LLDB mainline
ObjectFileELF.cpp
Go to the documentation of this file.
1//===-- ObjectFileELF.cpp -------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "ObjectFileELF.h"
10
11#include <algorithm>
12#include <cassert>
13#include <optional>
14#include <unordered_map>
15
16#include "lldb/Core/Module.h"
19#include "lldb/Core/Progress.h"
20#include "lldb/Core/Section.h"
22#include "lldb/Host/LZMA.h"
25#include "lldb/Target/Process.h"
27#include "lldb/Target/Target.h"
32#include "lldb/Utility/Log.h"
34#include "lldb/Utility/Status.h"
35#include "lldb/Utility/Stream.h"
36#include "lldb/Utility/Timer.h"
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"
48
49#define CASE_AND_STREAM(s, def, width) \
50 case def: \
51 s->Printf("%-*s", width, #def); \
52 break;
53
54using namespace lldb;
55using namespace lldb_private;
56using namespace elf;
57using namespace llvm::ELF;
58
60
61// ELF note owner definitions
62static const char *const LLDB_NT_OWNER_FREEBSD = "FreeBSD";
63static const char *const LLDB_NT_OWNER_GNU = "GNU";
64static const char *const LLDB_NT_OWNER_NETBSD = "NetBSD";
65static const char *const LLDB_NT_OWNER_NETBSDCORE = "NetBSD-CORE";
66static const char *const LLDB_NT_OWNER_OPENBSD = "OpenBSD";
67static const char *const LLDB_NT_OWNER_ANDROID = "Android";
68static const char *const LLDB_NT_OWNER_CORE = "CORE";
69static const char *const LLDB_NT_OWNER_LINUX = "LINUX";
70
71// ELF note type definitions
74
75static const elf_word LLDB_NT_GNU_ABI_TAG = 0x01;
77
79
84
85// GNU ABI note OS constants
89
90namespace {
91
92//===----------------------------------------------------------------------===//
93/// \class ELFRelocation
94/// Generic wrapper for ELFRel and ELFRela.
95///
96/// This helper class allows us to parse both ELFRel and ELFRela relocation
97/// entries in a generic manner.
98class ELFRelocation {
99public:
100 /// Constructs an ELFRelocation entry with a personality as given by @p
101 /// type.
102 ///
103 /// \param type Either DT_REL or DT_RELA. Any other value is invalid.
104 ELFRelocation(unsigned type);
105
106 ~ELFRelocation();
107
108 bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
109
110 static unsigned RelocType32(const ELFRelocation &rel);
111
112 static unsigned RelocType64(const ELFRelocation &rel);
113
114 static unsigned RelocSymbol32(const ELFRelocation &rel);
115
116 static unsigned RelocSymbol64(const ELFRelocation &rel);
117
118 static elf_addr RelocOffset32(const ELFRelocation &rel);
119
120 static elf_addr RelocOffset64(const ELFRelocation &rel);
121
122 static elf_sxword RelocAddend32(const ELFRelocation &rel);
123
124 static elf_sxword RelocAddend64(const ELFRelocation &rel);
125
126 bool IsRela() { return (llvm::isa<ELFRela *>(reloc)); }
127
128private:
129 typedef llvm::PointerUnion<ELFRel *, ELFRela *> RelocUnion;
130
131 RelocUnion reloc;
132};
133} // end anonymous namespace
134
135ELFRelocation::ELFRelocation(unsigned type) {
136 if (type == DT_REL || type == SHT_REL)
137 reloc = new ELFRel();
138 else if (type == DT_RELA || type == SHT_RELA)
139 reloc = new ELFRela();
140 else {
141 assert(false && "unexpected relocation type");
142 reloc = static_cast<ELFRel *>(nullptr);
143 }
144}
145
146ELFRelocation::~ELFRelocation() {
147 if (auto *elfrel = llvm::dyn_cast<ELFRel *>(reloc))
148 delete elfrel;
149 else
150 delete llvm::cast<ELFRela *>(reloc);
151}
152
153bool ELFRelocation::Parse(const lldb_private::DataExtractor &data,
154 lldb::offset_t *offset) {
155 if (auto *elfrel = llvm::dyn_cast<ELFRel *>(reloc))
156 return elfrel->Parse(data, offset);
157 else
158 return llvm::cast<ELFRela *>(reloc)->Parse(data, offset);
159}
160
161unsigned ELFRelocation::RelocType32(const ELFRelocation &rel) {
162 if (auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
163 return ELFRel::RelocType32(*elfrel);
164 else
165 return ELFRela::RelocType32(*llvm::cast<ELFRela *>(rel.reloc));
166}
167
168unsigned ELFRelocation::RelocType64(const ELFRelocation &rel) {
169 if (auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
170 return ELFRel::RelocType64(*elfrel);
171 else
172 return ELFRela::RelocType64(*llvm::cast<ELFRela *>(rel.reloc));
173}
174
175unsigned ELFRelocation::RelocSymbol32(const ELFRelocation &rel) {
176 if (auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
177 return ELFRel::RelocSymbol32(*elfrel);
178 else
179 return ELFRela::RelocSymbol32(*llvm::cast<ELFRela *>(rel.reloc));
180}
181
182unsigned ELFRelocation::RelocSymbol64(const ELFRelocation &rel) {
183 if (auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
184 return ELFRel::RelocSymbol64(*elfrel);
185 else
186 return ELFRela::RelocSymbol64(*llvm::cast<ELFRela *>(rel.reloc));
187}
188
189elf_addr ELFRelocation::RelocOffset32(const ELFRelocation &rel) {
190 if (auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
191 return elfrel->r_offset;
192 else
193 return llvm::cast<ELFRela *>(rel.reloc)->r_offset;
194}
195
196elf_addr ELFRelocation::RelocOffset64(const ELFRelocation &rel) {
197 if (auto *elfrel = llvm::dyn_cast<ELFRel *>(rel.reloc))
198 return elfrel->r_offset;
199 else
200 return llvm::cast<ELFRela *>(rel.reloc)->r_offset;
201}
202
203elf_sxword ELFRelocation::RelocAddend32(const ELFRelocation &rel) {
204 if (llvm::isa<ELFRel *>(rel.reloc))
205 return 0;
206 else
207 return llvm::cast<ELFRela *>(rel.reloc)->r_addend;
208}
209
210elf_sxword ELFRelocation::RelocAddend64(const ELFRelocation &rel) {
211 if (llvm::isa<ELFRel *>(rel.reloc))
212 return 0;
213 else
214 return llvm::cast<ELFRela *>(rel.reloc)->r_addend;
215}
216
217static user_id_t SegmentID(size_t PHdrIndex) {
218 return ~user_id_t(PHdrIndex);
219}
220
221bool ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset) {
222 // Read all fields.
223 if (data.GetU32(offset, &n_namesz, 3) == nullptr)
224 return false;
225
226 // The name field is required to be nul-terminated, and n_namesz includes the
227 // terminating nul in observed implementations (contrary to the ELF-64 spec).
228 // A special case is needed for cores generated by some older Linux versions,
229 // which write a note named "CORE" without a nul terminator and n_namesz = 4.
230 if (n_namesz == 4) {
231 char buf[4];
232 if (data.ExtractBytes(*offset, 4, data.GetByteOrder(), buf) != 4)
233 return false;
234 if (strncmp(buf, "CORE", 4) == 0) {
235 n_name = "CORE";
236 *offset += 4;
237 return true;
238 }
239 }
240
241 const char *cstr = data.GetCStr(offset, llvm::alignTo(n_namesz, 4));
242 if (cstr == nullptr) {
243 Log *log = GetLog(LLDBLog::Symbols);
244 LLDB_LOGF(log, "Failed to parse note name lacking nul terminator");
245
246 return false;
247 }
248 n_name = cstr;
249 return true;
250}
251
252static uint32_t mipsVariantFromElfFlags (const elf::ELFHeader &header) {
253 const uint32_t mips_arch = header.e_flags & llvm::ELF::EF_MIPS_ARCH;
254 uint32_t endian = header.e_ident[EI_DATA];
255 uint32_t arch_variant = ArchSpec::eMIPSSubType_unknown;
256 uint32_t fileclass = header.e_ident[EI_CLASS];
257
258 // If there aren't any elf flags available (e.g core elf file) then return
259 // default
260 // 32 or 64 bit arch (without any architecture revision) based on object file's class.
261 if (header.e_type == ET_CORE) {
262 switch (fileclass) {
263 case llvm::ELF::ELFCLASS32:
264 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
266 case llvm::ELF::ELFCLASS64:
267 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
269 default:
270 return arch_variant;
271 }
272 }
273
274 switch (mips_arch) {
275 case llvm::ELF::EF_MIPS_ARCH_1:
276 case llvm::ELF::EF_MIPS_ARCH_2:
277 case llvm::ELF::EF_MIPS_ARCH_32:
278 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
280 case llvm::ELF::EF_MIPS_ARCH_32R2:
281 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r2el
283 case llvm::ELF::EF_MIPS_ARCH_32R6:
284 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r6el
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:
290 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
292 case llvm::ELF::EF_MIPS_ARCH_64R2:
293 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r2el
295 case llvm::ELF::EF_MIPS_ARCH_64R6:
296 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r6el
298 default:
299 break;
300 }
301
302 return arch_variant;
303}
304
305static uint32_t riscvVariantFromElfFlags(const elf::ELFHeader &header) {
306 uint32_t fileclass = header.e_ident[EI_CLASS];
307 switch (fileclass) {
308 case llvm::ELF::ELFCLASS32:
310 case llvm::ELF::ELFCLASS64:
312 default:
314 }
315}
316
317static uint32_t ppc64VariantFromElfFlags(const elf::ELFHeader &header) {
318 uint32_t endian = header.e_ident[EI_DATA];
319 if (endian == ELFDATA2LSB)
321 else
323}
324
325static uint32_t loongarchVariantFromElfFlags(const elf::ELFHeader &header) {
326 uint32_t fileclass = header.e_ident[EI_CLASS];
327 switch (fileclass) {
328 case llvm::ELF::ELFCLASS32:
330 case llvm::ELF::ELFCLASS64:
332 default:
334 }
335}
336
337static uint32_t subTypeFromElfHeader(const elf::ELFHeader &header) {
338 if (header.e_machine == llvm::ELF::EM_MIPS)
339 return mipsVariantFromElfFlags(header);
340 else if (header.e_machine == llvm::ELF::EM_PPC64)
341 return ppc64VariantFromElfFlags(header);
342 else if (header.e_machine == llvm::ELF::EM_RISCV)
343 return riscvVariantFromElfFlags(header);
344 else if (header.e_machine == llvm::ELF::EM_LOONGARCH)
345 return loongarchVariantFromElfFlags(header);
346
348}
349
351
352// Arbitrary constant used as UUID prefix for core files.
353const uint32_t ObjectFileELF::g_core_uuid_magic(0xE210C);
354
355// Static methods.
360}
361
364}
365
367 DataBufferSP data_sp,
368 lldb::offset_t data_offset,
369 const lldb_private::FileSpec *file,
370 lldb::offset_t file_offset,
371 lldb::offset_t length) {
372 bool mapped_writable = false;
373 if (!data_sp) {
374 data_sp = MapFileDataWritable(*file, length, file_offset);
375 if (!data_sp)
376 return nullptr;
377 data_offset = 0;
378 mapped_writable = true;
379 }
380
381 assert(data_sp);
382
383 if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
384 return nullptr;
385
386 const uint8_t *magic = data_sp->GetBytes() + data_offset;
387 if (!ELFHeader::MagicBytesMatch(magic))
388 return nullptr;
389
390 // Update the data to contain the entire file if it doesn't already
391 if (data_sp->GetByteSize() < length) {
392 data_sp = MapFileDataWritable(*file, length, file_offset);
393 if (!data_sp)
394 return nullptr;
395 data_offset = 0;
396 mapped_writable = true;
397 magic = data_sp->GetBytes();
398 }
399
400 // If we didn't map the data as writable take ownership of the buffer.
401 if (!mapped_writable) {
402 data_sp = std::make_shared<DataBufferHeap>(data_sp->GetBytes(),
403 data_sp->GetByteSize());
404 data_offset = 0;
405 magic = data_sp->GetBytes();
406 }
407
408 unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
409 if (address_size == 4 || address_size == 8) {
410 std::unique_ptr<ObjectFileELF> objfile_up(new ObjectFileELF(
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();
415 }
416
417 return nullptr;
418}
419
421 const lldb::ModuleSP &module_sp, WritableDataBufferSP data_sp,
422 const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
423 if (!data_sp || data_sp->GetByteSize() < (llvm::ELF::EI_NIDENT))
424 return nullptr;
425 const uint8_t *magic = data_sp->GetBytes();
426 if (!ELFHeader::MagicBytesMatch(magic))
427 return nullptr;
428 // Read the ELF header first so we can figure out how many bytes we need
429 // to read to get as least the ELF header + program headers.
430 DataExtractor data;
431 data.SetData(data_sp);
432 elf::ELFHeader hdr;
433 lldb::offset_t offset = 0;
434 if (!hdr.Parse(data, &offset))
435 return nullptr;
436
437 // Make sure the address size is set correctly in the ELF header.
438 if (!hdr.Is32Bit() && !hdr.Is64Bit())
439 return nullptr;
440 // Figure out where the program headers end and read enough bytes to get the
441 // program headers in their entirety.
442 lldb::offset_t end_phdrs = hdr.e_phoff + (hdr.e_phentsize * hdr.e_phnum);
443 if (end_phdrs > data_sp->GetByteSize())
444 data_sp = ReadMemory(process_sp, header_addr, end_phdrs);
445
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();
451
452 return nullptr;
453}
454
456 lldb::addr_t data_offset,
457 lldb::addr_t data_length) {
458 if (data_sp &&
459 data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
460 const uint8_t *magic = data_sp->GetBytes() + data_offset;
461 return ELFHeader::MagicBytesMatch(magic);
462 }
463 return false;
464}
465
466static uint32_t calc_crc32(uint32_t init, const DataExtractor &data) {
467 return llvm::crc32(init,
468 llvm::ArrayRef(data.GetDataStart(), data.GetByteSize()));
469}
470
472 const ProgramHeaderColl &program_headers, DataExtractor &object_data) {
473
474 uint32_t core_notes_crc = 0;
475
476 for (const ELFProgramHeader &H : program_headers) {
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;
480
481 DataExtractor segment_data;
482 if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size) {
483 // The ELF program header contained incorrect data, probably corefile
484 // is incomplete or corrupted.
485 break;
486 }
487
488 core_notes_crc = calc_crc32(core_notes_crc, segment_data);
489 }
490 }
491
492 return core_notes_crc;
493}
494
495static const char *OSABIAsCString(unsigned char osabi_byte) {
496#define _MAKE_OSABI_CASE(x) \
497 case x: \
498 return #x
499 switch (osabi_byte) {
500 _MAKE_OSABI_CASE(ELFOSABI_NONE);
501 _MAKE_OSABI_CASE(ELFOSABI_HPUX);
502 _MAKE_OSABI_CASE(ELFOSABI_NETBSD);
503 _MAKE_OSABI_CASE(ELFOSABI_GNU);
504 _MAKE_OSABI_CASE(ELFOSABI_HURD);
505 _MAKE_OSABI_CASE(ELFOSABI_SOLARIS);
506 _MAKE_OSABI_CASE(ELFOSABI_AIX);
507 _MAKE_OSABI_CASE(ELFOSABI_IRIX);
508 _MAKE_OSABI_CASE(ELFOSABI_FREEBSD);
509 _MAKE_OSABI_CASE(ELFOSABI_TRU64);
510 _MAKE_OSABI_CASE(ELFOSABI_MODESTO);
511 _MAKE_OSABI_CASE(ELFOSABI_OPENBSD);
512 _MAKE_OSABI_CASE(ELFOSABI_OPENVMS);
513 _MAKE_OSABI_CASE(ELFOSABI_NSK);
514 _MAKE_OSABI_CASE(ELFOSABI_AROS);
515 _MAKE_OSABI_CASE(ELFOSABI_FENIXOS);
516 _MAKE_OSABI_CASE(ELFOSABI_C6000_ELFABI);
517 _MAKE_OSABI_CASE(ELFOSABI_C6000_LINUX);
518 _MAKE_OSABI_CASE(ELFOSABI_ARM);
519 _MAKE_OSABI_CASE(ELFOSABI_STANDALONE);
520 default:
521 return "<unknown-osabi>";
522 }
523#undef _MAKE_OSABI_CASE
524}
525
526//
527// WARNING : This function is being deprecated
528// It's functionality has moved to ArchSpec::SetArchitecture This function is
529// only being kept to validate the move.
530//
531// TODO : Remove this function
532static bool GetOsFromOSABI(unsigned char osabi_byte,
533 llvm::Triple::OSType &ostype) {
534 switch (osabi_byte) {
535 case ELFOSABI_AIX:
536 ostype = llvm::Triple::OSType::AIX;
537 break;
538 case ELFOSABI_FREEBSD:
539 ostype = llvm::Triple::OSType::FreeBSD;
540 break;
541 case ELFOSABI_GNU:
542 ostype = llvm::Triple::OSType::Linux;
543 break;
544 case ELFOSABI_NETBSD:
545 ostype = llvm::Triple::OSType::NetBSD;
546 break;
547 case ELFOSABI_OPENBSD:
548 ostype = llvm::Triple::OSType::OpenBSD;
549 break;
550 case ELFOSABI_SOLARIS:
551 ostype = llvm::Triple::OSType::Solaris;
552 break;
553 default:
554 ostype = llvm::Triple::OSType::UnknownOS;
555 }
556 return ostype != llvm::Triple::OSType::UnknownOS;
557}
558
560 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
561 lldb::offset_t data_offset, lldb::offset_t file_offset,
563 Log *log = GetLog(LLDBLog::Modules);
564
565 const size_t initial_count = specs.GetSize();
566
567 if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
568 DataExtractor data;
569 data.SetData(data_sp);
570 elf::ELFHeader header;
571 lldb::offset_t header_offset = data_offset;
572 if (header.Parse(data, &header_offset)) {
573 if (data_sp) {
574 ModuleSpec spec(file);
575 // In Android API level 23 and above, bionic dynamic linker is able to
576 // load .so file directly from zip file. In that case, .so file is
577 // page aligned and uncompressed, and this module spec should retain the
578 // .so file offset and file size to pass through the information from
579 // lldb-server to LLDB. For normal file, file_offset should be 0,
580 // length should be the size of the file.
581 spec.SetObjectOffset(file_offset);
582 spec.SetObjectSize(length);
583
584 const uint32_t sub_type = subTypeFromElfHeader(header);
586 eArchTypeELF, header.e_machine, sub_type, header.e_ident[EI_OSABI]);
587
588 if (spec.GetArchitecture().IsValid()) {
589 llvm::Triple::OSType ostype;
590 llvm::Triple::VendorType vendor;
591 llvm::Triple::OSType spec_ostype =
592 spec.GetArchitecture().GetTriple().getOS();
593
594 LLDB_LOGF(log, "ObjectFileELF::%s file '%s' module OSABI: %s",
595 __FUNCTION__, file.GetPath().c_str(),
596 OSABIAsCString(header.e_ident[EI_OSABI]));
597
598 // SetArchitecture should have set the vendor to unknown
599 vendor = spec.GetArchitecture().GetTriple().getVendor();
600 assert(vendor == llvm::Triple::UnknownVendor);
602
603 //
604 // Validate it is ok to remove GetOsFromOSABI
605 GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
606 assert(spec_ostype == ostype);
607 if (spec_ostype != llvm::Triple::OSType::UnknownOS) {
608 LLDB_LOGF(log,
609 "ObjectFileELF::%s file '%s' set ELF module OS type "
610 "from ELF header OSABI.",
611 __FUNCTION__, file.GetPath().c_str());
612 }
613
614 // When ELF file does not contain GNU build ID, the later code will
615 // calculate CRC32 with this data_sp file_offset and length. It is
616 // important for Android zip .so file, which is a slice of a file,
617 // to not access the outside of the file slice range.
618 if (data_sp->GetByteSize() < length)
619 data_sp = MapFileData(file, length, file_offset);
620 if (data_sp)
621 data.SetData(data_sp);
622 // In case there is header extension in the section #0, the header we
623 // parsed above could have sentinel values for e_phnum, e_shnum, and
624 // e_shstrndx. In this case we need to reparse the header with a
625 // bigger data source to get the actual values.
626 if (header.HasHeaderExtension()) {
627 lldb::offset_t header_offset = data_offset;
628 header.Parse(data, &header_offset);
629 }
630
631 uint32_t gnu_debuglink_crc = 0;
632 std::string gnu_debuglink_file;
633 SectionHeaderColl section_headers;
634 lldb_private::UUID &uuid = spec.GetUUID();
635
636 GetSectionHeaderInfo(section_headers, data, header, uuid,
637 gnu_debuglink_file, gnu_debuglink_crc,
638 spec.GetArchitecture());
639
640 llvm::Triple &spec_triple = spec.GetArchitecture().GetTriple();
641
642 LLDB_LOGF(log,
643 "ObjectFileELF::%s file '%s' module set to triple: %s "
644 "(architecture %s)",
645 __FUNCTION__, file.GetPath().c_str(),
646 spec_triple.getTriple().c_str(),
648
649 if (!uuid.IsValid()) {
650 uint32_t core_notes_crc = 0;
651
652 if (!gnu_debuglink_crc) {
654 "Calculating module crc32 %s with size %" PRIu64 " KiB",
655 file.GetFilename().AsCString(),
656 (length - file_offset) / 1024);
657
658 // For core files - which usually don't happen to have a
659 // gnu_debuglink, and are pretty bulky - calculating whole
660 // contents crc32 would be too much of luxury. Thus we will need
661 // to fallback to something simpler.
662 if (header.e_type == llvm::ELF::ET_CORE) {
663 ProgramHeaderColl program_headers;
664 GetProgramHeaderInfo(program_headers, data, header);
665
666 core_notes_crc =
667 CalculateELFNotesSegmentsCRC32(program_headers, data);
668 } else {
669 gnu_debuglink_crc = calc_crc32(0, data);
670 }
671 }
672 using u32le = llvm::support::ulittle32_t;
673 if (gnu_debuglink_crc) {
674 // Use 4 bytes of crc from the .gnu_debuglink section.
675 u32le data(gnu_debuglink_crc);
676 uuid = UUID(&data, sizeof(data));
677 } else if (core_notes_crc) {
678 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make
679 // it look different form .gnu_debuglink crc followed by 4 bytes
680 // of note segments crc.
681 u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)};
682 uuid = UUID(data, sizeof(data));
683 }
684 }
685
686 specs.Append(spec);
687 }
688 }
689 }
690 }
691
692 return specs.GetSize() - initial_count;
693}
694
695// ObjectFile protocol
696
698 DataBufferSP data_sp, lldb::offset_t data_offset,
699 const FileSpec *file, lldb::offset_t file_offset,
700 lldb::offset_t length)
701 : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset) {
702 if (file)
703 m_file = *file;
704}
705
707 DataBufferSP header_data_sp,
708 const lldb::ProcessSP &process_sp,
709 addr_t header_addr)
710 : ObjectFile(module_sp, process_sp, header_addr, header_data_sp) {}
711
713 return ((m_header.e_type & ET_EXEC) != 0) || (m_header.e_entry != 0);
714}
715
717 bool value_is_offset) {
718 ModuleSP module_sp = GetModule();
719 if (module_sp) {
720 size_t num_loaded_sections = 0;
721 SectionList *section_list = GetSectionList();
722 if (section_list) {
723 if (!value_is_offset) {
725 if (base == LLDB_INVALID_ADDRESS)
726 return false;
727 value -= base;
728 }
729
730 const size_t num_sections = section_list->GetSize();
731 size_t sect_idx = 0;
732
733 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
734 // Iterate through the object file sections to find all of the sections
735 // that have SHF_ALLOC in their flag bits.
736 SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
737
738 // PT_TLS segments can have the same p_vaddr and p_paddr as other
739 // PT_LOAD segments so we shouldn't load them. If we do load them, then
740 // the SectionLoadList will incorrectly fill in the instance variable
741 // SectionLoadList::m_addr_to_sect with the same address as a PT_LOAD
742 // segment and we won't be able to resolve addresses in the PT_LOAD
743 // segment whose p_vaddr entry matches that of the PT_TLS. Any variables
744 // that appear in the PT_TLS segments get resolved by the DWARF
745 // expressions. If this ever changes we will need to fix all object
746 // file plug-ins, but until then, we don't want PT_TLS segments to
747 // remove the entry from SectionLoadList::m_addr_to_sect when we call
748 // SetSectionLoadAddress() below.
749 if (section_sp->IsThreadSpecific())
750 continue;
751 if (section_sp->Test(SHF_ALLOC) ||
752 section_sp->GetType() == eSectionTypeContainer) {
753 lldb::addr_t load_addr = section_sp->GetFileAddress();
754 // We don't want to update the load address of a section with type
755 // eSectionTypeAbsoluteAddress as they already have the absolute load
756 // address already specified
757 if (section_sp->GetType() != eSectionTypeAbsoluteAddress)
758 load_addr += value;
759
760 // On 32-bit systems the load address have to fit into 4 bytes. The
761 // rest of the bytes are the overflow from the addition.
762 if (GetAddressByteSize() == 4)
763 load_addr &= 0xFFFFFFFF;
764
765 if (target.SetSectionLoadAddress(section_sp, load_addr))
766 ++num_loaded_sections;
767 }
768 }
769 return num_loaded_sections > 0;
770 }
771 }
772 return false;
773}
774
776 if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
777 return eByteOrderBig;
778 if (m_header.e_ident[EI_DATA] == ELFDATA2LSB)
779 return eByteOrderLittle;
780 return eByteOrderInvalid;
781}
782
784 return m_data.GetAddressByteSize();
785}
786
788 Symtab *symtab = GetSymtab();
789 if (!symtab)
790 return AddressClass::eUnknown;
791
792 // The address class is determined based on the symtab. Ask it from the
793 // object file what contains the symtab information.
794 ObjectFile *symtab_objfile = symtab->GetObjectFile();
795 if (symtab_objfile != nullptr && symtab_objfile != this)
796 return symtab_objfile->GetAddressClass(file_addr);
797
798 auto res = ObjectFile::GetAddressClass(file_addr);
799 if (res != AddressClass::eCode)
800 return res;
801
802 auto ub = m_address_class_map.upper_bound(file_addr);
803 if (ub == m_address_class_map.begin()) {
804 // No entry in the address class map before the address. Return default
805 // address class for an address in a code section.
806 return AddressClass::eCode;
807 }
808
809 // Move iterator to the address class entry preceding address
810 --ub;
811
812 return ub->second;
813}
814
816 return std::distance(m_section_headers.begin(), I);
817}
818
820 return std::distance(m_section_headers.begin(), I);
821}
822
824 lldb::offset_t offset = 0;
825 return m_header.Parse(m_data, &offset);
826}
827
829 // Need to parse the section list to get the UUIDs, so make sure that's been
830 // done.
832 return UUID();
833
834 if (!m_uuid) {
835 using u32le = llvm::support::ulittle32_t;
837 uint32_t core_notes_crc = 0;
838
839 if (!ParseProgramHeaders())
840 return UUID();
841
842 core_notes_crc =
844
845 if (core_notes_crc) {
846 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it
847 // look different form .gnu_debuglink crc - followed by 4 bytes of note
848 // segments crc.
849 u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)};
850 m_uuid = UUID(data, sizeof(data));
851 }
852 } else {
856 // Use 4 bytes of crc from the .gnu_debuglink section.
857 u32le data(m_gnu_debuglink_crc);
858 m_uuid = UUID(&data, sizeof(data));
859 }
860 }
861 }
862
863 return m_uuid;
864}
865
866std::optional<FileSpec> ObjectFileELF::GetDebugLink() {
867 if (m_gnu_debuglink_file.empty())
868 return std::nullopt;
870}
871
873 size_t num_modules = ParseDependentModules();
874 uint32_t num_specs = 0;
875
876 for (unsigned i = 0; i < num_modules; ++i) {
877 if (files.AppendIfUnique(m_filespec_up->GetFileSpecAtIndex(i)))
878 num_specs++;
879 }
880
881 return num_specs;
882}
883
885 if (!ParseDynamicSymbols())
886 return Address();
887
888 SectionList *section_list = GetSectionList();
889 if (!section_list)
890 return Address();
891
892 for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) {
893 const ELFDynamic &symbol = m_dynamic_symbols[i].symbol;
894
895 if (symbol.d_tag != DT_DEBUG && symbol.d_tag != DT_MIPS_RLD_MAP &&
896 symbol.d_tag != DT_MIPS_RLD_MAP_REL)
897 continue;
898
899 // Compute the offset as the number of previous entries plus the size of
900 // d_tag.
901 const addr_t offset = (i * 2 + 1) * GetAddressByteSize();
902 const addr_t d_file_addr = m_dynamic_base_addr + offset;
903 Address d_addr;
904 if (!d_addr.ResolveAddressUsingFileSections(d_file_addr, GetSectionList()))
905 return Address();
906 if (symbol.d_tag == DT_DEBUG)
907 return d_addr;
908
909 // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP
910 // exists in non-PIE.
911 if ((symbol.d_tag == DT_MIPS_RLD_MAP ||
912 symbol.d_tag == DT_MIPS_RLD_MAP_REL) &&
913 target) {
914 const addr_t d_load_addr = d_addr.GetLoadAddress(target);
915 if (d_load_addr == LLDB_INVALID_ADDRESS)
916 return Address();
917
919 if (symbol.d_tag == DT_MIPS_RLD_MAP) {
920 // DT_MIPS_RLD_MAP tag stores an absolute address of the debug pointer.
921 Address addr;
922 if (target->ReadPointerFromMemory(d_load_addr, error, addr, true))
923 return addr;
924 }
925 if (symbol.d_tag == DT_MIPS_RLD_MAP_REL) {
926 // DT_MIPS_RLD_MAP_REL tag stores the offset to the debug pointer,
927 // relative to the address of the tag.
928 uint64_t rel_offset;
929 rel_offset = target->ReadUnsignedIntegerFromMemory(
930 d_load_addr, GetAddressByteSize(), UINT64_MAX, error, true);
931 if (error.Success() && rel_offset != UINT64_MAX) {
932 Address addr;
933 addr_t debug_ptr_address =
934 d_load_addr - GetAddressByteSize() + rel_offset;
935 addr.SetOffset(debug_ptr_address);
936 return addr;
937 }
938 }
939 }
940 }
941 return Address();
942}
943
947
948 if (!ParseHeader() || !IsExecutable())
950
951 SectionList *section_list = GetSectionList();
952 addr_t offset = m_header.e_entry;
953
954 if (!section_list)
956 else
959}
960
963 for (SectionHeaderCollIter I = std::next(m_section_headers.begin());
964 I != m_section_headers.end(); ++I) {
965 const ELFSectionHeaderInfo &header = *I;
966 if (header.sh_flags & SHF_ALLOC)
967 return Address(GetSectionList()->FindSectionByID(SectionIndex(I)), 0);
968 }
970 }
971
972 for (const auto &EnumPHdr : llvm::enumerate(ProgramHeaders())) {
973 const ELFProgramHeader &H = EnumPHdr.value();
974 if (H.p_type != PT_LOAD)
975 continue;
976
977 return Address(
978 GetSectionList()->FindSectionByID(SegmentID(EnumPHdr.index())), 0);
979 }
981}
982
984 if (m_filespec_up)
985 return m_filespec_up->GetSize();
986
987 m_filespec_up = std::make_unique<FileSpecList>();
988
989 if (ParseDynamicSymbols()) {
990 for (const auto &entry : m_dynamic_symbols) {
991 if (entry.symbol.d_tag != DT_NEEDED)
992 continue;
993 if (!entry.name.empty()) {
994 FileSpec file_spec(entry.name);
995 FileSystem::Instance().Resolve(file_spec);
996 m_filespec_up->Append(file_spec);
997 }
998 }
999 }
1000 return m_filespec_up->GetSize();
1001}
1002
1003// GetProgramHeaderInfo
1005 DataExtractor &object_data,
1006 const ELFHeader &header) {
1007 // We have already parsed the program headers
1008 if (!program_headers.empty())
1009 return program_headers.size();
1010
1011 // If there are no program headers to read we are done.
1012 if (header.e_phnum == 0)
1013 return 0;
1014
1015 program_headers.resize(header.e_phnum);
1016 if (program_headers.size() != header.e_phnum)
1017 return 0;
1018
1019 const size_t ph_size = header.e_phnum * header.e_phentsize;
1020 const elf_off ph_offset = header.e_phoff;
1021 DataExtractor data;
1022 if (data.SetData(object_data, ph_offset, ph_size) != ph_size)
1023 return 0;
1024
1025 uint32_t idx;
1026 lldb::offset_t offset;
1027 for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) {
1028 if (!program_headers[idx].Parse(data, &offset))
1029 break;
1030 }
1031
1032 if (idx < program_headers.size())
1033 program_headers.resize(idx);
1034
1035 return program_headers.size();
1036}
1037
1038// ParseProgramHeaders
1041}
1042
1045 lldb_private::ArchSpec &arch_spec,
1046 lldb_private::UUID &uuid) {
1047 Log *log = GetLog(LLDBLog::Modules);
1048 Status error;
1049
1050 lldb::offset_t offset = 0;
1051
1052 while (true) {
1053 // Parse the note header. If this fails, bail out.
1054 const lldb::offset_t note_offset = offset;
1055 ELFNote note = ELFNote();
1056 if (!note.Parse(data, &offset)) {
1057 // We're done.
1058 return error;
1059 }
1060
1061 LLDB_LOGF(log, "ObjectFileELF::%s parsing note name='%s', type=%" PRIu32,
1062 __FUNCTION__, note.n_name.c_str(), note.n_type);
1063
1064 // Process FreeBSD ELF notes.
1065 if ((note.n_name == LLDB_NT_OWNER_FREEBSD) &&
1066 (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) &&
1067 (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) {
1068 // Pull out the min version info.
1069 uint32_t version_info;
1070 if (data.GetU32(&offset, &version_info, 1) == nullptr) {
1071 error =
1072 Status::FromErrorString("failed to read FreeBSD ABI note payload");
1073 return error;
1074 }
1075
1076 // Convert the version info into a major/minor number.
1077 const uint32_t version_major = version_info / 100000;
1078 const uint32_t version_minor = (version_info / 1000) % 100;
1079
1080 char os_name[32];
1081 snprintf(os_name, sizeof(os_name), "freebsd%" PRIu32 ".%" PRIu32,
1082 version_major, version_minor);
1083
1084 // Set the elf OS version to FreeBSD. Also clear the vendor.
1085 arch_spec.GetTriple().setOSName(os_name);
1086 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1087
1088 LLDB_LOGF(log,
1089 "ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32
1090 ".%" PRIu32,
1091 __FUNCTION__, version_major, version_minor,
1092 static_cast<uint32_t>(version_info % 1000));
1093 }
1094 // Process GNU ELF notes.
1095 else if (note.n_name == LLDB_NT_OWNER_GNU) {
1096 switch (note.n_type) {
1098 if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) {
1099 // Pull out the min OS version supporting the ABI.
1100 uint32_t version_info[4];
1101 if (data.GetU32(&offset, &version_info[0], note.n_descsz / 4) ==
1102 nullptr) {
1103 error =
1104 Status::FromErrorString("failed to read GNU ABI note payload");
1105 return error;
1106 }
1107
1108 // Set the OS per the OS field.
1109 switch (version_info[0]) {
1111 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1112 arch_spec.GetTriple().setVendor(
1113 llvm::Triple::VendorType::UnknownVendor);
1114 LLDB_LOGF(log,
1115 "ObjectFileELF::%s detected Linux, min version %" PRIu32
1116 ".%" PRIu32 ".%" PRIu32,
1117 __FUNCTION__, version_info[1], version_info[2],
1118 version_info[3]);
1119 // FIXME we have the minimal version number, we could be propagating
1120 // that. version_info[1] = OS Major, version_info[2] = OS Minor,
1121 // version_info[3] = Revision.
1122 break;
1124 arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
1125 arch_spec.GetTriple().setVendor(
1126 llvm::Triple::VendorType::UnknownVendor);
1127 LLDB_LOGF(log,
1128 "ObjectFileELF::%s detected Hurd (unsupported), min "
1129 "version %" PRIu32 ".%" PRIu32 ".%" PRIu32,
1130 __FUNCTION__, version_info[1], version_info[2],
1131 version_info[3]);
1132 break;
1134 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Solaris);
1135 arch_spec.GetTriple().setVendor(
1136 llvm::Triple::VendorType::UnknownVendor);
1137 LLDB_LOGF(log,
1138 "ObjectFileELF::%s detected Solaris, min version %" PRIu32
1139 ".%" PRIu32 ".%" PRIu32,
1140 __FUNCTION__, version_info[1], version_info[2],
1141 version_info[3]);
1142 break;
1143 default:
1144 LLDB_LOGF(log,
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]);
1149 break;
1150 }
1151 }
1152 break;
1153
1155 // Only bother processing this if we don't already have the uuid set.
1156 if (!uuid.IsValid()) {
1157 // 16 bytes is UUID|MD5, 20 bytes is SHA1. Other linkers may produce a
1158 // build-id of a different length. Accept it as long as it's at least
1159 // 4 bytes as it will be better than our own crc32.
1160 if (note.n_descsz >= 4) {
1161 if (const uint8_t *buf = data.PeekData(offset, note.n_descsz)) {
1162 // Save the build id as the UUID for the module.
1163 uuid = UUID(buf, note.n_descsz);
1164 } else {
1166 "failed to read GNU_BUILD_ID note payload");
1167 return error;
1168 }
1169 }
1170 }
1171 break;
1172 }
1173 if (arch_spec.IsMIPS() &&
1174 arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1175 // The note.n_name == LLDB_NT_OWNER_GNU is valid for Linux platform
1176 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1177 }
1178 // Process NetBSD ELF executables and shared libraries
1179 else if ((note.n_name == LLDB_NT_OWNER_NETBSD) &&
1180 (note.n_type == LLDB_NT_NETBSD_IDENT_TAG) &&
1181 (note.n_descsz == LLDB_NT_NETBSD_IDENT_DESCSZ) &&
1182 (note.n_namesz == LLDB_NT_NETBSD_IDENT_NAMESZ)) {
1183 // Pull out the version info.
1184 uint32_t version_info;
1185 if (data.GetU32(&offset, &version_info, 1) == nullptr) {
1186 error =
1187 Status::FromErrorString("failed to read NetBSD ABI note payload");
1188 return error;
1189 }
1190 // Convert the version info into a major/minor/patch number.
1191 // #define __NetBSD_Version__ MMmmrrpp00
1192 //
1193 // M = major version
1194 // m = minor version; a minor number of 99 indicates current.
1195 // r = 0 (since NetBSD 3.0 not used)
1196 // p = patchlevel
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;
1200 // Set the elf OS version to NetBSD. Also clear the vendor.
1201 arch_spec.GetTriple().setOSName(
1202 llvm::formatv("netbsd{0}.{1}.{2}", version_major, version_minor,
1203 version_patch).str());
1204 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1205 }
1206 // Process NetBSD ELF core(5) notes
1207 else if ((note.n_name == LLDB_NT_OWNER_NETBSDCORE) &&
1208 (note.n_type == LLDB_NT_NETBSD_PROCINFO)) {
1209 // Set the elf OS version to NetBSD. Also clear the vendor.
1210 arch_spec.GetTriple().setOS(llvm::Triple::OSType::NetBSD);
1211 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1212 }
1213 // Process OpenBSD ELF notes.
1214 else if (note.n_name == LLDB_NT_OWNER_OPENBSD) {
1215 // Set the elf OS version to OpenBSD. Also clear the vendor.
1216 arch_spec.GetTriple().setOS(llvm::Triple::OSType::OpenBSD);
1217 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1218 } else if (note.n_name == LLDB_NT_OWNER_ANDROID) {
1219 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1220 arch_spec.GetTriple().setEnvironment(
1221 llvm::Triple::EnvironmentType::Android);
1222 } else if (note.n_name == LLDB_NT_OWNER_LINUX) {
1223 // This is sometimes found in core files and usually contains extended
1224 // register info
1225 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1226 } else if (note.n_name == LLDB_NT_OWNER_CORE) {
1227 // Parse the NT_FILE to look for stuff in paths to shared libraries
1228 // The contents look like this in a 64 bit ELF core file:
1229 //
1230 // count = 0x000000000000000a (10)
1231 // page_size = 0x0000000000001000 (4096)
1232 // Index start end file_ofs path
1233 // ===== ------------------ ------------------ ------------------ -------------------------------------
1234 // [ 0] 0x0000000000401000 0x0000000000000000 /tmp/a.out
1235 // [ 1] 0x0000000000600000 0x0000000000601000 0x0000000000000000 /tmp/a.out
1236 // [ 2] 0x0000000000601000 0x0000000000602000 0x0000000000000001 /tmp/a.out
1237 // [ 3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000 /lib/x86_64-linux-gnu/libc-2.19.so
1238 // [ 4] 0x00007fa79cba8000 0x00007fa79cda7000 0x00000000000001bb /lib/x86_64-linux-gnu/libc-2.19.so
1239 // [ 5] 0x00007fa79cda7000 0x00007fa79cdab000 0x00000000000001ba /lib/x86_64-linux-gnu/libc-2.19.so
1240 // [ 6] 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be /lib/x86_64-linux-gnu/libc-2.19.so
1241 // [ 7] 0x00007fa79cdb2000 0x00007fa79cdd5000 0x0000000000000000 /lib/x86_64-linux-gnu/ld-2.19.so
1242 // [ 8] 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022 /lib/x86_64-linux-gnu/ld-2.19.so
1243 // [ 9] 0x00007fa79cfd5000 0x00007fa79cfd6000 0x0000000000000023 /lib/x86_64-linux-gnu/ld-2.19.so
1244 //
1245 // In the 32 bit ELFs the count, page_size, start, end, file_ofs are
1246 // uint32_t.
1247 //
1248 // For reference: see readelf source code (in binutils).
1249 if (note.n_type == NT_FILE) {
1250 uint64_t count = data.GetAddress(&offset);
1251 const char *cstr;
1252 data.GetAddress(&offset); // Skip page size
1253 offset += count * 3 *
1254 data.GetAddressByteSize(); // Skip all start/end/file_ofs
1255 for (size_t i = 0; i < count; ++i) {
1256 cstr = data.GetCStr(&offset);
1257 if (cstr == nullptr) {
1259 "ObjectFileELF::%s trying to read "
1260 "at an offset after the end "
1261 "(GetCStr returned nullptr)",
1262 __FUNCTION__);
1263 return error;
1264 }
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);
1268 break;
1269 }
1270 }
1271 if (arch_spec.IsMIPS() &&
1272 arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1273 // In case of MIPSR6, the LLDB_NT_OWNER_GNU note is missing for some
1274 // cases (e.g. compile with -nostdlib) Hence set OS to Linux
1275 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1276 }
1277 }
1278
1279 // Calculate the offset of the next note just in case "offset" has been
1280 // used to poke at the contents of the note data
1281 offset = note_offset + note.GetByteSize();
1282 }
1283
1284 return error;
1285}
1286
1288 ArchSpec &arch_spec) {
1289 lldb::offset_t Offset = 0;
1290
1291 uint8_t FormatVersion = data.GetU8(&Offset);
1292 if (FormatVersion != llvm::ELFAttrs::Format_Version)
1293 return;
1294
1295 Offset = Offset + sizeof(uint32_t); // Section Length
1296 llvm::StringRef VendorName = data.GetCStr(&Offset);
1297
1298 if (VendorName != "aeabi")
1299 return;
1300
1301 if (arch_spec.GetTriple().getEnvironment() ==
1302 llvm::Triple::UnknownEnvironment)
1303 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI);
1304
1305 while (Offset < length) {
1306 uint8_t Tag = data.GetU8(&Offset);
1307 uint32_t Size = data.GetU32(&Offset);
1308
1309 if (Tag != llvm::ARMBuildAttrs::File || Size == 0)
1310 continue;
1311
1312 while (Offset < length) {
1313 uint64_t Tag = data.GetULEB128(&Offset);
1314 switch (Tag) {
1315 default:
1316 if (Tag < 32)
1317 data.GetULEB128(&Offset);
1318 else if (Tag % 2 == 0)
1319 data.GetULEB128(&Offset);
1320 else
1321 data.GetCStr(&Offset);
1322
1323 break;
1324
1325 case llvm::ARMBuildAttrs::CPU_raw_name:
1326 case llvm::ARMBuildAttrs::CPU_name:
1327 data.GetCStr(&Offset);
1328
1329 break;
1330
1331 case llvm::ARMBuildAttrs::ABI_VFP_args: {
1332 uint64_t VFPArgs = data.GetULEB128(&Offset);
1333
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);
1339
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);
1346
1348 }
1349
1350 break;
1351 }
1352 }
1353 }
1354 }
1355}
1356
1357// GetSectionHeaderInfo
1359 DataExtractor &object_data,
1360 const elf::ELFHeader &header,
1361 lldb_private::UUID &uuid,
1362 std::string &gnu_debuglink_file,
1363 uint32_t &gnu_debuglink_crc,
1364 ArchSpec &arch_spec) {
1365 // Don't reparse the section headers if we already did that.
1366 if (!section_headers.empty())
1367 return section_headers.size();
1368
1369 // Only initialize the arch_spec to okay defaults if they're not already set.
1370 // We'll refine this with note data as we parse the notes.
1371 if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) {
1372 llvm::Triple::OSType ostype;
1373 llvm::Triple::OSType spec_ostype;
1374 const uint32_t sub_type = subTypeFromElfHeader(header);
1375 arch_spec.SetArchitecture(eArchTypeELF, header.e_machine, sub_type,
1376 header.e_ident[EI_OSABI]);
1377
1378 // Validate if it is ok to remove GetOsFromOSABI. Note, that now the OS is
1379 // determined based on EI_OSABI flag and the info extracted from ELF notes
1380 // (see RefineModuleDetailsFromNote). However in some cases that still
1381 // might be not enough: for example a shared library might not have any
1382 // notes at all and have EI_OSABI flag set to System V, as result the OS
1383 // will be set to UnknownOS.
1384 GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
1385 spec_ostype = arch_spec.GetTriple().getOS();
1386 assert(spec_ostype == ostype);
1387 UNUSED_IF_ASSERT_DISABLED(spec_ostype);
1388 }
1389
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:
1397 break;
1398 case llvm::ELF::EF_MIPS_ARCH_ASE_M16:
1400 break;
1401 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX:
1403 break;
1404 default:
1405 break;
1406 }
1407 }
1408
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)
1415 }
1416
1417 if (arch_spec.GetMachine() == llvm::Triple::riscv32 ||
1418 arch_spec.GetMachine() == llvm::Triple::riscv64) {
1419 uint32_t flags = arch_spec.GetFlags();
1420
1421 if (header.e_flags & llvm::ELF::EF_RISCV_RVC)
1422 flags |= ArchSpec::eRISCV_rvc;
1423 if (header.e_flags & llvm::ELF::EF_RISCV_RVE)
1424 flags |= ArchSpec::eRISCV_rve;
1425
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)
1435
1436 arch_spec.SetFlags(flags);
1437 }
1438
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:
1445 break;
1446 case llvm::ELF::EF_LOONGARCH_ABI_DOUBLE_FLOAT:
1448 break;
1449 case llvm::ELF::EF_LOONGARCH_ABI_SOFT_FLOAT:
1450 break;
1451 }
1452
1453 arch_spec.SetFlags(flags);
1454 }
1455
1456 // If there are no section headers we are done.
1457 if (header.e_shnum == 0)
1458 return 0;
1459
1460 Log *log = GetLog(LLDBLog::Modules);
1461
1462 section_headers.resize(header.e_shnum);
1463 if (section_headers.size() != header.e_shnum)
1464 return 0;
1465
1466 const size_t sh_size = header.e_shnum * header.e_shentsize;
1467 const elf_off sh_offset = header.e_shoff;
1468 DataExtractor sh_data;
1469 if (sh_data.SetData(object_data, sh_offset, sh_size) != sh_size)
1470 return 0;
1471
1472 uint32_t idx;
1473 lldb::offset_t offset;
1474 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) {
1475 if (!section_headers[idx].Parse(sh_data, &offset))
1476 break;
1477 }
1478 if (idx < section_headers.size())
1479 section_headers.resize(idx);
1480
1481 const unsigned strtab_idx = header.e_shstrndx;
1482 if (strtab_idx && strtab_idx < section_headers.size()) {
1483 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx];
1484 const size_t byte_size = sheader.sh_size;
1485 const Elf64_Off offset = sheader.sh_offset;
1486 lldb_private::DataExtractor shstr_data;
1487
1488 if (shstr_data.SetData(object_data, offset, byte_size) == byte_size) {
1489 for (SectionHeaderCollIter I = section_headers.begin();
1490 I != section_headers.end(); ++I) {
1491 static ConstString g_sect_name_gnu_debuglink(".gnu_debuglink");
1492 const ELFSectionHeaderInfo &sheader = *I;
1493 const uint64_t section_size =
1494 sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size;
1495 ConstString name(shstr_data.PeekCStr(I->sh_name));
1496
1497 I->section_name = name;
1498
1499 if (arch_spec.IsMIPS()) {
1500 uint32_t arch_flags = arch_spec.GetFlags();
1501 DataExtractor data;
1502 if (sheader.sh_type == SHT_MIPS_ABIFLAGS) {
1503
1504 if (section_size && (data.SetData(object_data, sheader.sh_offset,
1505 section_size) == section_size)) {
1506 // MIPS ASE Mask is at offset 12 in MIPS.abiflags section
1507 lldb::offset_t offset = 12; // MIPS ABI Flags Version: 0
1508 arch_flags |= data.GetU32(&offset);
1509
1510 // The floating point ABI is at offset 7
1511 offset = 7;
1512 switch (data.GetU8(&offset)) {
1513 case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY:
1515 break;
1516 case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE:
1518 break;
1519 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE:
1521 break;
1522 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT:
1524 break;
1525 case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64:
1527 break;
1528 case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX:
1530 break;
1531 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64:
1533 break;
1534 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A:
1536 break;
1537 }
1538 }
1539 }
1540 // Settings appropriate ArchSpec ABI Flags
1541 switch (header.e_flags & llvm::ELF::EF_MIPS_ABI) {
1542 case llvm::ELF::EF_MIPS_ABI_O32:
1544 break;
1545 case EF_MIPS_ABI_O64:
1547 break;
1548 case EF_MIPS_ABI_EABI32:
1550 break;
1551 case EF_MIPS_ABI_EABI64:
1553 break;
1554 default:
1555 // ABI Mask doesn't cover N32 and N64 ABI.
1556 if (header.e_ident[EI_CLASS] == llvm::ELF::ELFCLASS64)
1558 else if (header.e_flags & llvm::ELF::EF_MIPS_ABI2)
1560 break;
1561 }
1562 arch_spec.SetFlags(arch_flags);
1563 }
1564
1565 if (arch_spec.GetMachine() == llvm::Triple::arm ||
1566 arch_spec.GetMachine() == llvm::Triple::thumb) {
1567 DataExtractor data;
1568
1569 if (sheader.sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 &&
1570 data.SetData(object_data, sheader.sh_offset, section_size) == section_size)
1571 ParseARMAttributes(data, section_size, arch_spec);
1572 }
1573
1574 if (name == g_sect_name_gnu_debuglink) {
1575 DataExtractor data;
1576 if (section_size && (data.SetData(object_data, sheader.sh_offset,
1577 section_size) == section_size)) {
1578 lldb::offset_t gnu_debuglink_offset = 0;
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);
1582 }
1583 }
1584
1585 // Process ELF note section entries.
1586 bool is_note_header = (sheader.sh_type == SHT_NOTE);
1587
1588 // The section header ".note.android.ident" is stored as a
1589 // PROGBITS type header but it is actually a note header.
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;
1593
1594 if (is_note_header) {
1595 // Allow notes to refine module info.
1596 DataExtractor data;
1597 if (section_size && (data.SetData(object_data, sheader.sh_offset,
1598 section_size) == section_size)) {
1599 Status error = RefineModuleDetailsFromNote(data, arch_spec, uuid);
1600 if (error.Fail()) {
1601 LLDB_LOGF(log, "ObjectFileELF::%s ELF note processing failed: %s",
1602 __FUNCTION__, error.AsCString());
1603 }
1604 }
1605 }
1606 }
1607
1608 // Make any unknown triple components to be unspecified unknowns.
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());
1613
1614 return section_headers.size();
1615 }
1616 }
1617
1618 section_headers.clear();
1619 return 0;
1620}
1621
1622llvm::StringRef
1623ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const {
1624 size_t pos = symbol_name.find('@');
1625 return symbol_name.substr(0, pos);
1626}
1627
1628// ParseSectionHeaders
1632 m_arch_spec);
1633}
1634
1637 if (!ParseSectionHeaders())
1638 return nullptr;
1639
1640 if (id < m_section_headers.size())
1641 return &m_section_headers[id];
1642
1643 return nullptr;
1644}
1645
1647 if (!name || !name[0] || !ParseSectionHeaders())
1648 return 0;
1649 for (size_t i = 1; i < m_section_headers.size(); ++i)
1650 if (m_section_headers[i].section_name == ConstString(name))
1651 return i;
1652 return 0;
1653}
1654
1655static SectionType GetSectionTypeFromName(llvm::StringRef Name) {
1656 if (Name.consume_front(".debug_")) {
1657 return llvm::StringSwitch<SectionType>(Name)
1658 .Case("abbrev", eSectionTypeDWARFDebugAbbrev)
1659 .Case("abbrev.dwo", eSectionTypeDWARFDebugAbbrevDwo)
1660 .Case("addr", eSectionTypeDWARFDebugAddr)
1661 .Case("aranges", eSectionTypeDWARFDebugAranges)
1662 .Case("cu_index", eSectionTypeDWARFDebugCuIndex)
1663 .Case("frame", eSectionTypeDWARFDebugFrame)
1664 .Case("info", eSectionTypeDWARFDebugInfo)
1665 .Case("info.dwo", eSectionTypeDWARFDebugInfoDwo)
1666 .Cases("line", "line.dwo", eSectionTypeDWARFDebugLine)
1667 .Cases("line_str", "line_str.dwo", eSectionTypeDWARFDebugLineStr)
1668 .Case("loc", eSectionTypeDWARFDebugLoc)
1669 .Case("loc.dwo", eSectionTypeDWARFDebugLocDwo)
1670 .Case("loclists", eSectionTypeDWARFDebugLocLists)
1671 .Case("loclists.dwo", eSectionTypeDWARFDebugLocListsDwo)
1672 .Case("macinfo", eSectionTypeDWARFDebugMacInfo)
1673 .Cases("macro", "macro.dwo", eSectionTypeDWARFDebugMacro)
1674 .Case("names", eSectionTypeDWARFDebugNames)
1675 .Case("pubnames", eSectionTypeDWARFDebugPubNames)
1676 .Case("pubtypes", eSectionTypeDWARFDebugPubTypes)
1677 .Case("ranges", eSectionTypeDWARFDebugRanges)
1678 .Case("rnglists", eSectionTypeDWARFDebugRngLists)
1679 .Case("rnglists.dwo", eSectionTypeDWARFDebugRngListsDwo)
1680 .Case("str", eSectionTypeDWARFDebugStr)
1681 .Case("str.dwo", eSectionTypeDWARFDebugStrDwo)
1682 .Case("str_offsets", eSectionTypeDWARFDebugStrOffsets)
1683 .Case("str_offsets.dwo", eSectionTypeDWARFDebugStrOffsetsDwo)
1684 .Case("tu_index", eSectionTypeDWARFDebugTuIndex)
1685 .Case("types", eSectionTypeDWARFDebugTypes)
1686 .Case("types.dwo", eSectionTypeDWARFDebugTypesDwo)
1687 .Default(eSectionTypeOther);
1688 }
1689 return llvm::StringSwitch<SectionType>(Name)
1690 .Case(".ARM.exidx", eSectionTypeARMexidx)
1691 .Case(".ARM.extab", eSectionTypeARMextab)
1692 .Case(".ctf", eSectionTypeDebug)
1693 .Cases(".data", ".tdata", eSectionTypeData)
1694 .Case(".eh_frame", eSectionTypeEHFrame)
1695 .Case(".gnu_debugaltlink", eSectionTypeDWARFGNUDebugAltLink)
1696 .Case(".gosymtab", eSectionTypeGoSymtab)
1697 .Case(".text", eSectionTypeCode)
1698 .Case(".lldbsummaries", lldb::eSectionTypeLLDBTypeSummaries)
1699 .Case(".lldbformatters", lldb::eSectionTypeLLDBFormatters)
1700 .Case(".swift_ast", eSectionTypeSwiftModules)
1701 .Default(eSectionTypeOther);
1702}
1703
1705 switch (H.sh_type) {
1706 case SHT_PROGBITS:
1707 if (H.sh_flags & SHF_EXECINSTR)
1708 return eSectionTypeCode;
1709 break;
1710 case SHT_NOBITS:
1711 if (H.sh_flags & SHF_ALLOC)
1712 return eSectionTypeZeroFill;
1713 break;
1714 case SHT_SYMTAB:
1716 case SHT_DYNSYM:
1718 case SHT_RELA:
1719 case SHT_REL:
1721 case SHT_DYNAMIC:
1723 }
1725}
1726
1727static uint32_t GetTargetByteSize(SectionType Type, const ArchSpec &arch) {
1728 switch (Type) {
1729 case eSectionTypeData:
1731 return arch.GetDataByteSize();
1732 case eSectionTypeCode:
1733 return arch.GetCodeByteSize();
1734 default:
1735 return 1;
1736 }
1737}
1738
1739static Permissions GetPermissions(const ELFSectionHeader &H) {
1740 Permissions Perm = Permissions(0);
1741 if (H.sh_flags & SHF_ALLOC)
1742 Perm |= ePermissionsReadable;
1743 if (H.sh_flags & SHF_WRITE)
1744 Perm |= ePermissionsWritable;
1745 if (H.sh_flags & SHF_EXECINSTR)
1746 Perm |= ePermissionsExecutable;
1747 return Perm;
1748}
1749
1750static Permissions GetPermissions(const ELFProgramHeader &H) {
1751 Permissions Perm = Permissions(0);
1752 if (H.p_flags & PF_R)
1753 Perm |= ePermissionsReadable;
1754 if (H.p_flags & PF_W)
1755 Perm |= ePermissionsWritable;
1756 if (H.p_flags & PF_X)
1757 Perm |= ePermissionsExecutable;
1758 return Perm;
1759}
1760
1761namespace {
1762
1764
1765struct SectionAddressInfo {
1766 SectionSP Segment;
1767 VMRange Range;
1768};
1769
1770// (Unlinked) ELF object files usually have 0 for every section address, meaning
1771// we need to compute synthetic addresses in order for "file addresses" from
1772// different sections to not overlap. This class handles that logic.
1773class VMAddressProvider {
1774 using VMMap = llvm::IntervalMap<addr_t, SectionSP, 4,
1775 llvm::IntervalMapHalfOpenInfo<addr_t>>;
1776
1777 ObjectFile::Type ObjectType;
1778 addr_t NextVMAddress = 0;
1779 VMMap::Allocator Alloc;
1780 VMMap Segments{Alloc};
1781 VMMap Sections{Alloc};
1782 lldb_private::Log *Log = GetLog(LLDBLog::Modules);
1783 size_t SegmentCount = 0;
1784 std::string SegmentName;
1785
1786 VMRange GetVMRange(const ELFSectionHeader &H) {
1788 addr_t Size = H.sh_flags & SHF_ALLOC ? H.sh_size : 0;
1789
1790 // When this is a debug file for relocatable file, the address is all zero
1791 // and thus needs to use accumulate method
1792 if ((ObjectType == ObjectFile::Type::eTypeObjectFile ||
1793 (ObjectType == ObjectFile::Type::eTypeDebugInfo && H.sh_addr == 0)) &&
1794 Segments.empty() && (H.sh_flags & SHF_ALLOC)) {
1795 NextVMAddress =
1796 llvm::alignTo(NextVMAddress, std::max<addr_t>(H.sh_addralign, 1));
1797 Address = NextVMAddress;
1798 NextVMAddress += Size;
1799 }
1800 return VMRange(Address, Size);
1801 }
1802
1803public:
1804 VMAddressProvider(ObjectFile::Type Type, llvm::StringRef SegmentName)
1805 : ObjectType(Type), SegmentName(std::string(SegmentName)) {}
1806
1807 std::string GetNextSegmentName() const {
1808 return llvm::formatv("{0}[{1}]", SegmentName, SegmentCount).str();
1809 }
1810
1811 std::optional<VMRange> GetAddressInfo(const ELFProgramHeader &H) {
1812 if (H.p_memsz == 0) {
1813 LLDB_LOG(Log, "Ignoring zero-sized {0} segment. Corrupt object file?",
1814 SegmentName);
1815 return std::nullopt;
1816 }
1817
1818 if (Segments.overlaps(H.p_vaddr, H.p_vaddr + H.p_memsz)) {
1819 LLDB_LOG(Log, "Ignoring overlapping {0} segment. Corrupt object file?",
1820 SegmentName);
1821 return std::nullopt;
1822 }
1823 return VMRange(H.p_vaddr, H.p_memsz);
1824 }
1825
1826 std::optional<SectionAddressInfo> GetAddressInfo(const ELFSectionHeader &H) {
1827 VMRange Range = GetVMRange(H);
1828 SectionSP Segment;
1829 auto It = Segments.find(Range.GetRangeBase());
1830 if ((H.sh_flags & SHF_ALLOC) && It.valid()) {
1831 addr_t MaxSize;
1832 if (It.start() <= Range.GetRangeBase()) {
1833 MaxSize = It.stop() - Range.GetRangeBase();
1834 Segment = *It;
1835 } else
1836 MaxSize = It.start() - Range.GetRangeBase();
1837 if (Range.GetByteSize() > MaxSize) {
1838 LLDB_LOG(Log, "Shortening section crossing segment boundaries. "
1839 "Corrupt object file?");
1840 Range.SetByteSize(MaxSize);
1841 }
1842 }
1843 if (Range.GetByteSize() > 0 &&
1844 Sections.overlaps(Range.GetRangeBase(), Range.GetRangeEnd())) {
1845 LLDB_LOG(Log, "Ignoring overlapping section. Corrupt object file?");
1846 return std::nullopt;
1847 }
1848 if (Segment)
1849 Range.Slide(-Segment->GetFileAddress());
1850 return SectionAddressInfo{Segment, Range};
1851 }
1852
1853 void AddSegment(const VMRange &Range, SectionSP Seg) {
1854 Segments.insert(Range.GetRangeBase(), Range.GetRangeEnd(), std::move(Seg));
1855 ++SegmentCount;
1856 }
1857
1858 void AddSection(SectionAddressInfo Info, SectionSP Sect) {
1859 if (Info.Range.GetByteSize() == 0)
1860 return;
1861 if (Info.Segment)
1862 Info.Range.Slide(Info.Segment->GetFileAddress());
1863 Sections.insert(Info.Range.GetRangeBase(), Info.Range.GetRangeEnd(),
1864 std::move(Sect));
1865 }
1866};
1867}
1868
1869// We have to do this because ELF doesn't have section IDs, and also
1870// doesn't require section names to be unique. (We use the section index
1871// for section IDs, but that isn't guaranteed to be the same in separate
1872// debug images.)
1873static SectionSP FindMatchingSection(const SectionList &section_list,
1874 SectionSP section) {
1875 SectionSP sect_sp;
1876
1877 addr_t vm_addr = section->GetFileAddress();
1878 ConstString name = section->GetName();
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();
1883
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) {
1890 sect_sp = sect;
1891 break;
1892 } else {
1893 sect_sp = FindMatchingSection(sect->GetChildren(), section);
1894 if (sect_sp)
1895 break;
1896 }
1897 }
1898
1899 return sect_sp;
1900}
1901
1902void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
1903 if (m_sections_up)
1904 return;
1905
1906 m_sections_up = std::make_unique<SectionList>();
1907 VMAddressProvider regular_provider(GetType(), "PT_LOAD");
1908 VMAddressProvider tls_provider(GetType(), "PT_TLS");
1909
1910 for (const auto &EnumPHdr : llvm::enumerate(ProgramHeaders())) {
1911 const ELFProgramHeader &PHdr = EnumPHdr.value();
1912 if (PHdr.p_type != PT_LOAD && PHdr.p_type != PT_TLS)
1913 continue;
1914
1915 VMAddressProvider &provider =
1916 PHdr.p_type == PT_TLS ? tls_provider : regular_provider;
1917 auto InfoOr = provider.GetAddressInfo(PHdr);
1918 if (!InfoOr)
1919 continue;
1920
1921 uint32_t Log2Align = llvm::Log2_64(std::max<elf_xword>(PHdr.p_align, 1));
1922 SectionSP Segment = std::make_shared<Section>(
1923 GetModule(), this, SegmentID(EnumPHdr.index()),
1924 ConstString(provider.GetNextSegmentName()), eSectionTypeContainer,
1925 InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.p_offset,
1926 PHdr.p_filesz, Log2Align, /*flags*/ 0);
1927 Segment->SetPermissions(GetPermissions(PHdr));
1928 Segment->SetIsThreadSpecific(PHdr.p_type == PT_TLS);
1929 m_sections_up->AddSection(Segment);
1930
1931 provider.AddSegment(*InfoOr, std::move(Segment));
1932 }
1933
1935 if (m_section_headers.empty())
1936 return;
1937
1938 for (SectionHeaderCollIter I = std::next(m_section_headers.begin());
1939 I != m_section_headers.end(); ++I) {
1940 const ELFSectionHeaderInfo &header = *I;
1941
1942 ConstString &name = I->section_name;
1943 const uint64_t file_size =
1944 header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
1945
1946 VMAddressProvider &provider =
1947 header.sh_flags & SHF_TLS ? tls_provider : regular_provider;
1948 auto InfoOr = provider.GetAddressInfo(header);
1949 if (!InfoOr)
1950 continue;
1951
1952 SectionType sect_type = GetSectionType(header);
1953
1954 const uint32_t target_bytes_size =
1955 GetTargetByteSize(sect_type, m_arch_spec);
1956
1957 elf::elf_xword log2align =
1958 (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign);
1959
1960 SectionSP section_sp(new Section(
1961 InfoOr->Segment, GetModule(), // Module to which this section belongs.
1962 this, // ObjectFile to which this section belongs and should
1963 // read section data from.
1964 SectionIndex(I), // Section ID.
1965 name, // Section name.
1966 sect_type, // Section type.
1967 InfoOr->Range.GetRangeBase(), // VM address.
1968 InfoOr->Range.GetByteSize(), // VM size in bytes of this section.
1969 header.sh_offset, // Offset of this section in the file.
1970 file_size, // Size of the section as found in the file.
1971 log2align, // Alignment of the section
1972 header.sh_flags, // Flags for this section.
1973 target_bytes_size)); // Number of host bytes per target byte
1974
1975 section_sp->SetPermissions(GetPermissions(header));
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));
1980 }
1981
1982 // For eTypeDebugInfo files, the Symbol Vendor will take care of updating the
1983 // unified section list.
1984 if (GetType() != eTypeDebugInfo)
1985 unified_section_list = *m_sections_up;
1986
1987 // If there's a .gnu_debugdata section, we'll try to read the .symtab that's
1988 // embedded in there and replace the one in the original object file (if any).
1989 // If there's none in the orignal object file, we add it to it.
1990 if (auto gdd_obj_file = GetGnuDebugDataObjectFile()) {
1991 if (auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) {
1992 if (SectionSP symtab_section_sp =
1993 gdd_objfile_section_list->FindSectionByType(
1995 SectionSP module_section_sp = unified_section_list.FindSectionByType(
1997 if (module_section_sp)
1998 unified_section_list.ReplaceSection(module_section_sp->GetID(),
1999 symtab_section_sp);
2000 else
2001 unified_section_list.AddSection(symtab_section_sp);
2002 }
2003 }
2004 }
2005}
2006
2007std::shared_ptr<ObjectFileELF> ObjectFileELF::GetGnuDebugDataObjectFile() {
2008 if (m_gnu_debug_data_object_file != nullptr)
2010
2011 SectionSP section =
2012 GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"));
2013 if (!section)
2014 return nullptr;
2015
2017 GetModule()->ReportWarning(
2018 "No LZMA support found for reading .gnu_debugdata section");
2019 return nullptr;
2020 }
2021
2022 // Uncompress the data
2023 DataExtractor data;
2024 section->GetSectionData(data);
2025 llvm::SmallVector<uint8_t, 0> uncompressedData;
2026 auto err = lldb_private::lzma::uncompress(data.GetData(), uncompressedData);
2027 if (err) {
2028 GetModule()->ReportWarning(
2029 "An error occurred while decompression the section {0}: {1}",
2030 section->GetName().AsCString(), llvm::toString(std::move(err)).c_str());
2031 return nullptr;
2032 }
2033
2034 // Construct ObjectFileELF object from decompressed buffer
2035 DataBufferSP gdd_data_buf(
2036 new DataBufferHeap(uncompressedData.data(), uncompressedData.size()));
2038 llvm::StringRef("gnu_debugdata"));
2040 GetModule(), gdd_data_buf, 0, &fspec, 0, gdd_data_buf->GetByteSize()));
2041
2042 // This line is essential; otherwise a breakpoint can be set but not hit.
2044
2045 ArchSpec spec = m_gnu_debug_data_object_file->GetArchitecture();
2046 if (spec && m_gnu_debug_data_object_file->SetModulesArchitecture(spec))
2048
2049 return nullptr;
2050}
2051
2052// Find the arm/aarch64 mapping symbol character in the given symbol name.
2053// Mapping symbols have the form of "$<char>[.<any>]*". Additionally we
2054// recognize cases when the mapping symbol prefixed by an arbitrary string
2055// because if a symbol prefix added to each symbol in the object file with
2056// objcopy then the mapping symbols are also prefixed.
2057static char FindArmAarch64MappingSymbol(const char *symbol_name) {
2058 if (!symbol_name)
2059 return '\0';
2060
2061 const char *dollar_pos = ::strchr(symbol_name, '$');
2062 if (!dollar_pos || dollar_pos[1] == '\0')
2063 return '\0';
2064
2065 if (dollar_pos[2] == '\0' || dollar_pos[2] == '.')
2066 return dollar_pos[1];
2067 return '\0';
2068}
2069
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)
2073
2074// private
2075std::pair<unsigned, ObjectFileELF::FileAddressToAddressClassMap>
2077 SectionList *section_list, const size_t num_symbols,
2078 const DataExtractor &symtab_data,
2079 const DataExtractor &strtab_data) {
2080 ELFSymbol symbol;
2081 lldb::offset_t offset = 0;
2082 // The changes these symbols would make to the class map. We will also update
2083 // m_address_class_map but need to tell the caller what changed because the
2084 // caller may be another object file.
2085 FileAddressToAddressClassMap address_class_map;
2086
2087 static ConstString text_section_name(".text");
2088 static ConstString init_section_name(".init");
2089 static ConstString fini_section_name(".fini");
2090 static ConstString ctors_section_name(".ctors");
2091 static ConstString dtors_section_name(".dtors");
2092
2093 static ConstString data_section_name(".data");
2094 static ConstString rodata_section_name(".rodata");
2095 static ConstString rodata1_section_name(".rodata1");
2096 static ConstString data2_section_name(".data1");
2097 static ConstString bss_section_name(".bss");
2098 static ConstString opd_section_name(".opd"); // For ppc64
2099
2100 // On Android the oatdata and the oatexec symbols in the oat and odex files
2101 // covers the full .text section what causes issues with displaying unusable
2102 // symbol name to the user and very slow unwinding speed because the
2103 // instruction emulation based unwind plans try to emulate all instructions
2104 // in these symbols. Don't add these symbols to the symbol list as they have
2105 // no use for the debugger and they are causing a lot of trouble. Filtering
2106 // can't be restricted to Android because this special object file don't
2107 // contain the note section specifying the environment to Android but the
2108 // custom extension and file name makes it highly unlikely that this will
2109 // collide with anything else.
2110 llvm::StringRef file_extension = m_file.GetFileNameExtension();
2111 bool skip_oatdata_oatexec =
2112 file_extension == ".oat" || file_extension == ".odex";
2113
2114 ArchSpec arch = GetArchitecture();
2115 ModuleSP module_sp(GetModule());
2116 SectionList *module_section_list =
2117 module_sp ? module_sp->GetSectionList() : nullptr;
2118
2119 // We might have debug information in a separate object, in which case
2120 // we need to map the sections from that object to the sections in the
2121 // main object during symbol lookup. If we had to compare the sections
2122 // for every single symbol, that would be expensive, so this map is
2123 // used to accelerate the process.
2124 std::unordered_map<lldb::SectionSP, lldb::SectionSP> section_map;
2125
2126 unsigned i;
2127 for (i = 0; i < num_symbols; ++i) {
2128 if (!symbol.Parse(symtab_data, &offset))
2129 break;
2130
2131 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
2132 if (!symbol_name)
2133 symbol_name = "";
2134
2135 // No need to add non-section symbols that have no names
2136 if (symbol.getType() != STT_SECTION &&
2137 (symbol_name == nullptr || symbol_name[0] == '\0'))
2138 continue;
2139
2140 // Skipping oatdata and oatexec sections if it is requested. See details
2141 // above the definition of skip_oatdata_oatexec for the reasons.
2142 if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 ||
2143 ::strcmp(symbol_name, "oatexec") == 0))
2144 continue;
2145
2146 SectionSP symbol_section_sp;
2147 SymbolType symbol_type = eSymbolTypeInvalid;
2148 Elf64_Half shndx = symbol.st_shndx;
2149
2150 switch (shndx) {
2151 case SHN_ABS:
2152 symbol_type = eSymbolTypeAbsolute;
2153 break;
2154 case SHN_UNDEF:
2155 symbol_type = eSymbolTypeUndefined;
2156 break;
2157 default:
2158 symbol_section_sp = section_list->FindSectionByID(shndx);
2159 break;
2160 }
2161
2162 // If a symbol is undefined do not process it further even if it has a STT
2163 // type
2164 if (symbol_type != eSymbolTypeUndefined) {
2165 switch (symbol.getType()) {
2166 default:
2167 case STT_NOTYPE:
2168 // The symbol's type is not specified.
2169 break;
2170
2171 case STT_OBJECT:
2172 // The symbol is associated with a data object, such as a variable, an
2173 // array, etc.
2174 symbol_type = eSymbolTypeData;
2175 break;
2176
2177 case STT_FUNC:
2178 // The symbol is associated with a function or other executable code.
2179 symbol_type = eSymbolTypeCode;
2180 break;
2181
2182 case STT_SECTION:
2183 // The symbol is associated with a section. Symbol table entries of
2184 // this type exist primarily for relocation and normally have STB_LOCAL
2185 // binding.
2186 break;
2187
2188 case STT_FILE:
2189 // Conventionally, the symbol's name gives the name of the source file
2190 // associated with the object file. A file symbol has STB_LOCAL
2191 // binding, its section index is SHN_ABS, and it precedes the other
2192 // STB_LOCAL symbols for the file, if it is present.
2193 symbol_type = eSymbolTypeSourceFile;
2194 break;
2195
2196 case STT_GNU_IFUNC:
2197 // The symbol is associated with an indirect function. The actual
2198 // function will be resolved if it is referenced.
2199 symbol_type = eSymbolTypeResolver;
2200 break;
2201 }
2202 }
2203
2204 if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) {
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) {
2210 symbol_type = eSymbolTypeCode;
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) {
2216 symbol_type = eSymbolTypeData;
2217 }
2218 }
2219 }
2220
2221 int64_t symbol_value_offset = 0;
2222 uint32_t additional_flags = 0;
2223
2224 if (arch.IsValid()) {
2225 if (arch.GetMachine() == llvm::Triple::arm) {
2226 if (symbol.getBinding() == STB_LOCAL) {
2227 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
2228 if (symbol_type == eSymbolTypeCode) {
2229 switch (mapping_symbol) {
2230 case 'a':
2231 // $a[.<any>]* - marks an ARM instruction sequence
2232 address_class_map[symbol.st_value] = AddressClass::eCode;
2233 break;
2234 case 'b':
2235 case 't':
2236 // $b[.<any>]* - marks a THUMB BL instruction sequence
2237 // $t[.<any>]* - marks a THUMB instruction sequence
2238 address_class_map[symbol.st_value] =
2239 AddressClass::eCodeAlternateISA;
2240 break;
2241 case 'd':
2242 // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
2243 address_class_map[symbol.st_value] = AddressClass::eData;
2244 break;
2245 }
2246 }
2247 if (mapping_symbol)
2248 continue;
2249 }
2250 } else if (arch.GetMachine() == llvm::Triple::aarch64) {
2251 if (symbol.getBinding() == STB_LOCAL) {
2252 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
2253 if (symbol_type == eSymbolTypeCode) {
2254 switch (mapping_symbol) {
2255 case 'x':
2256 // $x[.<any>]* - marks an A64 instruction sequence
2257 address_class_map[symbol.st_value] = AddressClass::eCode;
2258 break;
2259 case 'd':
2260 // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
2261 address_class_map[symbol.st_value] = AddressClass::eData;
2262 break;
2263 }
2264 }
2265 if (mapping_symbol)
2266 continue;
2267 }
2268 }
2269
2270 if (arch.GetMachine() == llvm::Triple::arm) {
2271 if (symbol_type == eSymbolTypeCode) {
2272 if (symbol.st_value & 1) {
2273 // Subtracting 1 from the address effectively unsets the low order
2274 // bit, which results in the address actually pointing to the
2275 // beginning of the symbol. This delta will be used below in
2276 // conjunction with symbol.st_value to produce the final
2277 // symbol_value that we store in the symtab.
2278 symbol_value_offset = -1;
2279 address_class_map[symbol.st_value ^ 1] =
2280 AddressClass::eCodeAlternateISA;
2281 } else {
2282 // This address is ARM
2283 address_class_map[symbol.st_value] = AddressClass::eCode;
2284 }
2285 }
2286 }
2287
2288 /*
2289 * MIPS:
2290 * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for
2291 * MIPS).
2292 * This allows processor to switch between microMIPS and MIPS without any
2293 * need
2294 * for special mode-control register. However, apart from .debug_line,
2295 * none of
2296 * the ELF/DWARF sections set the ISA bit (for symbol or section). Use
2297 * st_other
2298 * flag to check whether the symbol is microMIPS and then set the address
2299 * class
2300 * accordingly.
2301 */
2302 if (arch.IsMIPS()) {
2303 if (IS_MICROMIPS(symbol.st_other))
2304 address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA;
2305 else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) {
2306 symbol.st_value = symbol.st_value & (~1ull);
2307 address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA;
2308 } else {
2309 if (symbol_type == eSymbolTypeCode)
2310 address_class_map[symbol.st_value] = AddressClass::eCode;
2311 else if (symbol_type == eSymbolTypeData)
2312 address_class_map[symbol.st_value] = AddressClass::eData;
2313 else
2314 address_class_map[symbol.st_value] = AddressClass::eUnknown;
2315 }
2316 }
2317 }
2318
2319 // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB
2320 // symbols. See above for more details.
2321 uint64_t symbol_value = symbol.st_value + symbol_value_offset;
2322
2323 if (symbol_section_sp &&
2324 CalculateType() != ObjectFile::Type::eTypeObjectFile)
2325 symbol_value -= symbol_section_sp->GetFileAddress();
2326
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,
2333 FindMatchingSection(*module_section_list,
2334 symbol_section_sp))
2335 .first;
2336 }
2337 if (section_it->second)
2338 symbol_section_sp = section_it->second;
2339 }
2340
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);
2344
2345 // Symbol names may contain @VERSION suffixes. Find those and strip them
2346 // temporarily.
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);
2350 Mangled mangled(symbol_bare);
2351
2352 // Now append the suffix back to mangled and unmangled names. Only do it if
2353 // the demangling was successful (string is not empty).
2354 if (has_suffix) {
2355 llvm::StringRef suffix = symbol_ref.substr(version_pos);
2356
2357 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef();
2358 if (!mangled_name.empty())
2359 mangled.SetMangledName(ConstString((mangled_name + suffix).str()));
2360
2361 ConstString demangled = mangled.GetDemangledName();
2362 llvm::StringRef demangled_name = demangled.GetStringRef();
2363 if (!demangled_name.empty())
2364 mangled.SetDemangledName(ConstString((demangled_name + suffix).str()));
2365 }
2366
2367 // In ELF all symbol should have a valid size but it is not true for some
2368 // function symbols coming from hand written assembly. As none of the
2369 // function symbol should have 0 size we try to calculate the size for
2370 // these symbols in the symtab with saying that their original size is not
2371 // valid.
2372 bool symbol_size_valid =
2373 symbol.st_size != 0 || symbol.getType() != STT_FUNC;
2374
2375 bool is_trampoline = false;
2376 if (arch.IsValid() && (arch.GetMachine() == llvm::Triple::aarch64)) {
2377 // On AArch64, trampolines are registered as code.
2378 // If we detect a trampoline (which starts with __AArch64ADRPThunk_ or
2379 // __AArch64AbsLongThunk_) we register the symbol as a trampoline. This
2380 // way we will be able to detect the trampoline when we step in a function
2381 // and step through the trampoline.
2382 if (symbol_type == eSymbolTypeCode) {
2383 llvm::StringRef trampoline_name = mangled.GetName().GetStringRef();
2384 if (trampoline_name.starts_with("__AArch64ADRPThunk_") ||
2385 trampoline_name.starts_with("__AArch64AbsLongThunk_")) {
2386 symbol_type = eSymbolTypeTrampoline;
2387 is_trampoline = true;
2388 }
2389 }
2390 }
2391
2392 Symbol dc_symbol(
2393 i + start_id, // ID is the original symbol table index.
2394 mangled,
2395 symbol_type, // Type of this symbol
2396 is_global, // Is this globally visible?
2397 false, // Is this symbol debug info?
2398 is_trampoline, // Is this symbol a trampoline?
2399 false, // Is this symbol artificial?
2400 AddressRange(symbol_section_sp, // Section in which this symbol is
2401 // defined or null.
2402 symbol_value, // Offset in section or symbol value.
2403 symbol.st_size), // Size in bytes of this symbol.
2404 symbol_size_valid, // Symbol size is valid
2405 has_suffix, // Contains linker annotations?
2406 flags); // Symbol flags.
2407 if (symbol.getBinding() == STB_WEAK)
2408 dc_symbol.SetIsWeak(true);
2409 symtab->AddSymbol(dc_symbol);
2410 }
2411
2412 m_address_class_map.merge(address_class_map);
2413 return {i, address_class_map};
2414}
2415
2416std::pair<unsigned, ObjectFileELF::FileAddressToAddressClassMap>
2418 lldb_private::Section *symtab) {
2419 if (symtab->GetObjectFile() != this) {
2420 // If the symbol table section is owned by a different object file, have it
2421 // do the parsing.
2422 ObjectFileELF *obj_file_elf =
2423 static_cast<ObjectFileELF *>(symtab->GetObjectFile());
2424 auto [num_symbols, address_class_map] =
2425 obj_file_elf->ParseSymbolTable(symbol_table, start_id, symtab);
2426
2427 // The other object file returned the changes it made to its address
2428 // class map, make the same changes to ours.
2429 m_address_class_map.merge(address_class_map);
2430
2431 return {num_symbols, address_class_map};
2432 }
2433
2434 // Get section list for this object file.
2435 SectionList *section_list = m_sections_up.get();
2436 if (!section_list)
2437 return {};
2438
2439 user_id_t symtab_id = symtab->GetID();
2440 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
2441 assert(symtab_hdr->sh_type == SHT_SYMTAB ||
2442 symtab_hdr->sh_type == SHT_DYNSYM);
2443
2444 // sh_link: section header index of associated string table.
2445 user_id_t strtab_id = symtab_hdr->sh_link;
2446 Section *strtab = section_list->FindSectionByID(strtab_id).get();
2447
2448 if (symtab && strtab) {
2449 assert(symtab->GetObjectFile() == this);
2450 assert(strtab->GetObjectFile() == this);
2451
2452 DataExtractor symtab_data;
2453 DataExtractor strtab_data;
2454 if (ReadSectionData(symtab, symtab_data) &&
2455 ReadSectionData(strtab, strtab_data)) {
2456 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize;
2457
2458 return ParseSymbols(symbol_table, start_id, section_list, num_symbols,
2459 symtab_data, strtab_data);
2460 }
2461 }
2462
2463 return {0, {}};
2464}
2465
2467 if (m_dynamic_symbols.size())
2468 return m_dynamic_symbols.size();
2469
2470 std::optional<DataExtractor> dynamic_data = GetDynamicData();
2471 if (!dynamic_data)
2472 return 0;
2473
2475 lldb::offset_t cursor = 0;
2476 while (e.symbol.Parse(*dynamic_data, &cursor)) {
2477 m_dynamic_symbols.push_back(e);
2478 if (e.symbol.d_tag == DT_NULL)
2479 break;
2480 }
2481 if (std::optional<DataExtractor> dynstr_data = GetDynstrData()) {
2482 for (ELFDynamicWithName &entry : m_dynamic_symbols) {
2483 switch (entry.symbol.d_tag) {
2484 case DT_NEEDED:
2485 case DT_SONAME:
2486 case DT_RPATH:
2487 case DT_RUNPATH:
2488 case DT_AUXILIARY:
2489 case DT_FILTER: {
2490 lldb::offset_t cursor = entry.symbol.d_val;
2491 const char *name = dynstr_data->GetCStr(&cursor);
2492 if (name)
2493 entry.name = std::string(name);
2494 break;
2495 }
2496 default:
2497 break;
2498 }
2499 }
2500 }
2501 return m_dynamic_symbols.size();
2502}
2503
2505 if (!ParseDynamicSymbols())
2506 return nullptr;
2507 for (const auto &entry : m_dynamic_symbols) {
2508 if (entry.symbol.d_tag == tag)
2509 return &entry.symbol;
2510 }
2511 return nullptr;
2512}
2513
2515 // DT_PLTREL
2516 // This member specifies the type of relocation entry to which the
2517 // procedure linkage table refers. The d_val member holds DT_REL or
2518 // DT_RELA, as appropriate. All relocations in a procedure linkage table
2519 // must use the same relocation.
2520 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL);
2521
2522 if (symbol)
2523 return symbol->d_val;
2524
2525 return 0;
2526}
2527
2528// Returns the size of the normal plt entries and the offset of the first
2529// normal plt entry. The 0th entry in the plt table is usually a resolution
2530// entry which have different size in some architectures then the rest of the
2531// plt entries.
2532static std::pair<uint64_t, uint64_t>
2534 const ELFSectionHeader *plt_hdr) {
2535 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2536
2537 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are
2538 // 16 bytes. So round the entsize up by the alignment if addralign is set.
2539 elf_xword plt_entsize =
2540 plt_hdr->sh_addralign
2541 ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign)
2542 : plt_hdr->sh_entsize;
2543
2544 // Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field incorrectly.
2545 // PLT entries relocation code in general requires multiple instruction and
2546 // should be greater than 4 bytes in most cases. Try to guess correct size
2547 // just in case.
2548 if (plt_entsize <= 4) {
2549 // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the
2550 // size of the plt entries based on the number of entries and the size of
2551 // the plt section with the assumption that the size of the 0th entry is at
2552 // least as big as the size of the normal entries and it isn't much bigger
2553 // then that.
2554 if (plt_hdr->sh_addralign)
2555 plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign /
2556 (num_relocations + 1) * plt_hdr->sh_addralign;
2557 else
2558 plt_entsize = plt_hdr->sh_size / (num_relocations + 1);
2559 }
2560
2561 elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize;
2562
2563 return std::make_pair(plt_entsize, plt_offset);
2564}
2565
2566static unsigned ParsePLTRelocations(
2567 Symtab *symbol_table, user_id_t start_id, unsigned rel_type,
2568 const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
2569 const ELFSectionHeader *plt_hdr, const ELFSectionHeader *sym_hdr,
2570 const lldb::SectionSP &plt_section_sp, DataExtractor &rel_data,
2571 DataExtractor &symtab_data, DataExtractor &strtab_data) {
2572 ELFRelocation rel(rel_type);
2573 ELFSymbol symbol;
2574 lldb::offset_t offset = 0;
2575
2576 uint64_t plt_offset, plt_entsize;
2577 std::tie(plt_entsize, plt_offset) =
2578 GetPltEntrySizeAndOffset(rel_hdr, plt_hdr);
2579 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2580
2581 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
2582 reloc_info_fn reloc_type;
2583 reloc_info_fn reloc_symbol;
2584
2585 if (hdr->Is32Bit()) {
2586 reloc_type = ELFRelocation::RelocType32;
2587 reloc_symbol = ELFRelocation::RelocSymbol32;
2588 } else {
2589 reloc_type = ELFRelocation::RelocType64;
2590 reloc_symbol = ELFRelocation::RelocSymbol64;
2591 }
2592
2593 unsigned slot_type = hdr->GetRelocationJumpSlotType();
2594 unsigned i;
2595 for (i = 0; i < num_relocations; ++i) {
2596 if (!rel.Parse(rel_data, &offset))
2597 break;
2598
2599 if (reloc_type(rel) != slot_type)
2600 continue;
2601
2602 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize;
2603 if (!symbol.Parse(symtab_data, &symbol_offset))
2604 break;
2605
2606 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
2607 uint64_t plt_index = plt_offset + i * plt_entsize;
2608
2609 Symbol jump_symbol(
2610 i + start_id, // Symbol table index
2611 symbol_name, // symbol name.
2612 eSymbolTypeTrampoline, // Type of this symbol
2613 false, // Is this globally visible?
2614 false, // Is this symbol debug info?
2615 true, // Is this symbol a trampoline?
2616 true, // Is this symbol artificial?
2617 plt_section_sp, // Section in which this symbol is defined or null.
2618 plt_index, // Offset in section or symbol value.
2619 plt_entsize, // Size in bytes of this symbol.
2620 true, // Size is valid
2621 false, // Contains linker annotations?
2622 0); // Symbol flags.
2623
2624 symbol_table->AddSymbol(jump_symbol);
2625 }
2626
2627 return i;
2628}
2629
2630unsigned
2632 const ELFSectionHeaderInfo *rel_hdr,
2633 user_id_t rel_id) {
2634 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL);
2635
2636 // The link field points to the associated symbol table.
2637 user_id_t symtab_id = rel_hdr->sh_link;
2638
2639 // If the link field doesn't point to the appropriate symbol name table then
2640 // try to find it by name as some compiler don't fill in the link fields.
2641 if (!symtab_id)
2642 symtab_id = GetSectionIndexByName(".dynsym");
2643
2644 // Get PLT section. We cannot use rel_hdr->sh_info, since current linkers
2645 // point that to the .got.plt or .got section instead of .plt.
2646 user_id_t plt_id = GetSectionIndexByName(".plt");
2647
2648 if (!symtab_id || !plt_id)
2649 return 0;
2650
2651 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id);
2652 if (!plt_hdr)
2653 return 0;
2654
2655 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id);
2656 if (!sym_hdr)
2657 return 0;
2658
2659 SectionList *section_list = m_sections_up.get();
2660 if (!section_list)
2661 return 0;
2662
2663 Section *rel_section = section_list->FindSectionByID(rel_id).get();
2664 if (!rel_section)
2665 return 0;
2666
2667 SectionSP plt_section_sp(section_list->FindSectionByID(plt_id));
2668 if (!plt_section_sp)
2669 return 0;
2670
2671 Section *symtab = section_list->FindSectionByID(symtab_id).get();
2672 if (!symtab)
2673 return 0;
2674
2675 // sh_link points to associated string table.
2676 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link).get();
2677 if (!strtab)
2678 return 0;
2679
2680 DataExtractor rel_data;
2681 if (!ReadSectionData(rel_section, rel_data))
2682 return 0;
2683
2684 DataExtractor symtab_data;
2685 if (!ReadSectionData(symtab, symtab_data))
2686 return 0;
2687
2688 DataExtractor strtab_data;
2689 if (!ReadSectionData(strtab, strtab_data))
2690 return 0;
2691
2692 unsigned rel_type = PLTRelocationType();
2693 if (!rel_type)
2694 return 0;
2695
2696 return ParsePLTRelocations(symbol_table, start_id, rel_type, &m_header,
2697 rel_hdr, plt_hdr, sym_hdr, plt_section_sp,
2698 rel_data, symtab_data, strtab_data);
2699}
2700
2701static void ApplyELF64ABS64Relocation(Symtab *symtab, ELFRelocation &rel,
2702 DataExtractor &debug_data,
2703 Section *rel_section) {
2704 Symbol *symbol = symtab->FindSymbolByID(ELFRelocation::RelocSymbol64(rel));
2705 if (symbol) {
2706 addr_t value = symbol->GetAddressRef().GetFileAddress();
2707 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2708 // ObjectFileELF creates a WritableDataBuffer in CreateInstance.
2709 WritableDataBuffer *data_buffer =
2710 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2711 uint64_t *dst = reinterpret_cast<uint64_t *>(
2712 data_buffer->GetBytes() + rel_section->GetFileOffset() +
2713 ELFRelocation::RelocOffset64(rel));
2714 uint64_t val_offset = value + ELFRelocation::RelocAddend64(rel);
2715 memcpy(dst, &val_offset, sizeof(uint64_t));
2716 }
2717}
2718
2719static void ApplyELF64ABS32Relocation(Symtab *symtab, ELFRelocation &rel,
2720 DataExtractor &debug_data,
2721 Section *rel_section, bool is_signed) {
2722 Symbol *symbol = symtab->FindSymbolByID(ELFRelocation::RelocSymbol64(rel));
2723 if (symbol) {
2724 addr_t value = symbol->GetAddressRef().GetFileAddress();
2725 value += ELFRelocation::RelocAddend32(rel);
2726 if ((!is_signed && (value > UINT32_MAX)) ||
2727 (is_signed &&
2728 ((int64_t)value > INT32_MAX || (int64_t)value < INT32_MIN))) {
2729 Log *log = GetLog(LLDBLog::Modules);
2730 LLDB_LOGF(log, "Failed to apply debug info relocations");
2731 return;
2732 }
2733 uint32_t truncated_addr = (value & 0xFFFFFFFF);
2734 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2735 // ObjectFileELF creates a WritableDataBuffer in CreateInstance.
2736 WritableDataBuffer *data_buffer =
2737 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2738 uint32_t *dst = reinterpret_cast<uint32_t *>(
2739 data_buffer->GetBytes() + rel_section->GetFileOffset() +
2740 ELFRelocation::RelocOffset32(rel));
2741 memcpy(dst, &truncated_addr, sizeof(uint32_t));
2742 }
2743}
2744
2745static void ApplyELF32ABS32RelRelocation(Symtab *symtab, ELFRelocation &rel,
2746 DataExtractor &debug_data,
2747 Section *rel_section) {
2748 Log *log = GetLog(LLDBLog::Modules);
2749 Symbol *symbol = symtab->FindSymbolByID(ELFRelocation::RelocSymbol32(rel));
2750 if (symbol) {
2751 addr_t value = symbol->GetAddressRef().GetFileAddress();
2752 if (value == LLDB_INVALID_ADDRESS) {
2753 const char *name = symbol->GetName().GetCString();
2754 LLDB_LOGF(log, "Debug info symbol invalid: %s", name);
2755 return;
2756 }
2757 assert(llvm::isUInt<32>(value) && "Valid addresses are 32-bit");
2758 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2759 // ObjectFileELF creates a WritableDataBuffer in CreateInstance.
2760 WritableDataBuffer *data_buffer =
2761 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2762 uint8_t *dst = data_buffer->GetBytes() + rel_section->GetFileOffset() +
2763 ELFRelocation::RelocOffset32(rel);
2764 // Implicit addend is stored inline as a signed value.
2765 int32_t addend;
2766 memcpy(&addend, dst, sizeof(int32_t));
2767 // The sum must be positive. This extra check prevents UB from overflow in
2768 // the actual range check below.
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);
2772 return;
2773 }
2774 if (!llvm::isUInt<32>(value + addend)) {
2775 LLDB_LOGF(log, "Debug info relocation out of range: 0x%" PRIx64, value);
2776 return;
2777 }
2778 uint32_t addr = value + addend;
2779 memcpy(dst, &addr, sizeof(uint32_t));
2780 }
2781}
2782
2784 Symtab *symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
2785 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr,
2786 DataExtractor &rel_data, DataExtractor &symtab_data,
2787 DataExtractor &debug_data, Section *rel_section) {
2788 ELFRelocation rel(rel_hdr->sh_type);
2789 lldb::addr_t offset = 0;
2790 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2791 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
2792 reloc_info_fn reloc_type;
2793 reloc_info_fn reloc_symbol;
2794
2795 if (hdr->Is32Bit()) {
2796 reloc_type = ELFRelocation::RelocType32;
2797 reloc_symbol = ELFRelocation::RelocSymbol32;
2798 } else {
2799 reloc_type = ELFRelocation::RelocType64;
2800 reloc_symbol = ELFRelocation::RelocSymbol64;
2801 }
2802
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",
2806 rel_section->GetName().AsCString(), i);
2807 break;
2808 }
2809 Symbol *symbol = nullptr;
2810
2811 if (hdr->Is32Bit()) {
2812 switch (hdr->e_machine) {
2813 case llvm::ELF::EM_ARM:
2814 switch (reloc_type(rel)) {
2815 case R_ARM_ABS32:
2816 ApplyELF32ABS32RelRelocation(symtab, rel, debug_data, rel_section);
2817 break;
2818 case R_ARM_REL32:
2819 GetModule()->ReportError("unsupported AArch32 relocation:"
2820 " .rel{0}[{1}], type {2}",
2821 rel_section->GetName().AsCString(), i,
2822 reloc_type(rel));
2823 break;
2824 default:
2825 assert(false && "unexpected relocation type");
2826 }
2827 break;
2828 case llvm::ELF::EM_386:
2829 switch (reloc_type(rel)) {
2830 case R_386_32:
2831 symbol = symtab->FindSymbolByID(reloc_symbol(rel));
2832 if (symbol) {
2833 addr_t f_offset =
2834 rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel);
2835 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2836 // ObjectFileELF creates a WritableDataBuffer in CreateInstance.
2837 WritableDataBuffer *data_buffer =
2838 llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
2839 uint32_t *dst = reinterpret_cast<uint32_t *>(
2840 data_buffer->GetBytes() + f_offset);
2841
2842 addr_t value = symbol->GetAddressRef().GetFileAddress();
2843 if (rel.IsRela()) {
2844 value += ELFRelocation::RelocAddend32(rel);
2845 } else {
2846 value += *dst;
2847 }
2848 *dst = value;
2849 } else {
2850 GetModule()->ReportError(".rel{0}[{1}] unknown symbol id: {2:d}",
2851 rel_section->GetName().AsCString(), i,
2852 reloc_symbol(rel));
2853 }
2854 break;
2855 case R_386_NONE:
2856 case R_386_PC32:
2857 GetModule()->ReportError("unsupported i386 relocation:"
2858 " .rel{0}[{1}], type {2}",
2859 rel_section->GetName().AsCString(), i,
2860 reloc_type(rel));
2861 break;
2862 default:
2863 assert(false && "unexpected relocation type");
2864 break;
2865 }
2866 break;
2867 default:
2868 GetModule()->ReportError("unsupported 32-bit ELF machine arch: {0}", hdr->e_machine);
2869 break;
2870 }
2871 } else {
2872 switch (hdr->e_machine) {
2873 case llvm::ELF::EM_AARCH64:
2874 switch (reloc_type(rel)) {
2875 case R_AARCH64_ABS64:
2876 ApplyELF64ABS64Relocation(symtab, rel, debug_data, rel_section);
2877 break;
2878 case R_AARCH64_ABS32:
2879 ApplyELF64ABS32Relocation(symtab, rel, debug_data, rel_section, true);
2880 break;
2881 default:
2882 assert(false && "unexpected relocation type");
2883 }
2884 break;
2885 case llvm::ELF::EM_LOONGARCH:
2886 switch (reloc_type(rel)) {
2887 case R_LARCH_64:
2888 ApplyELF64ABS64Relocation(symtab, rel, debug_data, rel_section);
2889 break;
2890 case R_LARCH_32:
2891 ApplyELF64ABS32Relocation(symtab, rel, debug_data, rel_section, true);
2892 break;
2893 default:
2894 assert(false && "unexpected relocation type");
2895 }
2896 break;
2897 case llvm::ELF::EM_X86_64:
2898 switch (reloc_type(rel)) {
2899 case R_X86_64_64:
2900 ApplyELF64ABS64Relocation(symtab, rel, debug_data, rel_section);
2901 break;
2902 case R_X86_64_32:
2903 ApplyELF64ABS32Relocation(symtab, rel, debug_data, rel_section,
2904 false);
2905 break;
2906 case R_X86_64_32S:
2907 ApplyELF64ABS32Relocation(symtab, rel, debug_data, rel_section, true);
2908 break;
2909 case R_X86_64_PC32:
2910 default:
2911 assert(false && "unexpected relocation type");
2912 }
2913 break;
2914 default:
2915 GetModule()->ReportError("unsupported 64-bit ELF machine arch: {0}", hdr->e_machine);
2916 break;
2917 }
2918 }
2919 }
2920
2921 return 0;
2922}
2923
2925 user_id_t rel_id,
2926 lldb_private::Symtab *thetab) {
2927 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL);
2928
2929 // Parse in the section list if needed.
2930 SectionList *section_list = GetSectionList();
2931 if (!section_list)
2932 return 0;
2933
2934 user_id_t symtab_id = rel_hdr->sh_link;
2935 user_id_t debug_id = rel_hdr->sh_info;
2936
2937 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
2938 if (!symtab_hdr)
2939 return 0;
2940
2941 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id);
2942 if (!debug_hdr)
2943 return 0;
2944
2945 Section *rel = section_list->FindSectionByID(rel_id).get();
2946 if (!rel)
2947 return 0;
2948
2949 Section *symtab = section_list->FindSectionByID(symtab_id).get();
2950 if (!symtab)
2951 return 0;
2952
2953 Section *debug = section_list->FindSectionByID(debug_id).get();
2954 if (!debug)
2955 return 0;
2956
2957 DataExtractor rel_data;
2958 DataExtractor symtab_data;
2959 DataExtractor debug_data;
2960
2961 if (GetData(rel->GetFileOffset(), rel->GetFileSize(), rel_data) &&
2962 GetData(symtab->GetFileOffset(), symtab->GetFileSize(), symtab_data) &&
2963 GetData(debug->GetFileOffset(), debug->GetFileSize(), debug_data)) {
2964 ApplyRelocations(thetab, &m_header, rel_hdr, symtab_hdr, debug_hdr,
2965 rel_data, symtab_data, debug_data, debug);
2966 }
2967
2968 return 0;
2969}
2970
2972 ModuleSP module_sp(GetModule());
2973 if (!module_sp)
2974 return;
2975
2976 Progress progress("Parsing symbol table",
2977 m_file.GetFilename().AsCString("<Unknown>"));
2978 ElapsedTime elapsed(module_sp->GetSymtabParseTime());
2979
2980 // We always want to use the main object file so we (hopefully) only have one
2981 // cached copy of our symtab, dynamic sections, etc.
2982 ObjectFile *module_obj_file = module_sp->GetObjectFile();
2983 if (module_obj_file && module_obj_file != this)
2984 return module_obj_file->ParseSymtab(lldb_symtab);
2985
2986 SectionList *section_list = module_sp->GetSectionList();
2987 if (!section_list)
2988 return;
2989
2990 uint64_t symbol_id = 0;
2991
2992 // Sharable objects and dynamic executables usually have 2 distinct symbol
2993 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
2994 // smaller version of the symtab that only contains global symbols. The
2995 // information found in the dynsym is therefore also found in the symtab,
2996 // while the reverse is not necessarily true.
2997 Section *symtab =
2998 section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get();
2999 if (symtab) {
3000 auto [num_symbols, address_class_map] =
3001 ParseSymbolTable(&lldb_symtab, symbol_id, symtab);
3002 m_address_class_map.merge(address_class_map);
3003 symbol_id += num_symbols;
3004 }
3005
3006 // The symtab section is non-allocable and can be stripped, while the
3007 // .dynsym section which should always be always be there. To support the
3008 // minidebuginfo case we parse .dynsym when there's a .gnu_debuginfo
3009 // section, nomatter if .symtab was already parsed or not. This is because
3010 // minidebuginfo normally removes the .symtab symbols which have their
3011 // matching .dynsym counterparts.
3012 if (!symtab ||
3013 GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"))) {
3014 Section *dynsym =
3016 .get();
3017 if (dynsym) {
3018 auto [num_symbols, address_class_map] =
3019 ParseSymbolTable(&lldb_symtab, symbol_id, dynsym);
3020 symbol_id += num_symbols;
3021 m_address_class_map.merge(address_class_map);
3022 } else {
3023 // Try and read the dynamic symbol table from the .dynamic section.
3024 uint32_t dynamic_num_symbols = 0;
3025 std::optional<DataExtractor> symtab_data =
3026 GetDynsymDataFromDynamic(dynamic_num_symbols);
3027 std::optional<DataExtractor> strtab_data = GetDynstrData();
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;
3033 m_address_class_map.merge(address_class_map);
3034 }
3035 }
3036 }
3037
3038 // DT_JMPREL
3039 // If present, this entry's d_ptr member holds the address of
3040 // relocation
3041 // entries associated solely with the procedure linkage table.
3042 // Separating
3043 // these relocation entries lets the dynamic linker ignore them during
3044 // process initialization, if lazy binding is enabled. If this entry is
3045 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must
3046 // also be present.
3047 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL);
3048 if (symbol) {
3049 // Synthesize trampoline symbols to help navigate the PLT.
3050 addr_t addr = symbol->d_ptr;
3051 Section *reloc_section =
3052 section_list->FindSectionContainingFileAddress(addr).get();
3053 if (reloc_section) {
3054 user_id_t reloc_id = reloc_section->GetID();
3055 const ELFSectionHeaderInfo *reloc_header =
3056 GetSectionHeaderByIndex(reloc_id);
3057 if (reloc_header)
3058 ParseTrampolineSymbols(&lldb_symtab, symbol_id, reloc_header, reloc_id);
3059 }
3060 }
3061
3062 if (DWARFCallFrameInfo *eh_frame =
3063 GetModule()->GetUnwindTable().GetEHFrameInfo()) {
3064 ParseUnwindSymbols(&lldb_symtab, eh_frame);
3065 }
3066
3067 // In the event that there's no symbol entry for the entry point we'll
3068 // artificially create one. We delegate to the symtab object the figuring
3069 // out of the proper size, this will usually make it span til the next
3070 // symbol it finds in the section. This means that if there are missing
3071 // symbols the entry point might span beyond its function definition.
3072 // We're fine with this as it doesn't make it worse than not having a
3073 // symbol entry at all.
3074 if (CalculateType() == eTypeExecutable) {
3075 ArchSpec arch = GetArchitecture();
3076 auto entry_point_addr = GetEntryPointAddress();
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();
3080 if (is_valid_entry_point && !lldb_symtab.FindSymbolContainingFileAddress(
3081 entry_point_file_addr)) {
3082 uint64_t symbol_id = lldb_symtab.GetNumSymbols();
3083 // Don't set the name for any synthetic symbols, the Symbol
3084 // object will generate one if needed when the name is accessed
3085 // via accessors.
3086 SectionSP section_sp = entry_point_addr.GetSection();
3087 Symbol symbol(
3088 /*symID=*/symbol_id,
3089 /*name=*/llvm::StringRef(), // Name will be auto generated.
3090 /*type=*/eSymbolTypeCode,
3091 /*external=*/true,
3092 /*is_debug=*/false,
3093 /*is_trampoline=*/false,
3094 /*is_artificial=*/true,
3095 /*section_sp=*/section_sp,
3096 /*offset=*/0,
3097 /*size=*/0, // FDE can span multiple symbols so don't use its size.
3098 /*size_is_valid=*/false,
3099 /*contains_linker_annotations=*/false,
3100 /*flags=*/0);
3101 // When the entry point is arm thumb we need to explicitly set its
3102 // class address to reflect that. This is important because expression
3103 // evaluation relies on correctly setting a breakpoint at this
3104 // address.
3105 if (arch.GetMachine() == llvm::Triple::arm &&
3106 (entry_point_file_addr & 1)) {
3107 symbol.GetAddressRef().SetOffset(entry_point_addr.GetOffset() ^ 1);
3108 m_address_class_map[entry_point_file_addr ^ 1] =
3109 AddressClass::eCodeAlternateISA;
3110 } else {
3111 m_address_class_map[entry_point_file_addr] = AddressClass::eCode;
3112 }
3113 lldb_symtab.AddSymbol(symbol);
3114 }
3115 }
3116}
3117
3119{
3120 static const char *debug_prefix = ".debug";
3121
3122 // Set relocated bit so we stop getting called, regardless of whether we
3123 // actually relocate.
3124 section->SetIsRelocated(true);
3125
3126 // We only relocate in ELF relocatable files
3128 return;
3129
3130 const char *section_name = section->GetName().GetCString();
3131 // Can't relocate that which can't be named
3132 if (section_name == nullptr)
3133 return;
3134
3135 // We don't relocate non-debug sections at the moment
3136 if (strncmp(section_name, debug_prefix, strlen(debug_prefix)))
3137 return;
3138
3139 // Relocation section names to look for
3140 std::string needle = std::string(".rel") + section_name;
3141 std::string needlea = std::string(".rela") + section_name;
3142
3144 I != m_section_headers.end(); ++I) {
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)
3148 continue;
3149 if (needle == hay_name || needlea == hay_name) {
3150 const ELFSectionHeader &reloc_header = *I;
3151 user_id_t reloc_id = SectionIndex(I);
3152 RelocateDebugSections(&reloc_header, reloc_id, GetSymtab());
3153 break;
3154 }
3155 }
3156 }
3157}
3158
3160 DWARFCallFrameInfo *eh_frame) {
3161 SectionList *section_list = GetSectionList();
3162 if (!section_list)
3163 return;
3164
3165 // First we save the new symbols into a separate list and add them to the
3166 // symbol table after we collected all symbols we want to add. This is
3167 // neccessary because adding a new symbol invalidates the internal index of
3168 // the symtab what causing the next lookup to be slow because it have to
3169 // recalculate the index first.
3170 std::vector<Symbol> new_symbols;
3171
3172 size_t num_symbols = symbol_table->GetNumSymbols();
3173 uint64_t last_symbol_id =
3174 num_symbols ? symbol_table->SymbolAtIndex(num_symbols - 1)->GetID() : 0;
3175 eh_frame->ForEachFDEEntries([&](lldb::addr_t file_addr, uint32_t size,
3176 dw_offset_t) {
3177 Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr);
3178 if (symbol) {
3179 if (!symbol->GetByteSizeIsValid()) {
3180 symbol->SetByteSize(size);
3181 symbol->SetSizeIsSynthesized(true);
3182 }
3183 } else {
3184 SectionSP section_sp =
3185 section_list->FindSectionContainingFileAddress(file_addr);
3186 if (section_sp) {
3187 addr_t offset = file_addr - section_sp->GetFileAddress();
3188 uint64_t symbol_id = ++last_symbol_id;
3189 // Don't set the name for any synthetic symbols, the Symbol
3190 // object will generate one if needed when the name is accessed
3191 // via accessors.
3192 Symbol eh_symbol(
3193 /*symID=*/symbol_id,
3194 /*name=*/llvm::StringRef(), // Name will be auto generated.
3195 /*type=*/eSymbolTypeCode,
3196 /*external=*/true,
3197 /*is_debug=*/false,
3198 /*is_trampoline=*/false,
3199 /*is_artificial=*/true,
3200 /*section_sp=*/section_sp,
3201 /*offset=*/offset,
3202 /*size=*/0, // FDE can span multiple symbols so don't use its size.
3203 /*size_is_valid=*/false,
3204 /*contains_linker_annotations=*/false,
3205 /*flags=*/0);
3206 new_symbols.push_back(eh_symbol);
3207 }
3208 }
3209 return true;
3210 });
3211
3212 for (const Symbol &s : new_symbols)
3213 symbol_table->AddSymbol(s);
3214}
3215
3217 // TODO: determine this for ELF
3218 return false;
3219}
3220
3221//===----------------------------------------------------------------------===//
3222// Dump
3223//
3224// Dump the specifics of the runtime file container (such as any headers
3225// segments, sections, etc).
3227 ModuleSP module_sp(GetModule());
3228 if (!module_sp) {
3229 return;
3230 }
3231
3232 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
3233 s->Printf("%p: ", static_cast<void *>(this));
3234 s->Indent();
3235 s->PutCString("ObjectFileELF");
3236
3237 ArchSpec header_arch = GetArchitecture();
3238
3239 *s << ", file = '" << m_file
3240 << "', arch = " << header_arch.GetArchitectureName();
3242 s->Printf(", addr = %#16.16" PRIx64, m_memory_addr);
3243 s->EOL();
3244
3246 s->EOL();
3248 s->EOL();
3250 s->EOL();
3251 SectionList *section_list = GetSectionList();
3252 if (section_list)
3253 section_list->Dump(s->AsRawOstream(), s->GetIndentLevel(), nullptr, true,
3254 UINT32_MAX);
3255 Symtab *symtab = GetSymtab();
3256 if (symtab)
3257 symtab->Dump(s, nullptr, eSortOrderNone);
3258 s->EOL();
3260 s->EOL();
3261 DumpELFDynamic(s);
3262 s->EOL();
3263 Address image_info_addr = GetImageInfoAddress(nullptr);
3264 if (image_info_addr.IsValid())
3265 s->Printf("image_info_address = %#16.16" PRIx64 "\n",
3266 image_info_addr.GetFileAddress());
3267}
3268
3269// DumpELFHeader
3270//
3271// Dump the ELF header to the specified output stream
3273 s->PutCString("ELF Header\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],
3276 header.e_ident[EI_MAG1]);
3277 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG2],
3278 header.e_ident[EI_MAG2]);
3279 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG3],
3280 header.e_ident[EI_MAG3]);
3281
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]);
3284 DumpELFHeader_e_ident_EI_DATA(s, 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]);
3287
3288 s->Printf("e_type = 0x%4.4x ", header.e_type);
3289 DumpELFHeader_e_type(s, header.e_type);
3290 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine);
3291 s->Printf("e_version = 0x%8.8x\n", header.e_version);
3292 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry);
3293 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff);
3294 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff);
3295 s->Printf("e_flags = 0x%8.8x\n", header.e_flags);
3296 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize);
3297 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize);
3298 s->Printf("e_phnum = 0x%8.8x\n", header.e_phnum);
3299 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize);
3300 s->Printf("e_shnum = 0x%8.8x\n", header.e_shnum);
3301 s->Printf("e_shstrndx = 0x%8.8x\n", header.e_shstrndx);
3302}
3303
3304// DumpELFHeader_e_type
3305//
3306// Dump an token value for the ELF header member e_type
3308 switch (e_type) {
3309 case ET_NONE:
3310 *s << "ET_NONE";
3311 break;
3312 case ET_REL:
3313 *s << "ET_REL";
3314 break;
3315 case ET_EXEC:
3316 *s << "ET_EXEC";
3317 break;
3318 case ET_DYN:
3319 *s << "ET_DYN";
3320 break;
3321 case ET_CORE:
3322 *s << "ET_CORE";
3323 break;
3324 default:
3325 break;
3326 }
3327}
3328
3329// DumpELFHeader_e_ident_EI_DATA
3330//
3331// Dump an token value for the ELF header member e_ident[EI_DATA]
3333 unsigned char ei_data) {
3334 switch (ei_data) {
3335 case ELFDATANONE:
3336 *s << "ELFDATANONE";
3337 break;
3338 case ELFDATA2LSB:
3339 *s << "ELFDATA2LSB - Little Endian";
3340 break;
3341 case ELFDATA2MSB:
3342 *s << "ELFDATA2MSB - Big Endian";
3343 break;
3344 default:
3345 break;
3346 }
3347}
3348
3349// DumpELFProgramHeader
3350//
3351// Dump a single ELF program header to the specified output stream
3353 const ELFProgramHeader &ph) {
3355 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset,
3356 ph.p_vaddr, ph.p_paddr);
3357 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz,
3358 ph.p_flags);
3359
3361 s->Printf(") %8.8" PRIx64, ph.p_align);
3362}
3363
3364// DumpELFProgramHeader_p_type
3365//
3366// Dump an token value for the ELF program header member p_type which describes
3367// the type of the program header
3369 const int kStrWidth = 15;
3370 switch (p_type) {
3371 CASE_AND_STREAM(s, PT_NULL, kStrWidth);
3372 CASE_AND_STREAM(s, PT_LOAD, kStrWidth);
3373 CASE_AND_STREAM(s, PT_DYNAMIC, kStrWidth);
3374 CASE_AND_STREAM(s, PT_INTERP, kStrWidth);
3375 CASE_AND_STREAM(s, PT_NOTE, kStrWidth);
3376 CASE_AND_STREAM(s, PT_SHLIB, kStrWidth);
3377 CASE_AND_STREAM(s, PT_PHDR, kStrWidth);
3378 CASE_AND_STREAM(s, PT_TLS, kStrWidth);
3379 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth);
3380 default:
3381 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, "");
3382 break;
3383 }
3384}
3385
3386// DumpELFProgramHeader_p_flags
3387//
3388// Dump an token value for the ELF program header member p_flags
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" : " ");
3395}
3396
3397// DumpELFProgramHeaders
3398//
3399// Dump all of the ELF program header to the specified output stream
3401 if (!ParseProgramHeaders())
3402 return;
3403
3404 s->PutCString("Program Headers\n");
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");
3409
3410 for (const auto &H : llvm::enumerate(m_program_headers)) {
3411 s->Format("[{0,2}] ", H.index());
3413 s->EOL();
3414 }
3415}
3416
3417// DumpELFSectionHeader
3418//
3419// Dump a single ELF section header to the specified output stream
3421 const ELFSectionHeaderInfo &sh) {
3422 s->Printf("%8.8x ", sh.sh_name);
3424 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags);
3426 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr,
3427 sh.sh_offset, sh.sh_size);
3428 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info);
3429 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize);
3430}
3431
3432// DumpELFSectionHeader_sh_type
3433//
3434// Dump an token value for the ELF section header member sh_type which
3435// describes the type of the section
3437 const int kStrWidth = 12;
3438 switch (sh_type) {
3439 CASE_AND_STREAM(s, SHT_NULL, kStrWidth);
3440 CASE_AND_STREAM(s, SHT_PROGBITS, kStrWidth);
3441 CASE_AND_STREAM(s, SHT_SYMTAB, kStrWidth);
3442 CASE_AND_STREAM(s, SHT_STRTAB, kStrWidth);
3443 CASE_AND_STREAM(s, SHT_RELA, kStrWidth);
3444 CASE_AND_STREAM(s, SHT_HASH, kStrWidth);
3445 CASE_AND_STREAM(s, SHT_DYNAMIC, kStrWidth);
3446 CASE_AND_STREAM(s, SHT_NOTE, kStrWidth);
3447 CASE_AND_STREAM(s, SHT_NOBITS, kStrWidth);
3448 CASE_AND_STREAM(s, SHT_REL, kStrWidth);
3449 CASE_AND_STREAM(s, SHT_SHLIB, kStrWidth);
3450 CASE_AND_STREAM(s, SHT_DYNSYM, kStrWidth);
3451 CASE_AND_STREAM(s, SHT_LOPROC, kStrWidth);
3452 CASE_AND_STREAM(s, SHT_HIPROC, kStrWidth);
3453 CASE_AND_STREAM(s, SHT_LOUSER, kStrWidth);
3454 CASE_AND_STREAM(s, SHT_HIUSER, kStrWidth);
3455 default:
3456 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, "");
3457 break;
3458 }
3459}
3460
3461// DumpELFSectionHeader_sh_flags
3462//
3463// Dump an token value for the ELF section header member sh_flags
3465 elf_xword sh_flags) {
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" : " ");
3471}
3472
3473// DumpELFSectionHeaders
3474//
3475// Dump all of the ELF section header to the specified output stream
3477 if (!ParseSectionHeaders())
3478 return;
3479
3480 s->PutCString("Section Headers\n");
3481 s->PutCString("IDX name type flags "
3482 "addr offset size link info addralgn "
3483 "entsize Name\n");
3484 s->PutCString("==== -------- ------------ -------------------------------- "
3485 "-------- -------- -------- -------- -------- -------- "
3486 "-------- ====================\n");
3487
3488 uint32_t idx = 0;
3490 I != m_section_headers.end(); ++I, ++idx) {
3491 s->Printf("[%2u] ", idx);
3493 const char *section_name = I->section_name.AsCString("");
3494 if (section_name)
3495 *s << ' ' << section_name << "\n";
3496 }
3497}
3498
3500 size_t num_modules = ParseDependentModules();
3501
3502 if (num_modules > 0) {
3503 s->PutCString("Dependent Modules:\n");
3504 for (unsigned i = 0; i < num_modules; ++i) {
3505 const FileSpec &spec = m_filespec_up->GetFileSpecAtIndex(i);
3506 s->Printf(" %s\n", spec.GetFilename().GetCString());
3507 }
3508 }
3509}
3510
3511std::string static getDynamicTagAsString(uint16_t Arch, uint64_t Type) {
3512#define DYNAMIC_STRINGIFY_ENUM(tag, value) \
3513 case value: \
3514 return #tag;
3515
3516#define DYNAMIC_TAG(n, v)
3517 switch (Arch) {
3518 case llvm::ELF::EM_AARCH64:
3519 switch (Type) {
3520#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3521#include "llvm/BinaryFormat/DynamicTags.def"
3522#undef AARCH64_DYNAMIC_TAG
3523 }
3524 break;
3525
3526 case llvm::ELF::EM_HEXAGON:
3527 switch (Type) {
3528#define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3529#include "llvm/BinaryFormat/DynamicTags.def"
3530#undef HEXAGON_DYNAMIC_TAG
3531 }
3532 break;
3533
3534 case llvm::ELF::EM_MIPS:
3535 switch (Type) {
3536#define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3537#include "llvm/BinaryFormat/DynamicTags.def"
3538#undef MIPS_DYNAMIC_TAG
3539 }
3540 break;
3541
3542 case llvm::ELF::EM_PPC:
3543 switch (Type) {
3544#define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3545#include "llvm/BinaryFormat/DynamicTags.def"
3546#undef PPC_DYNAMIC_TAG
3547 }
3548 break;
3549
3550 case llvm::ELF::EM_PPC64:
3551 switch (Type) {
3552#define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3553#include "llvm/BinaryFormat/DynamicTags.def"
3554#undef PPC64_DYNAMIC_TAG
3555 }
3556 break;
3557
3558 case llvm::ELF::EM_RISCV:
3559 switch (Type) {
3560#define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
3561#include "llvm/BinaryFormat/DynamicTags.def"
3562#undef RISCV_DYNAMIC_TAG
3563 }
3564 break;
3565 }
3566#undef DYNAMIC_TAG
3567 switch (Type) {
3568// Now handle all dynamic tags except the architecture specific ones
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)
3575// Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
3576#define DYNAMIC_TAG_MARKER(name, value)
3577#define DYNAMIC_TAG(name, value) \
3578 case value: \
3579 return #name;
3580#include "llvm/BinaryFormat/DynamicTags.def"
3581#undef DYNAMIC_TAG
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
3590 default:
3591 return "<unknown:>0x" + llvm::utohexstr(Type, true);
3592 }
3593}
3594
3597 if (m_dynamic_symbols.empty())
3598 return;
3599
3600 s->PutCString(".dynamic:\n");
3601 s->PutCString("IDX d_tag d_val/d_ptr\n");
3602 s->PutCString("==== ---------------- ------------------\n");
3603 uint32_t idx = 0;
3604 for (const auto &entry : m_dynamic_symbols) {
3605 s->Printf("[%2u] ", idx++);
3606 s->Printf(
3607 "%-16s 0x%16.16" PRIx64,
3608 getDynamicTagAsString(m_header.e_machine, entry.symbol.d_tag).c_str(),
3609 entry.symbol.d_ptr);
3610 if (!entry.name.empty())
3611 s->Printf(" \"%s\"", entry.name.c_str());
3612 s->EOL();
3613 }
3614}
3615
3617 if (!ParseHeader())
3618 return ArchSpec();
3619
3620 if (m_section_headers.empty()) {
3621 // Allow elf notes to be parsed which may affect the detected architecture.
3623 }
3624
3625 if (CalculateType() == eTypeCoreFile &&
3627 // Core files don't have section headers yet they have PT_NOTE program
3628 // headers that might shed more light on the architecture
3629 for (const elf::ELFProgramHeader &H : ProgramHeaders()) {
3630 if (H.p_type != PT_NOTE || H.p_offset == 0 || H.p_filesz == 0)
3631 continue;
3632 DataExtractor data;
3633 if (data.SetData(m_data, H.p_offset, H.p_filesz) == H.p_filesz) {
3634 UUID uuid;
3636 }
3637 }
3638 }
3639 return m_arch_spec;
3640}
3641
3643 switch (m_header.e_type) {
3644 case llvm::ELF::ET_NONE:
3645 // 0 - No file type
3646 return eTypeUnknown;
3647
3648 case llvm::ELF::ET_REL:
3649 // 1 - Relocatable file
3650 return eTypeObjectFile;
3651
3652 case llvm::ELF::ET_EXEC:
3653 // 2 - Executable file
3654 return eTypeExecutable;
3655
3656 case llvm::ELF::ET_DYN:
3657 // 3 - Shared object file
3658 return eTypeSharedLibrary;
3659
3660 case ET_CORE:
3661 // 4 - Core file
3662 return eTypeCoreFile;
3663
3664 default:
3665 break;
3666 }
3667 return eTypeUnknown;
3668}
3669
3671 switch (m_header.e_type) {
3672 case llvm::ELF::ET_NONE:
3673 // 0 - No file type
3674 return eStrataUnknown;
3675
3676 case llvm::ELF::ET_REL:
3677 // 1 - Relocatable file
3678 return eStrataUnknown;
3679
3680 case llvm::ELF::ET_EXEC:
3681 // 2 - Executable file
3682 {
3683 SectionList *section_list = GetSectionList();
3684 if (section_list) {
3685 static ConstString loader_section_name(".interp");
3686 SectionSP loader_section =
3687 section_list->FindSectionByName(loader_section_name);
3688 if (loader_section) {
3689 char buffer[256];
3690 size_t read_size =
3691 ReadSectionData(loader_section.get(), 0, buffer, sizeof(buffer));
3692
3693 // We compare the content of .interp section
3694 // It will contains \0 when counting read_size, so the size needs to
3695 // decrease by one
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)
3699 return eStrataKernel;
3700 }
3701 }
3702 return eStrataUser;
3703 }
3704
3705 case llvm::ELF::ET_DYN:
3706 // 3 - Shared object file
3707 // TODO: is there any way to detect that an shared library is a kernel
3708 // related executable by inspecting the program headers, section headers,
3709 // symbols, or any other flag bits???
3710 return eStrataUnknown;
3711
3712 case ET_CORE:
3713 // 4 - Core file
3714 // TODO: is there any way to detect that an core file is a kernel
3715 // related executable by inspecting the program headers, section headers,
3716 // symbols, or any other flag bits???
3717 return eStrataUnknown;
3718
3719 default:
3720 break;
3721 }
3722 return eStrataUnknown;
3723}
3724
3726 lldb::offset_t section_offset, void *dst,
3727 size_t dst_len) {
3728 // If some other objectfile owns this data, pass this to them.
3729 if (section->GetObjectFile() != this)
3730 return section->GetObjectFile()->ReadSectionData(section, section_offset,
3731 dst, dst_len);
3732
3733 if (!section->Test(SHF_COMPRESSED))
3734 return ObjectFile::ReadSectionData(section, section_offset, dst, dst_len);
3735
3736 // For compressed sections we need to read to full data to be able to
3737 // decompress.
3738 DataExtractor data;
3739 ReadSectionData(section, data);
3740 return data.CopyData(section_offset, dst_len, dst);
3741}
3742
3744 DataExtractor &section_data) {
3745 // If some other objectfile owns this data, pass this to them.
3746 if (section->GetObjectFile() != this)
3747 return section->GetObjectFile()->ReadSectionData(section, section_data);
3748
3749 size_t result = ObjectFile::ReadSectionData(section, section_data);
3750 if (result == 0 || !(section->Get() & llvm::ELF::SHF_COMPRESSED))
3751 return result;
3752
3753 auto Decompressor = llvm::object::Decompressor::create(
3754 section->GetName().GetStringRef(),
3755 {reinterpret_cast<const char *>(section_data.GetDataStart()),
3756 size_t(section_data.GetByteSize())},
3758 if (!Decompressor) {
3759 GetModule()->ReportWarning(
3760 "Unable to initialize decompressor for section '{0}': {1}",
3761 section->GetName().GetCString(),
3762 llvm::toString(Decompressor.takeError()).c_str());
3763 section_data.Clear();
3764 return 0;
3765 }
3766
3767 auto buffer_sp =
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}",
3772 section->GetName().GetCString(),
3773 llvm::toString(std::move(error)).c_str());
3774 section_data.Clear();
3775 return 0;
3776 }
3777
3778 section_data.SetData(buffer_sp);
3779 return buffer_sp->GetByteSize();
3780}
3781
3782llvm::ArrayRef<ELFProgramHeader> ObjectFileELF::ProgramHeaders() {
3784 return m_program_headers;
3785}
3786
3788 // Try and read the program header from our cached m_data which can come from
3789 // the file on disk being mmap'ed or from the initial part of the ELF file we
3790 // read from memory and cached.
3792 if (data.GetByteSize() == H.p_filesz)
3793 return data;
3794 if (IsInMemory()) {
3795 // We have a ELF file in process memory, read the program header data from
3796 // the process.
3797 if (ProcessSP process_sp = m_process_wp.lock()) {
3798 const lldb::offset_t base_file_addr = GetBaseAddress().GetFileAddress();
3799 const addr_t load_bias = m_memory_addr - base_file_addr;
3800 const addr_t data_addr = H.p_vaddr + load_bias;
3801 if (DataBufferSP data_sp = ReadMemory(process_sp, data_addr, H.p_memsz))
3802 return DataExtractor(data_sp, GetByteOrder(), GetAddressByteSize());
3803 }
3804 }
3805 return DataExtractor();
3806}
3807
3809 for (const ELFProgramHeader &H : ProgramHeaders()) {
3810 if (H.p_paddr != 0)
3811 return true;
3812 }
3813 return false;
3814}
3815
3816std::vector<ObjectFile::LoadableData>
3818 // Create a list of loadable data from loadable segments, using physical
3819 // addresses if they aren't all null
3820 std::vector<LoadableData> loadables;
3821 bool should_use_paddr = AnySegmentHasPhysicalAddress();
3822 for (const ELFProgramHeader &H : ProgramHeaders()) {
3823 LoadableData loadable;
3824 if (H.p_type != llvm::ELF::PT_LOAD)
3825 continue;
3826 loadable.Dest = should_use_paddr ? H.p_paddr : H.p_vaddr;
3827 if (loadable.Dest == LLDB_INVALID_ADDRESS)
3828 continue;
3829 if (H.p_filesz == 0)
3830 continue;
3831 auto segment_data = GetSegmentData(H);
3832 loadable.Contents = llvm::ArrayRef<uint8_t>(segment_data.GetDataStart(),
3833 segment_data.GetByteSize());
3834 loadables.push_back(loadable);
3835 }
3836 return loadables;
3837}
3838
3841 uint64_t Offset) {
3843 Offset);
3844}
3845
3846std::optional<DataExtractor>
3848 uint64_t offset) {
3849 // ELFDynamic values contain a "d_ptr" member that will be a load address if
3850 // we have an ELF file read from memory, or it will be a file address if it
3851 // was read from a ELF file. This function will correctly fetch data pointed
3852 // to by the ELFDynamic::d_ptr, or return std::nullopt if the data isn't
3853 // available.
3854 const lldb::addr_t d_ptr_addr = dyn->d_ptr + offset;
3855 if (ProcessSP process_sp = m_process_wp.lock()) {
3856 if (DataBufferSP data_sp = ReadMemory(process_sp, d_ptr_addr, length))
3857 return DataExtractor(data_sp, GetByteOrder(), GetAddressByteSize());
3858 } else {
3859 // We have an ELF file with no section headers or we didn't find the
3860 // .dynamic section. Try and find the .dynstr section.
3861 Address addr;
3862 if (!addr.ResolveAddressUsingFileSections(d_ptr_addr, GetSectionList()))
3863 return std::nullopt;
3864 DataExtractor data;
3865 addr.GetSection()->GetSectionData(data);
3866 return DataExtractor(data, d_ptr_addr - addr.GetSection()->GetFileAddress(),
3867 length);
3868 }
3869 return std::nullopt;
3870}
3871
3872std::optional<DataExtractor> ObjectFileELF::GetDynstrData() {
3873 if (SectionList *section_list = GetSectionList()) {
3874 // Find the SHT_DYNAMIC section.
3875 if (Section *dynamic =
3876 section_list
3877 ->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
3878 .get()) {
3879 assert(dynamic->GetObjectFile() == this);
3880 if (const ELFSectionHeaderInfo *header =
3881 GetSectionHeaderByIndex(dynamic->GetID())) {
3882 // sh_link: section header index of string table used by entries in
3883 // the section.
3884 if (Section *dynstr =
3885 section_list->FindSectionByID(header->sh_link).get()) {
3886 DataExtractor data;
3887 if (ReadSectionData(dynstr, data))
3888 return data;
3889 }
3890 }
3891 }
3892 }
3893
3894 // Every ELF file which represents an executable or shared library has
3895 // mandatory .dynamic entries. Two of these values are DT_STRTAB and DT_STRSZ
3896 // and represent the dynamic symbol tables's string table. These are needed
3897 // by the dynamic loader and we can read them from a process' address space.
3898 //
3899 // When loading and ELF file from memory, only the program headers are
3900 // guaranteed end up being mapped into memory, and we can find these values in
3901 // the PT_DYNAMIC segment.
3902 const ELFDynamic *strtab = FindDynamicSymbol(DT_STRTAB);
3903 const ELFDynamic *strsz = FindDynamicSymbol(DT_STRSZ);
3904 if (strtab == nullptr || strsz == nullptr)
3905 return std::nullopt;
3906
3907 return ReadDataFromDynamic(strtab, strsz->d_val, /*offset=*/0);
3908}
3909
3910std::optional<lldb_private::DataExtractor> ObjectFileELF::GetDynamicData() {
3911 DataExtractor data;
3912 // The PT_DYNAMIC program header describes where the .dynamic section is and
3913 // doesn't require parsing section headers. The PT_DYNAMIC is required by
3914 // executables and shared libraries so it will always be available.
3915 for (const ELFProgramHeader &H : ProgramHeaders()) {
3916 if (H.p_type == llvm::ELF::PT_DYNAMIC) {
3917 data = GetSegmentData(H);
3918 if (data.GetByteSize() > 0) {
3919 m_dynamic_base_addr = H.p_vaddr;
3920 return data;
3921 }
3922 }
3923 }
3924 // Fall back to using section headers.
3925 if (SectionList *section_list = GetSectionList()) {
3926 // Find the SHT_DYNAMIC section.
3927 if (Section *dynamic =
3928 section_list
3929 ->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
3930 .get()) {
3931 assert(dynamic->GetObjectFile() == this);
3932 if (ReadSectionData(dynamic, data)) {
3933 m_dynamic_base_addr = dynamic->GetFileAddress();
3934 return data;
3935 }
3936 }
3937 }
3938 return std::nullopt;
3939}
3940
3942 const ELFDynamic *hash = FindDynamicSymbol(DT_HASH);
3943 if (hash == nullptr)
3944 return std::nullopt;
3945
3946 // The DT_HASH header looks like this:
3947 struct DtHashHeader {
3948 uint32_t nbucket;
3949 uint32_t nchain;
3950 };
3951 if (auto data = ReadDataFromDynamic(hash, 8)) {
3952 // We don't need the number of buckets value "nbucket", we just need the
3953 // "nchain" value which contains the number of symbols.
3954 offset_t offset = offsetof(DtHashHeader, nchain);
3955 return data->GetU32(&offset);
3956 }
3957
3958 return std::nullopt;
3959}
3960
3962 const ELFDynamic *gnu_hash = FindDynamicSymbol(DT_GNU_HASH);
3963 if (gnu_hash == nullptr)
3964 return std::nullopt;
3965
3966 // Create a DT_GNU_HASH header
3967 // https://flapenguin.me/elf-dt-gnu-hash
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;
3973 };
3974 uint32_t num_symbols = 0;
3975 // Read enogh data for the DT_GNU_HASH header so we can extract the values.
3976 if (auto data = ReadDataFromDynamic(gnu_hash, sizeof(DtGnuHashHeader))) {
3977 offset_t offset = 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);
3983 const size_t addr_size = GetAddressByteSize();
3984 const addr_t buckets_offset =
3985 sizeof(DtGnuHashHeader) + addr_size * header.bloom_size;
3986 std::vector<uint32_t> buckets;
3987 if (auto bucket_data = ReadDataFromDynamic(gnu_hash, header.nbuckets * 4,
3988 buckets_offset)) {
3989 offset = 0;
3990 for (uint32_t i = 0; i < header.nbuckets; ++i)
3991 buckets.push_back(bucket_data->GetU32(&offset));
3992 // Locate the chain that handles the largest index bucket.
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;
3998 } else {
3999 // Walk the bucket's chain to add the chain length to the total.
4000 const addr_t chains_base_offset = buckets_offset + header.nbuckets * 4;
4001 for (;;) {
4002 if (auto chain_entry_data = ReadDataFromDynamic(
4003 gnu_hash, 4,
4004 chains_base_offset + (last_symbol - header.symoffset) * 4)) {
4005 offset = 0;
4006 uint32_t chain_entry = chain_entry_data->GetU32(&offset);
4007 ++last_symbol;
4008 // If the low bit is set, this entry is the end of the chain.
4009 if (chain_entry & 1)
4010 break;
4011 } else {
4012 break;
4013 }
4014 }
4015 num_symbols = last_symbol;
4016 }
4017 }
4018 }
4019 if (num_symbols > 0)
4020 return num_symbols;
4021
4022 return std::nullopt;
4023}
4024
4025std::optional<DataExtractor>
4027 // Every ELF file which represents an executable or shared library has
4028 // mandatory .dynamic entries. The DT_SYMTAB value contains a pointer to the
4029 // symbol table, and DT_SYMENT contains the size of a symbol table entry.
4030 // We then can use either the DT_HASH or DT_GNU_HASH to find the number of
4031 // symbols in the symbol table as the symbol count is not stored in the
4032 // .dynamic section as a key/value pair.
4033 //
4034 // When loading and ELF file from memory, only the program headers end up
4035 // being mapped into memory, and we can find these values in the PT_DYNAMIC
4036 // segment.
4037 num_symbols = 0;
4038 // Get the process in case this is an in memory ELF file.
4039 ProcessSP process_sp(m_process_wp.lock());
4040 const ELFDynamic *symtab = FindDynamicSymbol(DT_SYMTAB);
4041 const ELFDynamic *syment = FindDynamicSymbol(DT_SYMENT);
4042 // DT_SYMTAB and DT_SYMENT are mandatory.
4043 if (symtab == nullptr || syment == nullptr)
4044 return std::nullopt;
4045
4046 if (std::optional<uint32_t> syms = GetNumSymbolsFromDynamicHash())
4047 num_symbols = *syms;
4048 else if (std::optional<uint32_t> syms = GetNumSymbolsFromDynamicGnuHash())
4049 num_symbols = *syms;
4050 else
4051 return std::nullopt;
4052 if (num_symbols == 0)
4053 return std::nullopt;
4054 return ReadDataFromDynamic(symtab, syment->d_val * num_symbols);
4055}
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.
Definition: Log.h:369
#define LLDB_LOGF(log,...)
Definition: Log.h:376
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 &section_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)
Definition: PluginManager.h:32
static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end)
Definition: Statistics.cpp:39
#define LLDB_SCOPED_TIMERF(...)
Definition: Timer.h:86
Generic COFF object file reader.
Definition: ObjectFileELF.h:58
static size_t GetSectionHeaderInfo(SectionHeaderColl &section_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 Initialize()
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()
Definition: ObjectFileELF.h:67
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()
Definition: ObjectFileELF.h:65
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.
static void Terminate()
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...
static char ID
Definition: ObjectFileELF.h:94
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.
Definition: AddressRange.h:25
A section + offset based address class.
Definition: Address.h:62
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:312
bool ResolveAddressUsingFileSections(lldb::addr_t addr, const SectionList *sections)
Resolve a file virtual address using a section list.
Definition: Address.cpp:249
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:439
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:292
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:355
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:448
An architecture specification class.
Definition: ArchSpec.h:31
uint32_t GetCodeByteSize() const
Architecture code byte width accessor.
Definition: ArchSpec.cpp:700
bool IsValid() const
Tests if this ArchSpec is valid.
Definition: ArchSpec.h:361
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:463
void SetFlags(uint32_t flags)
Definition: ArchSpec.h:536
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.
Definition: ArchSpec.cpp:872
@ eLoongArch_abi_single_float
soft float
Definition: ArchSpec.h:112
@ eLoongArch_abi_double_float
single precision floating point, +f
Definition: ArchSpec.h:114
bool IsMIPS() const
if MIPS architecture return true.
Definition: ArchSpec.cpp:580
uint32_t GetDataByteSize() const
Architecture data byte width accessor.
Definition: ArchSpec.cpp:696
uint32_t GetFlags() const
Definition: ArchSpec.h:534
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
Definition: ArchSpec.cpp:704
@ eRISCV_float_abi_double
single precision floating point, +f
Definition: ArchSpec.h:97
@ eRISCV_float_abi_quad
double precision floating point, +d
Definition: ArchSpec.h:98
@ eRISCV_float_abi_single
soft float
Definition: ArchSpec.h:96
bool TripleOSWasSpecified() const
Definition: ArchSpec.h:370
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
Definition: ArchSpec.cpp:573
A uniqued constant string class.
Definition: ConstString.h:40
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:188
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:197
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
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.
An data extractor class.
Definition: DataExtractor.h:48
uint64_t GetULEB128(lldb::offset_t *offset_ptr) const
Extract a unsigned LEB128 value from *offset_ptr.
const char * GetCStr(lldb::offset_t *offset_ptr) const
Extract a C string from *offset_ptr.
const uint8_t * PeekData(lldb::offset_t offset, lldb::offset_t length) const
Peek at a bytes at offset.
const void * GetData(lldb::offset_t *offset_ptr, lldb::offset_t length) const
Extract length bytes from *offset_ptr.
void Clear()
Clears the object state.
lldb::offset_t CopyData(lldb::offset_t offset, lldb::offset_t length, void *dst) const
Copy length bytes from *offset, without swapping bytes.
lldb::DataBufferSP & GetSharedDataBuffer()
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
uint64_t GetByteSize() const
Get the number of bytes contained in this object.
uint64_t GetAddress(lldb::offset_t *offset_ptr) const
Extract an address from *offset_ptr.
const uint8_t * GetDataStart() const
Get the data start pointer.
lldb::offset_t SetData(const void *bytes, lldb::offset_t length, lldb::ByteOrder byte_order)
Set data with a buffer that is caller owned.
uint32_t GetAddressByteSize() const
Get the current address size.
lldb::ByteOrder GetByteOrder() const
Get the current byte order value.
uint8_t GetU8(lldb::offset_t *offset_ptr) const
Extract a uint8_t value from *offset_ptr.
const char * PeekCStr(lldb::offset_t offset) const
Peek at a C string at offset.
size_t ExtractBytes(lldb::offset_t offset, lldb::offset_t length, lldb::ByteOrder dst_byte_order, void *dst) const
Extract an arbitrary number of bytes in the specified byte order.
A class that measures elapsed time in an exception safe way.
Definition: Statistics.h:76
A file collection class.
Definition: FileSpecList.h:91
bool AppendIfUnique(const FileSpec &file)
Append a FileSpec object if unique.
A file utility class.
Definition: FileSpec.h:56
FileSpec CopyByAppendingPathComponent(llvm::StringRef component) const
Definition: FileSpec.cpp:418
const ConstString & GetFilename() const
Filename string const get accessor.
Definition: FileSpec.h:240
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
llvm::StringRef GetFileNameExtension() const
Extract the extension of the file.
Definition: FileSpec.cpp:403
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.
Definition: Flags.h:40
bool Test(ValueType bit) const
Test a single flag bit.
Definition: Flags.h:96
A class that handles mangled names.
Definition: Mangled.h:33
void SetDemangledName(ConstString name)
Definition: Mangled.h:137
ConstString GetDemangledName() const
Demangled name get accessor.
Definition: Mangled.cpp:272
void SetMangledName(ConstString name)
Definition: Mangled.h:139
ConstString & GetMangledName()
Mangled name get accessor.
Definition: Mangled.h:145
ConstString GetName(NamePreference preference=ePreferDemangled) const
Best name get accessor.
Definition: Mangled.cpp:337
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
void Append(const ModuleSpec &spec)
Definition: ModuleSpec.h:308
void SetObjectSize(uint64_t object_size)
Definition: ModuleSpec.h:115
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:89
void SetObjectOffset(uint64_t object_offset)
Definition: ModuleSpec.h:109
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:44
DataExtractor m_data
The data for this object file so things can be parsed lazily.
Definition: ObjectFile.h:758
Symtab * GetSymtab()
Gets the symbol table for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:738
std::unique_ptr< lldb_private::SectionList > m_sections_up
Definition: ObjectFile.h:762
static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size, uint64_t Offset)
Definition: ObjectFile.cpp:672
const lldb::addr_t m_memory_addr
Set if the object file only exists in memory.
Definition: ObjectFile.h:761
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.
Definition: ObjectFile.cpp:304
static lldb::WritableDataBufferSP ReadMemory(const lldb::ProcessSP &process_sp, lldb::addr_t addr, size_t byte_size)
Definition: ObjectFile.cpp:459
size_t GetData(lldb::offset_t offset, size_t length, DataExtractor &data) const
Definition: ObjectFile.cpp:474
@ eTypeExecutable
A normal executable.
Definition: ObjectFile.h:53
@ eTypeDebugInfo
An object file that contains only debug information.
Definition: ObjectFile.h:55
@ eTypeObjectFile
An intermediate object file.
Definition: ObjectFile.h:59
@ eTypeCoreFile
A core file that has a checkpoint of a program's execution state.
Definition: ObjectFile.h:51
@ eTypeSharedLibrary
A shared library that can be used during execution.
Definition: ObjectFile.h:61
virtual FileSpec & GetFileSpec()
Get accessor to the object file specification.
Definition: ObjectFile.h:275
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:602
bool IsInMemory() const
Returns true if the object file exists only in memory.
Definition: ObjectFile.h:691
lldb::ProcessWP m_process_wp
Definition: ObjectFile.h:759
virtual size_t ReadSectionData(Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len)
Definition: ObjectFile.cpp:488
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool UnregisterPlugin(ABICreateInstance create_callback)
A Progress indicator helper class.
Definition: Progress.h:60
lldb::SectionSP FindSectionByName(ConstString section_dstr) const
Definition: Section.cpp:558
lldb::SectionSP FindSectionByID(lldb::user_id_t sect_id) const
Definition: Section.cpp:580
lldb::SectionSP FindSectionContainingFileAddress(lldb::addr_t addr, uint32_t depth=UINT32_MAX) const
Definition: Section.cpp:617
size_t GetSize() const
Definition: Section.h:75
size_t AddSection(const lldb::SectionSP &section_sp)
Definition: Section.cpp:481
bool ReplaceSection(lldb::user_id_t sect_id, const lldb::SectionSP &section_sp, uint32_t depth=UINT32_MAX)
Definition: Section.cpp:521
lldb::SectionSP FindSectionByType(lldb::SectionType sect_type, bool check_children, size_t start_idx=0) const
Definition: Section.cpp:598
void Dump(llvm::raw_ostream &s, unsigned indent, Target *target, bool show_header, uint32_t depth) const
Definition: Section.cpp:644
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:550
ConstString GetName() const
Definition: Section.h:184
void SetIsRelocated(bool b)
Definition: Section.h:251
lldb::offset_t GetFileOffset() const
Definition: Section.h:154
ObjectFile * GetObjectFile()
Definition: Section.h:204
lldb::offset_t GetFileSize() const
Definition: Section.h:160
An error handling class.
Definition: Status.h:118
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Definition: Status.cpp:106
static Status FromErrorString(const char *str)
Definition: Status.h:141
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
void Format(const char *format, Args &&... args)
Definition: Stream.h:353
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:401
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:157
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:65
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:155
unsigned GetIndentLevel() const
Get the current indentation level.
Definition: Stream.cpp:187
uint32_t GetID() const
Definition: Symbol.h:136
bool GetByteSizeIsValid() const
Definition: Symbol.h:208
Address & GetAddressRef()
Definition: Symbol.h:72
void SetIsWeak(bool b)
Definition: Symbol.h:206
ConstString GetName() const
Definition: Symbol.cpp:548
Symbol * FindSymbolByID(lldb::user_id_t uid) const
Definition: Symtab.cpp:219
Symbol * SymbolAtIndex(size_t idx)
Definition: Symtab.cpp:228
Symbol * FindSymbolAtFileAddress(lldb::addr_t file_addr)
Definition: Symtab.cpp:1029
Symbol * FindSymbolContainingFileAddress(lldb::addr_t file_addr)
Definition: Symtab.cpp:1044
uint32_t AddSymbol(const Symbol &symbol)
Definition: Symtab.cpp:64
void Dump(Stream *s, Target *target, SortOrder sort_type, Mangled::NamePreference name_preference=Mangled::ePreferDemangled)
Definition: Symtab.cpp:87
ObjectFile * GetObjectFile() const
Definition: Symtab.h:137
size_t GetNumSymbols() const
Definition: Symtab.cpp:77
bool ReadPointerFromMemory(const Address &addr, Status &error, Address &pointer_addr, bool force_live_memory=false)
Definition: Target.cpp:2262
uint64_t ReadUnsignedIntegerFromMemory(const Address &addr, size_t integer_byte_size, uint64_t fail_value, Status &error, bool force_live_memory=false)
Definition: Target.cpp:2251
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: Target.cpp:3236
bool IsValid() const
Definition: UUID.h:69
uint8_t * GetBytes()
Get a pointer to the data.
Definition: DataBuffer.h:108
uint64_t dw_offset_t
Definition: dwarf.h:30
#define INT32_MAX
Definition: lldb-defines.h:15
#define UINT64_MAX
Definition: lldb-defines.h:23
#define LLDB_INVALID_CPUTYPE
Definition: lldb-defines.h:104
#define UNUSED_IF_ASSERT_DISABLED(x)
Definition: lldb-defines.h:140
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define UINT32_MAX
Definition: lldb-defines.h:19
Definition: ELFHeader.h:32
uint64_t elf_addr
Definition: ELFHeader.h:41
uint64_t elf_off
Definition: ELFHeader.h:42
uint32_t elf_word
Definition: ELFHeader.h:44
uint64_t elf_xword
Definition: ELFHeader.h:47
uint16_t elf_half
Definition: ELFHeader.h:43
int64_t elf_sxword
Definition: ELFHeader.h:48
bool isAvailable()
Definition: LZMA.cpp:22
llvm::Error uncompress(llvm::ArrayRef< uint8_t > InputBuffer, llvm::SmallVectorImpl< uint8_t > &Uncompressed)
Definition: LZMA.cpp:28
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.
Definition: Log.h:332
Definition: SBAddress.h:15
uint64_t offset_t
Definition: lldb-types.h:85
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:390
SymbolType
Symbol types.
@ eSymbolTypeUndefined
@ eSymbolTypeTrampoline
@ eSymbolTypeResolver
@ eSymbolTypeSourceFile
@ eSymbolTypeInvalid
@ eSymbolTypeAbsolute
ByteOrder
Byte ordering definitions.
@ eByteOrderInvalid
@ eByteOrderLittle
uint64_t user_id_t
Definition: lldb-types.h:82
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
Definition: lldb-forward.h:337
std::shared_ptr< lldb_private::Section > SectionSP
Definition: lldb-forward.h:419
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
Definition: lldb-forward.h:338
uint64_t addr_t
Definition: lldb-types.h:80
@ eSectionTypeDWARFDebugStrOffsets
@ eSectionTypeELFDynamicSymbols
Elf SHT_DYNSYM section.
@ eSectionTypeData
@ eSectionTypeDWARFDebugPubNames
@ eSectionTypeZeroFill
@ eSectionTypeDWARFDebugLocDwo
@ eSectionTypeDWARFDebugFrame
@ eSectionTypeARMextab
@ 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.
@ eSectionTypeOther
@ eSectionTypeLLDBFormatters
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
@ eSectionTypeDWARFDebugRngLists
DWARF v5 .debug_rnglists.
@ eSectionTypeEHFrame
@ eSectionTypeDWARFDebugStrOffsetsDwo
@ eSectionTypeDWARFDebugMacro
@ eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugTypesDwo
@ eSectionTypeDWARFDebugRanges
@ eSectionTypeDWARFDebugRngListsDwo
@ eSectionTypeLLDBTypeSummaries
@ eSectionTypeGoSymtab
@ eSectionTypeARMexidx
@ eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugPubTypes
@ eSectionTypeDWARFDebugTuIndex
@ eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFDebugLineStr
DWARF v5 .debug_line_str.
@ eSectionTypeDWARFDebugLoc
@ eSectionTypeCode
@ eSectionTypeSwiftModules
@ eSectionTypeDebug
@ eSectionTypeDWARFDebugCuIndex
@ eSectionTypeDWARFDebugAranges
@ eSectionTypeDWARFDebugAbbrevDwo
@ eSectionTypeDWARFGNUDebugAltLink
@ eSectionTypeDWARFDebugStrDwo
@ eSectionTypeDWARFDebugAbbrev
@ eSectionTypeDWARFDebugLocListsDwo
@ eSectionTypeDWARFDebugInfoDwo
@ eSectionTypeDWARFDebugAddr
@ eSectionTypeELFSymbolTable
Elf SHT_SYMTAB section.
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:374
bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
Parse an ELFNote entry from the given DataExtractor starting at position offset.
std::string n_name
Definition: ObjectFileELF.h:30
elf::elf_word n_namesz
Definition: ObjectFileELF.h:26
lldb_private::ConstString section_name
Represents an entry in an ELF dynamic table.
Definition: ELFHeader.h:276
elf_addr d_ptr
Pointer value of the table entry.
Definition: ELFHeader.h:280
elf_xword d_val
Integer value of the table entry.
Definition: ELFHeader.h:279
bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
Parse an ELFDynamic entry from the given DataExtractor starting at position offset.
Definition: ELFHeader.cpp:406
elf_sxword d_tag
Type of dynamic table entry.
Definition: ELFHeader.h:277
Generic representation of an ELF file header.
Definition: ELFHeader.h:56
elf_word e_shnum
Number of section header entries.
Definition: ELFHeader.h:76
bool HasHeaderExtension() const
Check if there should be header extension in section header #0.
Definition: ELFHeader.cpp:81
elf_off e_phoff
File offset of program header table.
Definition: ELFHeader.h:59
bool Is64Bit() const
Returns true if this is a 64 bit ELF file header.
Definition: ELFHeader.h:93
static unsigned AddressSizeInBytes(const uint8_t *magic)
Examines at most EI_NIDENT bytes starting from the given address and determines the address size of t...
Definition: ELFHeader.cpp:161
elf_half e_phentsize
Size of a program header table entry.
Definition: ELFHeader.h:66
bool Is32Bit() const
Returns true if this is a 32 bit ELF file header.
Definition: ELFHeader.h:85
static bool MagicBytesMatch(const uint8_t *magic)
Examines at most EI_NIDENT bytes starting from the given pointer and determines if the magic ELF iden...
Definition: ELFHeader.cpp:157
elf_off e_shoff
File offset of section header table.
Definition: ELFHeader.h:60
elf_half e_ehsize
Byte size of the ELF header.
Definition: ELFHeader.h:65
bool Parse(lldb_private::DataExtractor &data, lldb::offset_t *offset)
Parse an ELFHeader entry starting at position offset and update the data extractor with the address s...
Definition: ELFHeader.cpp:114
unsigned GetRelocationJumpSlotType() const
The jump slot relocation type of this ELF.
Definition: ELFHeader.cpp:176
elf_word e_phnum
Number of program header entries.
Definition: ELFHeader.h:75
elf_word e_version
Version of object file (always 1).
Definition: ELFHeader.h:62
unsigned char e_ident[llvm::ELF::EI_NIDENT]
ELF file identification.
Definition: ELFHeader.h:57
elf_half e_machine
Target architecture.
Definition: ELFHeader.h:64
elf_addr e_entry
Virtual address program entry point.
Definition: ELFHeader.h:58
elf_word e_shstrndx
String table section index.
Definition: ELFHeader.h:77
elf_half e_shentsize
Size of a section header table entry.
Definition: ELFHeader.h:68
elf_half e_type
Object file type.
Definition: ELFHeader.h:63
elf_word e_flags
Processor specific flags.
Definition: ELFHeader.h:61
Generic representation of an ELF program header.
Definition: ELFHeader.h:192
elf_xword p_align
Segment alignment constraint.
Definition: ELFHeader.h:200
elf_addr p_paddr
Physical address (for non-VM systems).
Definition: ELFHeader.h:197
elf_word p_flags
Segment attributes.
Definition: ELFHeader.h:194
elf_xword p_filesz
Byte size of the segment in file.
Definition: ELFHeader.h:198
elf_off p_offset
Start of segment from beginning of file.
Definition: ELFHeader.h:195
elf_addr p_vaddr
Virtual address of segment in memory.
Definition: ELFHeader.h:196
elf_xword p_memsz
Byte size of the segment in memory.
Definition: ELFHeader.h:199
elf_word p_type
Type of program segment.
Definition: ELFHeader.h:193
Represents a relocation entry with an implicit addend.
Definition: ELFHeader.h:305
static unsigned RelocSymbol64(const ELFRel &rel)
Returns the symbol index when the given entry represents a 64-bit relocation.
Definition: ELFHeader.h:341
static unsigned RelocType64(const ELFRel &rel)
Returns the type when the given entry represents a 64-bit relocation.
Definition: ELFHeader.h:331
static unsigned RelocType32(const ELFRel &rel)
Returns the type when the given entry represents a 32-bit relocation.
Definition: ELFHeader.h:328
static unsigned RelocSymbol32(const ELFRel &rel)
Returns the symbol index when the given entry represents a 32-bit relocation.
Definition: ELFHeader.h:337
Represents a relocation entry with an explicit addend.
Definition: ELFHeader.h:346
static unsigned RelocSymbol64(const ELFRela &rela)
Returns the symbol index when the given entry represents a 64-bit relocation.
Definition: ELFHeader.h:387
static unsigned RelocType64(const ELFRela &rela)
Returns the type when the given entry represents a 64-bit relocation.
Definition: ELFHeader.h:375
static unsigned RelocType32(const ELFRela &rela)
Returns the type when the given entry represents a 32-bit relocation.
Definition: ELFHeader.h:370
static unsigned RelocSymbol32(const ELFRela &rela)
Returns the symbol index when the given entry represents a 32-bit relocation.
Definition: ELFHeader.h:381
Generic representation of an ELF section header.
Definition: ELFHeader.h:159
elf_word sh_link
Index of associated section.
Definition: ELFHeader.h:166
elf_word sh_info
Extra section info (overloaded).
Definition: ELFHeader.h:167
elf_xword sh_size
Number of bytes occupied in the file.
Definition: ELFHeader.h:165
elf_xword sh_flags
Section attributes.
Definition: ELFHeader.h:162
elf_word sh_name
Section name string index.
Definition: ELFHeader.h:160
elf_off sh_offset
Start of section from beginning of file.
Definition: ELFHeader.h:164
elf_word sh_type
Section type.
Definition: ELFHeader.h:161
elf_xword sh_addralign
Power of two alignment constraint.
Definition: ELFHeader.h:168
elf_xword sh_entsize
Byte size of each section entry.
Definition: ELFHeader.h:169
elf_addr sh_addr
Virtual address of the section in memory.
Definition: ELFHeader.h:163
Represents a symbol within an ELF symbol table.
Definition: ELFHeader.h:224
unsigned char getType() const
Returns the type attribute of the st_info member.
Definition: ELFHeader.h:238
elf_half st_shndx
Section to which this symbol applies.
Definition: ELFHeader.h:230
unsigned char st_info
Symbol type and binding attributes.
Definition: ELFHeader.h:228
unsigned char getBinding() const
Returns the binding attribute of the st_info member.
Definition: ELFHeader.h:235
bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset)
Parse an ELFSymbol entry from the given DataExtractor starting at position offset.
Definition: ELFHeader.cpp:325
elf_addr st_value
Absolute or relocatable address.
Definition: ELFHeader.h:225
elf_word st_name
Symbol name string index.
Definition: ELFHeader.h:227
elf_xword st_size
Size of the symbol or zero.
Definition: ELFHeader.h:226
unsigned char st_other
Reserved for future use.
Definition: ELFHeader.h:229
llvm::ArrayRef< uint8_t > Contents
Definition: ObjectFile.h:91
BaseType GetRangeBase() const
Definition: RangeMap.h:45
SizeType GetByteSize() const
Definition: RangeMap.h:87
BaseType GetRangeEnd() const
Definition: RangeMap.h:78
void Slide(BaseType slide)
Definition: RangeMap.h:50
void SetByteSize(SizeType s)
Definition: RangeMap.h:89
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47