14#include <unordered_map>
37#include "llvm/ADT/IntervalMap.h"
38#include "llvm/ADT/PointerUnion.h"
39#include "llvm/ADT/StringRef.h"
40#include "llvm/BinaryFormat/ELF.h"
41#include "llvm/Object/Decompressor.h"
42#include "llvm/Support/ARMBuildAttributes.h"
43#include "llvm/Support/CRC.h"
44#include "llvm/Support/FormatVariadic.h"
45#include "llvm/Support/MathExtras.h"
46#include "llvm/Support/MemoryBuffer.h"
47#include "llvm/Support/MipsABIFlags.h"
49#define CASE_AND_STREAM(s, def, width) \
51 s->Printf("%-*s", width, #def); \
57using namespace llvm::ELF;
104 ELFRelocation(
unsigned type);
110 static unsigned RelocType32(
const ELFRelocation &rel);
112 static unsigned RelocType64(
const ELFRelocation &rel);
114 static unsigned RelocSymbol32(
const ELFRelocation &rel);
116 static unsigned RelocSymbol64(
const ELFRelocation &rel);
118 static elf_addr RelocOffset32(
const ELFRelocation &rel);
120 static elf_addr RelocOffset64(
const ELFRelocation &rel);
122 static elf_sxword RelocAddend32(
const ELFRelocation &rel);
124 static elf_sxword RelocAddend64(
const ELFRelocation &rel);
126 bool IsRela() {
return (llvm::isa<ELFRela *>(reloc)); }
129 typedef llvm::PointerUnion<ELFRel *, ELFRela *> RelocUnion;
135ELFRelocation::ELFRelocation(
unsigned type) {
136 if (type == DT_REL || type == SHT_REL)
138 else if (type == DT_RELA || type == SHT_RELA)
141 assert(
false &&
"unexpected relocation type");
142 reloc =
static_cast<ELFRel *
>(
nullptr);
146ELFRelocation::~ELFRelocation() {
147 if (
auto *elfrel = llvm::dyn_cast<ELFRel *>(reloc))
150 delete llvm::cast<ELFRela *>(reloc);
155 if (
auto *elfrel = llvm::dyn_cast<ELFRel *>(reloc))
156 return elfrel->Parse(data, offset);
158 return llvm::cast<ELFRela *>(reloc)->Parse(data, offset);
161unsigned ELFRelocation::RelocType32(
const ELFRelocation &rel) {
162 if (
auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
168unsigned ELFRelocation::RelocType64(
const ELFRelocation &rel) {
169 if (
auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
175unsigned ELFRelocation::RelocSymbol32(
const ELFRelocation &rel) {
176 if (
auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
182unsigned ELFRelocation::RelocSymbol64(
const ELFRelocation &rel) {
183 if (
auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
189elf_addr ELFRelocation::RelocOffset32(
const ELFRelocation &rel) {
190 if (
auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
191 return elfrel->r_offset;
193 return llvm::cast<ELFRela *>(rel.reloc)->r_offset;
196elf_addr ELFRelocation::RelocOffset64(
const ELFRelocation &rel) {
197 if (
auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
198 return elfrel->r_offset;
200 return llvm::cast<ELFRela *>(rel.reloc)->r_offset;
203elf_sxword ELFRelocation::RelocAddend32(
const ELFRelocation &rel) {
204 if (llvm::isa<ELFRel *>(rel.reloc))
207 return llvm::cast<ELFRela *>(rel.reloc)->r_addend;
210elf_sxword ELFRelocation::RelocAddend64(
const ELFRelocation &rel) {
211 if (llvm::isa<ELFRel *>(rel.reloc))
214 return llvm::cast<ELFRela *>(rel.reloc)->r_addend;
234 if (strncmp(buf,
"CORE", 4) == 0) {
242 if (cstr ==
nullptr) {
244 LLDB_LOGF(log,
"Failed to parse note name lacking nul terminator");
253 const uint32_t mips_arch = header.
e_flags & llvm::ELF::EF_MIPS_ARCH;
254 uint32_t endian = header.
e_ident[EI_DATA];
256 uint32_t fileclass = header.
e_ident[EI_CLASS];
261 if (header.
e_type == ET_CORE) {
263 case llvm::ELF::ELFCLASS32:
266 case llvm::ELF::ELFCLASS64:
275 case llvm::ELF::EF_MIPS_ARCH_1:
276 case llvm::ELF::EF_MIPS_ARCH_2:
277 case llvm::ELF::EF_MIPS_ARCH_32:
280 case llvm::ELF::EF_MIPS_ARCH_32R2:
283 case llvm::ELF::EF_MIPS_ARCH_32R6:
286 case llvm::ELF::EF_MIPS_ARCH_3:
287 case llvm::ELF::EF_MIPS_ARCH_4:
288 case llvm::ELF::EF_MIPS_ARCH_5:
289 case llvm::ELF::EF_MIPS_ARCH_64:
292 case llvm::ELF::EF_MIPS_ARCH_64R2:
295 case llvm::ELF::EF_MIPS_ARCH_64R6:
306 uint32_t fileclass = header.
e_ident[EI_CLASS];
308 case llvm::ELF::ELFCLASS32:
310 case llvm::ELF::ELFCLASS64:
318 uint32_t endian = header.
e_ident[EI_DATA];
319 if (endian == ELFDATA2LSB)
326 uint32_t fileclass = header.
e_ident[EI_CLASS];
328 case llvm::ELF::ELFCLASS32:
330 case llvm::ELF::ELFCLASS64:
338 if (header.
e_machine == llvm::ELF::EM_MIPS)
340 else if (header.
e_machine == llvm::ELF::EM_PPC64)
342 else if (header.
e_machine == llvm::ELF::EM_RISCV)
344 else if (header.
e_machine == llvm::ELF::EM_LOONGARCH)
372 bool mapped_writable =
false;
378 mapped_writable =
true;
383 if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
386 const uint8_t *magic = data_sp->GetBytes() + data_offset;
391 if (data_sp->GetByteSize() < length) {
396 mapped_writable =
true;
397 magic = data_sp->GetBytes();
401 if (!mapped_writable) {
402 data_sp = std::make_shared<DataBufferHeap>(data_sp->GetBytes(),
403 data_sp->GetByteSize());
405 magic = data_sp->GetBytes();
409 if (address_size == 4 || address_size == 8) {
411 module_sp, data_sp, data_offset, file, file_offset, length));
412 ArchSpec spec = objfile_up->GetArchitecture();
413 if (spec && objfile_up->SetModulesArchitecture(spec))
414 return objfile_up.release();
423 if (!data_sp || data_sp->GetByteSize() < (llvm::ELF::EI_NIDENT))
425 const uint8_t *magic = data_sp->GetBytes();
434 if (!hdr.
Parse(data, &offset))
443 if (end_phdrs > data_sp->GetByteSize())
444 data_sp =
ReadMemory(process_sp, header_addr, end_phdrs);
446 std::unique_ptr<ObjectFileELF> objfile_up(
447 new ObjectFileELF(module_sp, data_sp, process_sp, header_addr));
448 ArchSpec spec = objfile_up->GetArchitecture();
449 if (spec && objfile_up->SetModulesArchitecture(spec))
450 return objfile_up.release();
459 data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
460 const uint8_t *magic = data_sp->GetBytes() + data_offset;
467 return llvm::crc32(init,
474 uint32_t core_notes_crc = 0;
477 if (H.p_type == llvm::ELF::PT_NOTE) {
478 const elf_off ph_offset = H.p_offset;
479 const size_t ph_size = H.p_filesz;
482 if (segment_data.
SetData(object_data, ph_offset, ph_size) != ph_size) {
488 core_notes_crc =
calc_crc32(core_notes_crc, segment_data);
492 return core_notes_crc;
496#define _MAKE_OSABI_CASE(x) \
499 switch (osabi_byte) {
521 return "<unknown-osabi>";
523#undef _MAKE_OSABI_CASE
533 llvm::Triple::OSType &ostype) {
534 switch (osabi_byte) {
536 ostype = llvm::Triple::OSType::AIX;
538 case ELFOSABI_FREEBSD:
539 ostype = llvm::Triple::OSType::FreeBSD;
542 ostype = llvm::Triple::OSType::Linux;
544 case ELFOSABI_NETBSD:
545 ostype = llvm::Triple::OSType::NetBSD;
547 case ELFOSABI_OPENBSD:
548 ostype = llvm::Triple::OSType::OpenBSD;
550 case ELFOSABI_SOLARIS:
551 ostype = llvm::Triple::OSType::Solaris;
554 ostype = llvm::Triple::OSType::UnknownOS;
556 return ostype != llvm::Triple::OSType::UnknownOS;
565 const size_t initial_count = specs.
GetSize();
572 if (header.
Parse(data, &header_offset)) {
589 llvm::Triple::OSType ostype;
590 llvm::Triple::VendorType vendor;
591 llvm::Triple::OSType spec_ostype =
594 LLDB_LOGF(log,
"ObjectFileELF::%s file '%s' module OSABI: %s",
595 __FUNCTION__, file.
GetPath().c_str(),
600 assert(vendor == llvm::Triple::UnknownVendor);
606 assert(spec_ostype == ostype);
607 if (spec_ostype != llvm::Triple::OSType::UnknownOS) {
609 "ObjectFileELF::%s file '%s' set ELF module OS type "
610 "from ELF header OSABI.",
611 __FUNCTION__, file.
GetPath().c_str());
618 if (data_sp->GetByteSize() < length)
628 header.
Parse(data, &header_offset);
631 uint32_t gnu_debuglink_crc = 0;
632 std::string gnu_debuglink_file;
637 gnu_debuglink_file, gnu_debuglink_crc,
643 "ObjectFileELF::%s file '%s' module set to triple: %s "
645 __FUNCTION__, file.
GetPath().c_str(),
646 spec_triple.getTriple().c_str(),
650 uint32_t core_notes_crc = 0;
652 if (!gnu_debuglink_crc) {
654 "Calculating module crc32 %s with size %" PRIu64
" KiB",
656 (length - file_offset) / 1024);
662 if (header.
e_type == llvm::ELF::ET_CORE) {
672 using u32le = llvm::support::ulittle32_t;
673 if (gnu_debuglink_crc) {
675 u32le data(gnu_debuglink_crc);
676 uuid =
UUID(&data,
sizeof(data));
677 }
else if (core_notes_crc) {
682 uuid =
UUID(data,
sizeof(data));
692 return specs.
GetSize() - initial_count;
701 :
ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset) {
710 :
ObjectFile(module_sp, process_sp, header_addr, header_data_sp) {}
717 bool value_is_offset) {
720 size_t num_loaded_sections = 0;
723 if (!value_is_offset) {
730 const size_t num_sections = section_list->
GetSize();
733 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
749 if (section_sp->IsThreadSpecific())
751 if (section_sp->Test(SHF_ALLOC) ||
763 load_addr &= 0xFFFFFFFF;
766 ++num_loaded_sections;
769 return num_loaded_sections > 0;
790 return AddressClass::eUnknown;
795 if (symtab_objfile !=
nullptr && symtab_objfile !=
this)
799 if (res != AddressClass::eCode)
806 return AddressClass::eCode;
835 using u32le = llvm::support::ulittle32_t;
837 uint32_t core_notes_crc = 0;
845 if (core_notes_crc) {
874 uint32_t num_specs = 0;
876 for (
unsigned i = 0; i < num_modules; ++i) {
895 if (symbol.
d_tag != DT_DEBUG && symbol.
d_tag != DT_MIPS_RLD_MAP &&
896 symbol.
d_tag != DT_MIPS_RLD_MAP_REL)
906 if (symbol.
d_tag == DT_DEBUG)
911 if ((symbol.
d_tag == DT_MIPS_RLD_MAP ||
912 symbol.
d_tag == DT_MIPS_RLD_MAP_REL) &&
919 if (symbol.
d_tag == DT_MIPS_RLD_MAP) {
925 if (symbol.
d_tag == DT_MIPS_RLD_MAP_REL) {
933 addr_t debug_ptr_address =
991 if (entry.symbol.d_tag != DT_NEEDED)
993 if (!entry.name.empty()) {
1008 if (!program_headers.empty())
1009 return program_headers.size();
1015 program_headers.resize(header.
e_phnum);
1016 if (program_headers.size() != header.
e_phnum)
1022 if (data.
SetData(object_data, ph_offset, ph_size) != ph_size)
1027 for (idx = 0, offset = 0; idx < header.
e_phnum; ++idx) {
1028 if (!program_headers[idx].Parse(data, &offset))
1032 if (idx < program_headers.size())
1033 program_headers.resize(idx);
1035 return program_headers.size();
1056 if (!
note.Parse(data, &offset)) {
1061 LLDB_LOGF(log,
"ObjectFileELF::%s parsing note name='%s', type=%" PRIu32,
1062 __FUNCTION__,
note.n_name.c_str(),
note.n_type);
1069 uint32_t version_info;
1070 if (data.
GetU32(&offset, &version_info, 1) ==
nullptr) {
1077 const uint32_t version_major = version_info / 100000;
1078 const uint32_t version_minor = (version_info / 1000) % 100;
1081 snprintf(os_name,
sizeof(os_name),
"freebsd%" PRIu32
".%" PRIu32,
1082 version_major, version_minor);
1085 arch_spec.
GetTriple().setOSName(os_name);
1086 arch_spec.
GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1089 "ObjectFileELF::%s detected FreeBSD %" PRIu32
".%" PRIu32
1091 __FUNCTION__, version_major, version_minor,
1092 static_cast<uint32_t
>(version_info % 1000));
1096 switch (
note.n_type) {
1100 uint32_t version_info[4];
1101 if (data.
GetU32(&offset, &version_info[0],
note.n_descsz / 4) ==
1109 switch (version_info[0]) {
1111 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1113 llvm::Triple::VendorType::UnknownVendor);
1115 "ObjectFileELF::%s detected Linux, min version %" PRIu32
1116 ".%" PRIu32
".%" PRIu32,
1117 __FUNCTION__, version_info[1], version_info[2],
1124 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
1126 llvm::Triple::VendorType::UnknownVendor);
1128 "ObjectFileELF::%s detected Hurd (unsupported), min "
1129 "version %" PRIu32
".%" PRIu32
".%" PRIu32,
1130 __FUNCTION__, version_info[1], version_info[2],
1134 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Solaris);
1136 llvm::Triple::VendorType::UnknownVendor);
1138 "ObjectFileELF::%s detected Solaris, min version %" PRIu32
1139 ".%" PRIu32
".%" PRIu32,
1140 __FUNCTION__, version_info[1], version_info[2],
1145 "ObjectFileELF::%s unrecognized OS in note, id %" PRIu32
1146 ", min version %" PRIu32
".%" PRIu32
".%" PRIu32,
1147 __FUNCTION__, version_info[0], version_info[1],
1148 version_info[2], version_info[3]);
1160 if (
note.n_descsz >= 4) {
1161 if (
const uint8_t *buf = data.
PeekData(offset,
note.n_descsz)) {
1166 "failed to read GNU_BUILD_ID note payload");
1173 if (arch_spec.
IsMIPS() &&
1174 arch_spec.
GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1176 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1184 uint32_t version_info;
1185 if (data.
GetU32(&offset, &version_info, 1) ==
nullptr) {
1197 const uint32_t version_major = version_info / 100000000;
1198 const uint32_t version_minor = (version_info % 100000000) / 1000000;
1199 const uint32_t version_patch = (version_info % 10000) / 100;
1202 llvm::formatv(
"netbsd{0}.{1}.{2}", version_major, version_minor,
1203 version_patch).str());
1204 arch_spec.
GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1210 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::NetBSD);
1211 arch_spec.
GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1216 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::OpenBSD);
1217 arch_spec.
GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1219 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1221 llvm::Triple::EnvironmentType::Android);
1225 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1249 if (
note.n_type == NT_FILE) {
1253 offset += count * 3 *
1255 for (
size_t i = 0; i < count; ++i) {
1257 if (cstr ==
nullptr) {
1259 "ObjectFileELF::%s trying to read "
1260 "at an offset after the end "
1261 "(GetCStr returned nullptr)",
1265 llvm::StringRef path(cstr);
1266 if (path.contains(
"/lib/x86_64-linux-gnu") || path.contains(
"/lib/i386-linux-gnu")) {
1267 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1271 if (arch_spec.
IsMIPS() &&
1272 arch_spec.
GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1275 arch_spec.
GetTriple().setOS(llvm::Triple::OSType::Linux);
1281 offset = note_offset +
note.GetByteSize();
1291 uint8_t FormatVersion = data.
GetU8(&Offset);
1292 if (FormatVersion != llvm::ELFAttrs::Format_Version)
1295 Offset = Offset +
sizeof(uint32_t);
1296 llvm::StringRef VendorName = data.
GetCStr(&Offset);
1298 if (VendorName !=
"aeabi")
1301 if (arch_spec.
GetTriple().getEnvironment() ==
1302 llvm::Triple::UnknownEnvironment)
1303 arch_spec.
GetTriple().setEnvironment(llvm::Triple::EABI);
1305 while (Offset < length) {
1306 uint8_t Tag = data.
GetU8(&Offset);
1307 uint32_t Size = data.
GetU32(&Offset);
1309 if (Tag != llvm::ARMBuildAttrs::File || Size == 0)
1312 while (Offset < length) {
1318 else if (Tag % 2 == 0)
1325 case llvm::ARMBuildAttrs::CPU_raw_name:
1326 case llvm::ARMBuildAttrs::CPU_name:
1331 case llvm::ARMBuildAttrs::ABI_VFP_args: {
1334 if (VFPArgs == llvm::ARMBuildAttrs::BaseAAPCS) {
1335 if (arch_spec.
GetTriple().getEnvironment() ==
1336 llvm::Triple::UnknownEnvironment ||
1337 arch_spec.
GetTriple().getEnvironment() == llvm::Triple::EABIHF)
1338 arch_spec.
GetTriple().setEnvironment(llvm::Triple::EABI);
1341 }
else if (VFPArgs == llvm::ARMBuildAttrs::HardFPAAPCS) {
1342 if (arch_spec.
GetTriple().getEnvironment() ==
1343 llvm::Triple::UnknownEnvironment ||
1344 arch_spec.
GetTriple().getEnvironment() == llvm::Triple::EABI)
1345 arch_spec.
GetTriple().setEnvironment(llvm::Triple::EABIHF);
1362 std::string &gnu_debuglink_file,
1363 uint32_t &gnu_debuglink_crc,
1366 if (!section_headers.empty())
1367 return section_headers.size();
1371 if (arch_spec.
GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) {
1372 llvm::Triple::OSType ostype;
1373 llvm::Triple::OSType spec_ostype;
1385 spec_ostype = arch_spec.
GetTriple().getOS();
1386 assert(spec_ostype == ostype);
1390 if (arch_spec.
GetMachine() == llvm::Triple::mips ||
1391 arch_spec.
GetMachine() == llvm::Triple::mipsel ||
1392 arch_spec.
GetMachine() == llvm::Triple::mips64 ||
1393 arch_spec.
GetMachine() == llvm::Triple::mips64el) {
1394 switch (header.
e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) {
1395 case llvm::ELF::EF_MIPS_MICROMIPS:
1398 case llvm::ELF::EF_MIPS_ARCH_ASE_M16:
1401 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX:
1409 if (arch_spec.
GetMachine() == llvm::Triple::arm ||
1410 arch_spec.
GetMachine() == llvm::Triple::thumb) {
1411 if (header.
e_flags & llvm::ELF::EF_ARM_SOFT_FLOAT)
1413 else if (header.
e_flags & llvm::ELF::EF_ARM_VFP_FLOAT)
1417 if (arch_spec.
GetMachine() == llvm::Triple::riscv32 ||
1418 arch_spec.
GetMachine() == llvm::Triple::riscv64) {
1419 uint32_t flags = arch_spec.
GetFlags();
1421 if (header.
e_flags & llvm::ELF::EF_RISCV_RVC)
1423 if (header.
e_flags & llvm::ELF::EF_RISCV_RVE)
1426 if ((header.
e_flags & llvm::ELF::EF_RISCV_FLOAT_ABI_SINGLE) ==
1427 llvm::ELF::EF_RISCV_FLOAT_ABI_SINGLE)
1429 else if ((header.
e_flags & llvm::ELF::EF_RISCV_FLOAT_ABI_DOUBLE) ==
1430 llvm::ELF::EF_RISCV_FLOAT_ABI_DOUBLE)
1432 else if ((header.
e_flags & llvm::ELF::EF_RISCV_FLOAT_ABI_QUAD) ==
1433 llvm::ELF::EF_RISCV_FLOAT_ABI_QUAD)
1439 if (arch_spec.
GetMachine() == llvm::Triple::loongarch32 ||
1440 arch_spec.
GetMachine() == llvm::Triple::loongarch64) {
1441 uint32_t flags = arch_spec.
GetFlags();
1442 switch (header.
e_flags & llvm::ELF::EF_LOONGARCH_ABI_MODIFIER_MASK) {
1443 case llvm::ELF::EF_LOONGARCH_ABI_SINGLE_FLOAT:
1446 case llvm::ELF::EF_LOONGARCH_ABI_DOUBLE_FLOAT:
1449 case llvm::ELF::EF_LOONGARCH_ABI_SOFT_FLOAT:
1462 section_headers.resize(header.
e_shnum);
1463 if (section_headers.size() != header.
e_shnum)
1469 if (sh_data.
SetData(object_data, sh_offset, sh_size) != sh_size)
1474 for (idx = 0, offset = 0; idx < header.
e_shnum; ++idx) {
1475 if (!section_headers[idx].Parse(sh_data, &offset))
1478 if (idx < section_headers.size())
1479 section_headers.resize(idx);
1481 const unsigned strtab_idx = header.
e_shstrndx;
1482 if (strtab_idx && strtab_idx < section_headers.size()) {
1484 const size_t byte_size = sheader.
sh_size;
1485 const Elf64_Off offset = sheader.
sh_offset;
1488 if (shstr_data.
SetData(object_data, offset, byte_size) == byte_size) {
1490 I != section_headers.end(); ++I) {
1491 static ConstString g_sect_name_gnu_debuglink(
".gnu_debuglink");
1493 const uint64_t section_size =
1497 I->section_name = name;
1499 if (arch_spec.
IsMIPS()) {
1500 uint32_t arch_flags = arch_spec.
GetFlags();
1502 if (sheader.
sh_type == SHT_MIPS_ABIFLAGS) {
1505 section_size) == section_size)) {
1508 arch_flags |= data.
GetU32(&offset);
1512 switch (data.
GetU8(&offset)) {
1513 case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY:
1516 case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE:
1519 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE:
1522 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT:
1525 case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64:
1528 case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX:
1531 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64:
1534 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A:
1541 switch (header.
e_flags & llvm::ELF::EF_MIPS_ABI) {
1542 case llvm::ELF::EF_MIPS_ABI_O32:
1545 case EF_MIPS_ABI_O64:
1548 case EF_MIPS_ABI_EABI32:
1551 case EF_MIPS_ABI_EABI64:
1556 if (header.
e_ident[EI_CLASS] == llvm::ELF::ELFCLASS64)
1558 else if (header.
e_flags & llvm::ELF::EF_MIPS_ABI2)
1565 if (arch_spec.
GetMachine() == llvm::Triple::arm ||
1566 arch_spec.
GetMachine() == llvm::Triple::thumb) {
1569 if (sheader.
sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 &&
1570 data.
SetData(object_data, sheader.
sh_offset, section_size) == section_size)
1574 if (name == g_sect_name_gnu_debuglink) {
1577 section_size) == section_size)) {
1579 gnu_debuglink_file = data.
GetCStr(&gnu_debuglink_offset);
1580 gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4);
1581 data.
GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1);
1586 bool is_note_header = (sheader.
sh_type == SHT_NOTE);
1590 static ConstString g_sect_name_android_ident(
".note.android.ident");
1591 if (!is_note_header && name == g_sect_name_android_ident)
1592 is_note_header =
true;
1594 if (is_note_header) {
1598 section_size) == section_size)) {
1601 LLDB_LOGF(log,
"ObjectFileELF::%s ELF note processing failed: %s",
1602 __FUNCTION__,
error.AsCString());
1609 if (arch_spec.
GetTriple().getVendor() == llvm::Triple::UnknownVendor)
1610 arch_spec.
GetTriple().setVendorName(llvm::StringRef());
1611 if (arch_spec.
GetTriple().getOS() == llvm::Triple::UnknownOS)
1612 arch_spec.
GetTriple().setOSName(llvm::StringRef());
1614 return section_headers.size();
1618 section_headers.clear();
1624 size_t pos = symbol_name.find(
'@');
1625 return symbol_name.substr(0, pos);
1656 if (Name.consume_front(
".debug_")) {
1657 return llvm::StringSwitch<SectionType>(Name)
1689 return llvm::StringSwitch<SectionType>(Name)
1740 Permissions Perm = Permissions(0);
1742 Perm |= ePermissionsReadable;
1744 Perm |= ePermissionsWritable;
1746 Perm |= ePermissionsExecutable;
1751 Permissions Perm = Permissions(0);
1753 Perm |= ePermissionsReadable;
1755 Perm |= ePermissionsWritable;
1757 Perm |= ePermissionsExecutable;
1765struct SectionAddressInfo {
1773class VMAddressProvider {
1775 llvm::IntervalMapHalfOpenInfo<addr_t>>;
1778 addr_t NextVMAddress = 0;
1779 VMMap::Allocator Alloc;
1781 VMMap Sections{Alloc};
1783 size_t SegmentCount = 0;
1784 std::string SegmentName;
1792 if ((ObjectType == ObjectFile::Type::eTypeObjectFile ||
1793 (ObjectType == ObjectFile::Type::eTypeDebugInfo && H.
sh_addr == 0)) &&
1796 llvm::alignTo(NextVMAddress, std::max<addr_t>(H.
sh_addralign, 1));
1798 NextVMAddress += Size;
1805 : ObjectType(
Type), SegmentName(std::string(SegmentName)) {}
1807 std::string GetNextSegmentName()
const {
1808 return llvm::formatv(
"{0}[{1}]", SegmentName, SegmentCount).str();
1813 LLDB_LOG(
Log,
"Ignoring zero-sized {0} segment. Corrupt object file?",
1815 return std::nullopt;
1819 LLDB_LOG(
Log,
"Ignoring overlapping {0} segment. Corrupt object file?",
1821 return std::nullopt;
1826 std::optional<SectionAddressInfo> GetAddressInfo(
const ELFSectionHeader &H) {
1830 if ((H.
sh_flags & SHF_ALLOC) && It.valid()) {
1838 LLDB_LOG(
Log,
"Shortening section crossing segment boundaries. "
1839 "Corrupt object file?");
1845 LLDB_LOG(
Log,
"Ignoring overlapping section. Corrupt object file?");
1846 return std::nullopt;
1850 return SectionAddressInfo{Segment,
Range};
1858 void AddSection(SectionAddressInfo Info,
SectionSP Sect) {
1859 if (Info.Range.GetByteSize() == 0)
1862 Info.Range.Slide(Info.Segment->GetFileAddress());
1863 Sections.insert(Info.Range.GetRangeBase(), Info.Range.GetRangeEnd(),
1877 addr_t vm_addr = section->GetFileAddress();
1879 offset_t byte_size = section->GetByteSize();
1880 bool thread_specific = section->IsThreadSpecific();
1881 uint32_t permissions = section->GetPermissions();
1882 uint32_t alignment = section->GetLog2Align();
1884 for (
auto sect : section_list) {
1885 if (sect->GetName() == name &&
1886 sect->IsThreadSpecific() == thread_specific &&
1887 sect->GetPermissions() == permissions &&
1888 sect->GetByteSize() == byte_size && sect->GetFileAddress() == vm_addr &&
1889 sect->GetLog2Align() == alignment) {
1907 VMAddressProvider regular_provider(
GetType(),
"PT_LOAD");
1908 VMAddressProvider tls_provider(
GetType(),
"PT_TLS");
1915 VMAddressProvider &provider =
1916 PHdr.
p_type == PT_TLS ? tls_provider : regular_provider;
1917 auto InfoOr = provider.GetAddressInfo(PHdr);
1921 uint32_t Log2Align = llvm::Log2_64(std::max<elf_xword>(PHdr.
p_align, 1));
1922 SectionSP Segment = std::make_shared<Section>(
1925 InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.
p_offset,
1928 Segment->SetIsThreadSpecific(PHdr.
p_type == PT_TLS);
1931 provider.AddSegment(*InfoOr, std::move(Segment));
1943 const uint64_t file_size =
1946 VMAddressProvider &provider =
1947 header.
sh_flags & SHF_TLS ? tls_provider : regular_provider;
1948 auto InfoOr = provider.GetAddressInfo(header);
1954 const uint32_t target_bytes_size =
1967 InfoOr->Range.GetRangeBase(),
1968 InfoOr->Range.GetByteSize(),
1973 target_bytes_size));
1976 section_sp->SetIsThreadSpecific(header.
sh_flags & SHF_TLS);
1977 (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *
m_sections_up)
1978 .AddSection(section_sp);
1979 provider.AddSection(std::move(*InfoOr), std::move(section_sp));
1991 if (
auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) {
1993 gdd_objfile_section_list->FindSectionByType(
1997 if (module_section_sp)
2001 unified_section_list.
AddSection(symtab_section_sp);
2018 "No LZMA support found for reading .gnu_debugdata section");
2024 section->GetSectionData(data);
2025 llvm::SmallVector<uint8_t, 0> uncompressedData;
2029 "An error occurred while decompression the section {0}: {1}",
2030 section->GetName().AsCString(), llvm::toString(std::move(err)).c_str());
2036 new DataBufferHeap(uncompressedData.data(), uncompressedData.size()));
2038 llvm::StringRef(
"gnu_debugdata"));
2040 GetModule(), gdd_data_buf, 0, &fspec, 0, gdd_data_buf->GetByteSize()));
2061 const char *dollar_pos = ::strchr(symbol_name,
'$');
2062 if (!dollar_pos || dollar_pos[1] ==
'\0')
2065 if (dollar_pos[2] ==
'\0' || dollar_pos[2] ==
'.')
2066 return dollar_pos[1];
2070#define STO_MIPS_ISA (3 << 6)
2071#define STO_MICROMIPS (2 << 6)
2072#define IS_MICROMIPS(ST_OTHER) (((ST_OTHER)&STO_MIPS_ISA) == STO_MICROMIPS)
2075std::pair<unsigned, ObjectFileELF::FileAddressToAddressClassMap>
2077 SectionList *section_list,
const size_t num_symbols,
2094 static ConstString rodata_section_name(
".rodata");
2095 static ConstString rodata1_section_name(
".rodata1");
2111 bool skip_oatdata_oatexec =
2112 file_extension ==
".oat" || file_extension ==
".odex";
2117 module_sp ? module_sp->GetSectionList() :
nullptr;
2124 std::unordered_map<lldb::SectionSP, lldb::SectionSP> section_map;
2127 for (i = 0; i < num_symbols; ++i) {
2128 if (!symbol.
Parse(symtab_data, &offset))
2136 if (symbol.
getType() != STT_SECTION &&
2137 (symbol_name ==
nullptr || symbol_name[0] ==
'\0'))
2142 if (skip_oatdata_oatexec && (::strcmp(symbol_name,
"oatdata") == 0 ||
2143 ::strcmp(symbol_name,
"oatexec") == 0))
2148 Elf64_Half shndx = symbol.
st_shndx;
2205 if (symbol_section_sp) {
2206 ConstString sect_name = symbol_section_sp->GetName();
2207 if (sect_name == text_section_name || sect_name == init_section_name ||
2208 sect_name == fini_section_name || sect_name == ctors_section_name ||
2209 sect_name == dtors_section_name) {
2211 }
else if (sect_name == data_section_name ||
2212 sect_name == data2_section_name ||
2213 sect_name == rodata_section_name ||
2214 sect_name == rodata1_section_name ||
2215 sect_name == bss_section_name) {
2221 int64_t symbol_value_offset = 0;
2222 uint32_t additional_flags = 0;
2225 if (arch.
GetMachine() == llvm::Triple::arm) {
2229 switch (mapping_symbol) {
2232 address_class_map[symbol.
st_value] = AddressClass::eCode;
2238 address_class_map[symbol.
st_value] =
2239 AddressClass::eCodeAlternateISA;
2243 address_class_map[symbol.
st_value] = AddressClass::eData;
2250 }
else if (arch.
GetMachine() == llvm::Triple::aarch64) {
2254 switch (mapping_symbol) {
2257 address_class_map[symbol.
st_value] = AddressClass::eCode;
2261 address_class_map[symbol.
st_value] = AddressClass::eData;
2270 if (arch.
GetMachine() == llvm::Triple::arm) {
2278 symbol_value_offset = -1;
2279 address_class_map[symbol.
st_value ^ 1] =
2280 AddressClass::eCodeAlternateISA;
2283 address_class_map[symbol.
st_value] = AddressClass::eCode;
2304 address_class_map[symbol.
st_value] = AddressClass::eCodeAlternateISA;
2307 address_class_map[symbol.
st_value] = AddressClass::eCodeAlternateISA;
2310 address_class_map[symbol.
st_value] = AddressClass::eCode;
2312 address_class_map[symbol.
st_value] = AddressClass::eData;
2314 address_class_map[symbol.
st_value] = AddressClass::eUnknown;
2321 uint64_t symbol_value = symbol.
st_value + symbol_value_offset;
2323 if (symbol_section_sp &&
2325 symbol_value -= symbol_section_sp->GetFileAddress();
2327 if (symbol_section_sp && module_section_list &&
2328 module_section_list != section_list) {
2329 auto section_it = section_map.find(symbol_section_sp);
2330 if (section_it == section_map.end()) {
2331 section_it = section_map
2332 .emplace(symbol_section_sp,
2337 if (section_it->second)
2338 symbol_section_sp = section_it->second;
2341 bool is_global = symbol.
getBinding() == STB_GLOBAL;
2342 uint32_t flags = symbol.
st_other << 8 | symbol.
st_info | additional_flags;
2343 llvm::StringRef symbol_ref(symbol_name);
2347 size_t version_pos = symbol_ref.find(
'@');
2348 bool has_suffix = version_pos != llvm::StringRef::npos;
2349 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
2355 llvm::StringRef suffix = symbol_ref.substr(version_pos);
2358 if (!mangled_name.empty())
2362 llvm::StringRef demangled_name = demangled.
GetStringRef();
2363 if (!demangled_name.empty())
2372 bool symbol_size_valid =
2375 bool is_trampoline =
false;
2384 if (trampoline_name.starts_with(
"__AArch64ADRPThunk_") ||
2385 trampoline_name.starts_with(
"__AArch64AbsLongThunk_")) {
2387 is_trampoline =
true;
2413 return {i, address_class_map};
2416std::pair<unsigned, ObjectFileELF::FileAddressToAddressClassMap>
2424 auto [num_symbols, address_class_map] =
2431 return {num_symbols, address_class_map};
2441 assert(symtab_hdr->
sh_type == SHT_SYMTAB ||
2442 symtab_hdr->
sh_type == SHT_DYNSYM);
2448 if (symtab && strtab) {
2458 return ParseSymbols(symbol_table, start_id, section_list, num_symbols,
2459 symtab_data, strtab_data);
2481 if (std::optional<DataExtractor> dynstr_data =
GetDynstrData()) {
2483 switch (entry.symbol.d_tag) {
2491 const char *name = dynstr_data->GetCStr(&cursor);
2493 entry.name = std::string(name);
2508 if (entry.symbol.d_tag == tag)
2509 return &entry.symbol;
2523 return symbol->
d_val;
2532static std::pair<uint64_t, uint64_t>
2548 if (plt_entsize <= 4) {
2558 plt_entsize = plt_hdr->
sh_size / (num_relocations + 1);
2563 return std::make_pair(plt_entsize, plt_offset);
2572 ELFRelocation rel(rel_type);
2576 uint64_t plt_offset, plt_entsize;
2577 std::tie(plt_entsize, plt_offset) =
2581 typedef unsigned (*reloc_info_fn)(
const ELFRelocation &rel);
2582 reloc_info_fn reloc_type;
2583 reloc_info_fn reloc_symbol;
2586 reloc_type = ELFRelocation::RelocType32;
2587 reloc_symbol = ELFRelocation::RelocSymbol32;
2589 reloc_type = ELFRelocation::RelocType64;
2590 reloc_symbol = ELFRelocation::RelocSymbol64;
2595 for (i = 0; i < num_relocations; ++i) {
2596 if (!rel.Parse(rel_data, &offset))
2599 if (reloc_type(rel) != slot_type)
2603 if (!symbol.
Parse(symtab_data, &symbol_offset))
2607 uint64_t plt_index = plt_offset + i * plt_entsize;
2634 assert(rel_hdr->
sh_type == SHT_RELA || rel_hdr->
sh_type == SHT_REL);
2648 if (!symtab_id || !plt_id)
2668 if (!plt_section_sp)
2697 rel_hdr, plt_hdr, sym_hdr, plt_section_sp,
2698 rel_data, symtab_data, strtab_data);
2710 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2711 uint64_t *dst =
reinterpret_cast<uint64_t *
>(
2713 ELFRelocation::RelocOffset64(rel));
2714 uint64_t val_offset = value + ELFRelocation::RelocAddend64(rel);
2715 memcpy(dst, &val_offset,
sizeof(uint64_t));
2721 Section *rel_section,
bool is_signed) {
2725 value += ELFRelocation::RelocAddend32(rel);
2728 ((int64_t)value >
INT32_MAX || (int64_t)value < INT32_MIN))) {
2730 LLDB_LOGF(log,
"Failed to apply debug info relocations");
2733 uint32_t truncated_addr = (value & 0xFFFFFFFF);
2737 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2738 uint32_t *dst =
reinterpret_cast<uint32_t *
>(
2740 ELFRelocation::RelocOffset32(rel));
2741 memcpy(dst, &truncated_addr,
sizeof(uint32_t));
2754 LLDB_LOGF(log,
"Debug info symbol invalid: %s", name);
2757 assert(llvm::isUInt<32>(value) &&
"Valid addresses are 32-bit");
2761 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2763 ELFRelocation::RelocOffset32(rel);
2766 memcpy(&addend, dst,
sizeof(int32_t));
2769 if (addend < 0 &&
static_cast<uint32_t
>(-addend) > value) {
2770 LLDB_LOGF(log,
"Debug info relocation overflow: 0x%" PRIx64,
2771 static_cast<int64_t
>(value) + addend);
2774 if (!llvm::isUInt<32>(value + addend)) {
2775 LLDB_LOGF(log,
"Debug info relocation out of range: 0x%" PRIx64, value);
2778 uint32_t addr = value + addend;
2779 memcpy(dst, &addr,
sizeof(uint32_t));
2788 ELFRelocation rel(rel_hdr->
sh_type);
2791 typedef unsigned (*reloc_info_fn)(
const ELFRelocation &rel);
2792 reloc_info_fn reloc_type;
2793 reloc_info_fn reloc_symbol;
2796 reloc_type = ELFRelocation::RelocType32;
2797 reloc_symbol = ELFRelocation::RelocSymbol32;
2799 reloc_type = ELFRelocation::RelocType64;
2800 reloc_symbol = ELFRelocation::RelocSymbol64;
2803 for (
unsigned i = 0; i < num_relocations; ++i) {
2804 if (!rel.Parse(rel_data, &offset)) {
2805 GetModule()->ReportError(
".rel{0}[{1:d}] failed to parse relocation",
2809 Symbol *symbol =
nullptr;
2813 case llvm::ELF::EM_ARM:
2814 switch (reloc_type(rel)) {
2819 GetModule()->ReportError(
"unsupported AArch32 relocation:"
2820 " .rel{0}[{1}], type {2}",
2825 assert(
false &&
"unexpected relocation type");
2828 case llvm::ELF::EM_386:
2829 switch (reloc_type(rel)) {
2834 rel_section->
GetFileOffset() + ELFRelocation::RelocOffset32(rel);
2838 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2839 uint32_t *dst =
reinterpret_cast<uint32_t *
>(
2840 data_buffer->
GetBytes() + f_offset);
2844 value += ELFRelocation::RelocAddend32(rel);
2850 GetModule()->ReportError(
".rel{0}[{1}] unknown symbol id: {2:d}",
2857 GetModule()->ReportError(
"unsupported i386 relocation:"
2858 " .rel{0}[{1}], type {2}",
2863 assert(
false &&
"unexpected relocation type");
2868 GetModule()->ReportError(
"unsupported 32-bit ELF machine arch: {0}", hdr->
e_machine);
2873 case llvm::ELF::EM_AARCH64:
2874 switch (reloc_type(rel)) {
2875 case R_AARCH64_ABS64:
2878 case R_AARCH64_ABS32:
2882 assert(
false &&
"unexpected relocation type");
2885 case llvm::ELF::EM_LOONGARCH:
2886 switch (reloc_type(rel)) {
2894 assert(
false &&
"unexpected relocation type");
2897 case llvm::ELF::EM_X86_64:
2898 switch (reloc_type(rel)) {
2911 assert(
false &&
"unexpected relocation type");
2915 GetModule()->ReportError(
"unsupported 64-bit ELF machine arch: {0}", hdr->
e_machine);
2927 assert(rel_hdr->
sh_type == SHT_RELA || rel_hdr->
sh_type == SHT_REL);
2965 rel_data, symtab_data, debug_data, debug);
2976 Progress progress(
"Parsing symbol table",
2982 ObjectFile *module_obj_file = module_sp->GetObjectFile();
2983 if (module_obj_file && module_obj_file !=
this)
2986 SectionList *section_list = module_sp->GetSectionList();
2990 uint64_t symbol_id = 0;
3000 auto [num_symbols, address_class_map] =
3003 symbol_id += num_symbols;
3018 auto [num_symbols, address_class_map] =
3020 symbol_id += num_symbols;
3024 uint32_t dynamic_num_symbols = 0;
3025 std::optional<DataExtractor> symtab_data =
3028 if (symtab_data && strtab_data) {
3029 auto [num_symbols_parsed, address_class_map] =
ParseSymbols(
3030 &lldb_symtab, symbol_id, section_list, dynamic_num_symbols,
3031 symtab_data.value(), strtab_data.value());
3032 symbol_id += num_symbols_parsed;
3053 if (reloc_section) {
3063 GetModule()->GetUnwindTable().GetEHFrameInfo()) {
3077 bool is_valid_entry_point =
3078 entry_point_addr.IsValid() && entry_point_addr.IsSectionOffset();
3079 addr_t entry_point_file_addr = entry_point_addr.GetFileAddress();
3081 entry_point_file_addr)) {
3086 SectionSP section_sp = entry_point_addr.GetSection();
3105 if (arch.
GetMachine() == llvm::Triple::arm &&
3106 (entry_point_file_addr & 1)) {
3109 AddressClass::eCodeAlternateISA;
3120 static const char *debug_prefix =
".debug";
3132 if (section_name ==
nullptr)
3136 if (strncmp(section_name, debug_prefix, strlen(debug_prefix)))
3140 std::string needle = std::string(
".rel") + section_name;
3141 std::string needlea = std::string(
".rela") + section_name;
3145 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) {
3146 const char *hay_name = I->section_name.GetCString();
3147 if (hay_name ==
nullptr)
3149 if (needle == hay_name || needlea == hay_name) {
3170 std::vector<Symbol> new_symbols;
3173 uint64_t last_symbol_id =
3180 symbol->SetByteSize(size);
3181 symbol->SetSizeIsSynthesized(true);
3187 addr_t offset = file_addr - section_sp->GetFileAddress();
3188 uint64_t symbol_id = ++last_symbol_id;
3206 new_symbols.push_back(eh_symbol);
3212 for (
const Symbol &s : new_symbols)
3232 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
3233 s->
Printf(
"%p: ",
static_cast<void *
>(
this));
3239 *s <<
", file = '" <<
m_file
3264 if (image_info_addr.
IsValid())
3265 s->
Printf(
"image_info_address = %#16.16" PRIx64
"\n",
3274 s->
Printf(
"e_ident[EI_MAG0 ] = 0x%2.2x\n", header.
e_ident[EI_MAG0]);
3275 s->
Printf(
"e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", header.
e_ident[EI_MAG1],
3277 s->
Printf(
"e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", header.
e_ident[EI_MAG2],
3279 s->
Printf(
"e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", header.
e_ident[EI_MAG3],
3282 s->
Printf(
"e_ident[EI_CLASS ] = 0x%2.2x\n", header.
e_ident[EI_CLASS]);
3283 s->
Printf(
"e_ident[EI_DATA ] = 0x%2.2x ", header.
e_ident[EI_DATA]);
3285 s->
Printf(
"\ne_ident[EI_VERSION] = 0x%2.2x\n", header.
e_ident[EI_VERSION]);
3286 s->
Printf(
"e_ident[EI_PAD ] = 0x%2.2x\n", header.
e_ident[EI_PAD]);
3333 unsigned char ei_data) {
3336 *s <<
"ELFDATANONE";
3339 *s <<
"ELFDATA2LSB - Little Endian";
3342 *s <<
"ELFDATA2MSB - Big Endian";
3355 s->
Printf(
" %8.8" PRIx64
" %8.8" PRIx64
" %8.8" PRIx64, ph.
p_offset,
3369 const int kStrWidth = 15;
3381 s->
Printf(
"0x%8.8x%*s", p_type, kStrWidth - 10,
"");
3390 *s << ((p_flags & PF_X) ?
"PF_X" :
" ")
3391 << (((p_flags & PF_X) && (p_flags & PF_W)) ?
'+' :
' ')
3392 << ((p_flags & PF_W) ?
"PF_W" :
" ")
3393 << (((p_flags & PF_W) && (p_flags & PF_R)) ?
'+' :
' ')
3394 << ((p_flags & PF_R) ?
"PF_R" :
" ");
3405 s->
PutCString(
"IDX p_type p_offset p_vaddr p_paddr "
3406 "p_filesz p_memsz p_flags p_align\n");
3407 s->
PutCString(
"==== --------------- -------- -------- -------- "
3408 "-------- -------- ------------------------- --------\n");
3411 s->
Format(
"[{0,2}] ", H.index());
3426 s->
Printf(
") %8.8" PRIx64
" %8.8" PRIx64
" %8.8" PRIx64, sh.
sh_addr,
3437 const int kStrWidth = 12;
3456 s->
Printf(
"0x%8.8x%*s", sh_type, kStrWidth - 10,
"");
3466 *s << ((sh_flags & SHF_WRITE) ?
"WRITE" :
" ")
3467 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ?
'+' :
' ')
3468 << ((sh_flags & SHF_ALLOC) ?
"ALLOC" :
" ")
3469 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ?
'+' :
' ')
3470 << ((sh_flags & SHF_EXECINSTR) ?
"EXECINSTR" :
" ");
3482 "addr offset size link info addralgn "
3484 s->
PutCString(
"==== -------- ------------ -------------------------------- "
3485 "-------- -------- -------- -------- -------- -------- "
3486 "-------- ====================\n");
3491 s->
Printf(
"[%2u] ", idx);
3493 const char *section_name = I->section_name.AsCString(
"");
3495 *s <<
' ' << section_name <<
"\n";
3502 if (num_modules > 0) {
3504 for (
unsigned i = 0; i < num_modules; ++i) {
3512#define DYNAMIC_STRINGIFY_ENUM(tag, value) \
3516#define DYNAMIC_TAG(n, v)
3518 case llvm::ELF::EM_AARCH64:
3520#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3521#include "llvm/BinaryFormat/DynamicTags.def"
3522#undef AARCH64_DYNAMIC_TAG
3526 case llvm::ELF::EM_HEXAGON:
3528#define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3529#include "llvm/BinaryFormat/DynamicTags.def"
3530#undef HEXAGON_DYNAMIC_TAG
3534 case llvm::ELF::EM_MIPS:
3536#define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3537#include "llvm/BinaryFormat/DynamicTags.def"
3538#undef MIPS_DYNAMIC_TAG
3542 case llvm::ELF::EM_PPC:
3544#define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3545#include "llvm/BinaryFormat/DynamicTags.def"
3546#undef PPC_DYNAMIC_TAG
3550 case llvm::ELF::EM_PPC64:
3552#define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3553#include "llvm/BinaryFormat/DynamicTags.def"
3554#undef PPC64_DYNAMIC_TAG
3558 case llvm::ELF::EM_RISCV:
3560#define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3561#include "llvm/BinaryFormat/DynamicTags.def"
3562#undef RISCV_DYNAMIC_TAG
3569#define AARCH64_DYNAMIC_TAG(name, value)
3570#define MIPS_DYNAMIC_TAG(name, value)
3571#define HEXAGON_DYNAMIC_TAG(name, value)
3572#define PPC_DYNAMIC_TAG(name, value)
3573#define PPC64_DYNAMIC_TAG(name, value)
3574#define RISCV_DYNAMIC_TAG(name, value)
3576#define DYNAMIC_TAG_MARKER(name, value)
3577#define DYNAMIC_TAG(name, value) \
3580#include "llvm/BinaryFormat/DynamicTags.def"
3582#undef AARCH64_DYNAMIC_TAG
3583#undef MIPS_DYNAMIC_TAG
3584#undef HEXAGON_DYNAMIC_TAG
3585#undef PPC_DYNAMIC_TAG
3586#undef PPC64_DYNAMIC_TAG
3587#undef RISCV_DYNAMIC_TAG
3588#undef DYNAMIC_TAG_MARKER
3589#undef DYNAMIC_STRINGIFY_ENUM
3591 return "<unknown:>0x" + llvm::utohexstr(
Type,
true);
3602 s->
PutCString(
"==== ---------------- ------------------\n");
3605 s->
Printf(
"[%2u] ", idx++);
3607 "%-16s 0x%16.16" PRIx64,
3609 entry.symbol.d_ptr);
3610 if (!entry.name.empty())
3611 s->
Printf(
" \"%s\"", entry.name.c_str());
3630 if (H.p_type != PT_NOTE || H.p_offset == 0 || H.p_filesz == 0)
3633 if (data.
SetData(
m_data, H.p_offset, H.p_filesz) == H.p_filesz) {
3644 case llvm::ELF::ET_NONE:
3648 case llvm::ELF::ET_REL:
3652 case llvm::ELF::ET_EXEC:
3656 case llvm::ELF::ET_DYN:
3672 case llvm::ELF::ET_NONE:
3676 case llvm::ELF::ET_REL:
3680 case llvm::ELF::ET_EXEC:
3685 static ConstString loader_section_name(
".interp");
3688 if (loader_section) {
3696 llvm::StringRef loader_name(buffer, read_size - 1);
3697 llvm::StringRef freebsd_kernel_loader_name(
"/red/herring");
3698 if (loader_name == freebsd_kernel_loader_name)
3705 case llvm::ELF::ET_DYN:
3733 if (!section->
Test(SHF_COMPRESSED))
3740 return data.
CopyData(section_offset, dst_len, dst);
3750 if (result == 0 || !(section->
Get() & llvm::ELF::SHF_COMPRESSED))
3753 auto Decompressor = llvm::object::Decompressor::create(
3755 {reinterpret_cast<const char *>(section_data.GetDataStart()),
3756 size_t(section_data.GetByteSize())},
3758 if (!Decompressor) {
3760 "Unable to initialize decompressor for section '{0}': {1}",
3762 llvm::toString(Decompressor.takeError()).c_str());
3763 section_data.
Clear();
3768 std::make_shared<DataBufferHeap>(Decompressor->getDecompressedSize(), 0);
3769 if (
auto error = Decompressor->decompress(
3770 {buffer_sp->GetBytes(), size_t(buffer_sp->GetByteSize())})) {
3771 GetModule()->ReportWarning(
"Decompression of section '{0}' failed: {1}",
3773 llvm::toString(std::move(
error)).c_str());
3774 section_data.
Clear();
3778 section_data.
SetData(buffer_sp);
3779 return buffer_sp->GetByteSize();
3816std::vector<ObjectFile::LoadableData>
3820 std::vector<LoadableData> loadables;
3824 if (H.p_type != llvm::ELF::PT_LOAD)
3826 loadable.
Dest = should_use_paddr ? H.p_paddr : H.p_vaddr;
3829 if (H.p_filesz == 0)
3832 loadable.
Contents = llvm::ArrayRef<uint8_t>(segment_data.GetDataStart(),
3833 segment_data.GetByteSize());
3834 loadables.push_back(loadable);
3846std::optional<DataExtractor>
3863 return std::nullopt;
3869 return std::nullopt;
3879 assert(dynamic->GetObjectFile() ==
this);
3885 section_list->FindSectionByID(header->sh_link).get()) {
3904 if (strtab ==
nullptr || strsz ==
nullptr)
3905 return std::nullopt;
3916 if (H.p_type == llvm::ELF::PT_DYNAMIC) {
3931 assert(dynamic->GetObjectFile() ==
this);
3938 return std::nullopt;
3943 if (hash ==
nullptr)
3944 return std::nullopt;
3947 struct DtHashHeader {
3954 offset_t offset = offsetof(DtHashHeader, nchain);
3955 return data->
GetU32(&offset);
3958 return std::nullopt;
3963 if (gnu_hash ==
nullptr)
3964 return std::nullopt;
3968 struct DtGnuHashHeader {
3969 uint32_t nbuckets = 0;
3970 uint32_t symoffset = 0;
3971 uint32_t bloom_size = 0;
3972 uint32_t bloom_shift = 0;
3974 uint32_t num_symbols = 0;
3978 DtGnuHashHeader header;
3979 header.nbuckets = data->
GetU32(&offset);
3980 header.symoffset = data->
GetU32(&offset);
3981 header.bloom_size = data->
GetU32(&offset);
3982 header.bloom_shift = data->
GetU32(&offset);
3984 const addr_t buckets_offset =
3985 sizeof(DtGnuHashHeader) + addr_size * header.bloom_size;
3986 std::vector<uint32_t> buckets;
3990 for (uint32_t i = 0; i < header.nbuckets; ++i)
3991 buckets.push_back(bucket_data->GetU32(&offset));
3993 uint32_t last_symbol = 0;
3994 for (uint32_t bucket_value : buckets)
3995 last_symbol = std::max(bucket_value, last_symbol);
3996 if (last_symbol < header.symoffset) {
3997 num_symbols = header.symoffset;
4000 const addr_t chains_base_offset = buckets_offset + header.nbuckets * 4;
4004 chains_base_offset + (last_symbol - header.symoffset) * 4)) {
4006 uint32_t chain_entry = chain_entry_data->GetU32(&offset);
4009 if (chain_entry & 1)
4015 num_symbols = last_symbol;
4019 if (num_symbols > 0)
4022 return std::nullopt;
4025std::optional<DataExtractor>
4043 if (symtab ==
nullptr || syment ==
nullptr)
4044 return std::nullopt;
4047 num_symbols = *syms;
4049 num_symbols = *syms;
4051 return std::nullopt;
4052 if (num_symbols == 0)
4053 return std::nullopt;
static llvm::raw_ostream & error(Stream &strm)
static llvm::raw_ostream & note(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 std::string getDynamicTagAsString(uint16_t Arch, uint64_t Type)
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)
std::optional< lldb_private::DataExtractor > GetDynsymDataFromDynamic(uint32_t &num_symbols)
Get the bytes that represent the dynamic symbol table from the .dynamic section from process memory.
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.
std::optional< uint32_t > GetNumSymbolsFromDynamicGnuHash()
Get the number of symbols from the DT_GNU_HASH dynamic entry.
std::optional< lldb_private::DataExtractor > ReadDataFromDynamic(const elf::ELFDynamic *dyn, uint64_t length, uint64_t offset=0)
Read the bytes pointed to by the dyn dynamic entry.
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)
std::optional< lldb_private::DataExtractor > GetDynamicData()
Get the bytes that represent the .dynamic section.
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...
std::optional< uint32_t > GetNumSymbolsFromDynamicHash()
Get the number of symbols from the DT_HASH dynamic entry.
bool ParseProgramHeaders()
Parses all section headers present in this object file and populates m_program_headers.
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.
void DumpELFDynamic(lldb_private::Stream *s)
ELF dump the .dynamic section.
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)
lldb::addr_t m_dynamic_base_addr
The file address of the .dynamic section.
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()
std::optional< lldb_private::DataExtractor > GetDynstrData()
Get the bytes that represent the dynamic string table data.
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.
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
bool ResolveAddressUsingFileSections(lldb::addr_t addr, const SectionList *sections)
Resolve a file virtual address using a section list.
lldb::SectionSP GetSection() const
Get const accessor for the section.
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.
@ eLoongArch_abi_single_float
soft float
@ eLoongArch_abi_double_float
single precision floating point, +f
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)
const lldb::addr_t m_memory_addr
Set if the object file only exists in memory.
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.
static lldb::WritableDataBufferSP ReadMemory(const lldb::ProcessSP &process_sp, lldb::addr_t addr, size_t byte_size)
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).
bool IsInMemory() const
Returns true if the object file exists only in memory.
lldb::ProcessWP m_process_wp
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
ConstString GetName() const
void SetIsRelocated(bool b)
lldb::offset_t GetFileOffset() const
ObjectFile * GetObjectFile()
lldb::offset_t GetFileSize() const
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
static Status FromErrorString(const char *str)
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
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)
bool SetSectionLoadAddress(const lldb::SectionSP §ion, lldb::addr_t load_addr, bool warn_multiple=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.
@ eSectionTypeLLDBFormatters
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
@ eSectionTypeDWARFDebugRngLists
DWARF v5 .debug_rnglists.
@ eSectionTypeDWARFDebugStrOffsetsDwo
@ eSectionTypeDWARFDebugMacro
@ eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugTypesDwo
@ eSectionTypeDWARFDebugRanges
@ eSectionTypeDWARFDebugRngListsDwo
@ eSectionTypeLLDBTypeSummaries
@ 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.
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.