1 //===-- ObjectFileELF.cpp ------------------------------------- -*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "ObjectFileELF.h"
14 #include <unordered_map>
16 #include "lldb/Core/ArchSpec.h"
17 #include "lldb/Core/FileSpecList.h"
18 #include "lldb/Core/Module.h"
19 #include "lldb/Core/ModuleSpec.h"
20 #include "lldb/Core/PluginManager.h"
21 #include "lldb/Core/Section.h"
22 #include "lldb/Core/Timer.h"
23 #include "lldb/Symbol/DWARFCallFrameInfo.h"
24 #include "lldb/Symbol/SymbolContext.h"
25 #include "lldb/Target/SectionLoadList.h"
26 #include "lldb/Target/Target.h"
27 #include "lldb/Utility/DataBufferLLVM.h"
28 #include "lldb/Utility/Log.h"
29 #include "lldb/Utility/Status.h"
30 #include "lldb/Utility/Stream.h"
32 #include "llvm/ADT/PointerUnion.h"
33 #include "llvm/ADT/StringRef.h"
34 #include "llvm/Support/ARMBuildAttributes.h"
35 #include "llvm/Support/MathExtras.h"
36 #include "llvm/Support/MemoryBuffer.h"
37 #include "llvm/Support/MipsABIFlags.h"
39 #define CASE_AND_STREAM(s, def, width) \
41 s->Printf("%-*s", width, #def); \
45 using namespace lldb_private;
47 using namespace llvm::ELF;
51 // ELF note owner definitions
52 const char *const LLDB_NT_OWNER_FREEBSD = "FreeBSD";
53 const char *const LLDB_NT_OWNER_GNU = "GNU";
54 const char *const LLDB_NT_OWNER_NETBSD = "NetBSD";
55 const char *const LLDB_NT_OWNER_OPENBSD = "OpenBSD";
56 const char *const LLDB_NT_OWNER_CSR = "csr";
57 const char *const LLDB_NT_OWNER_ANDROID = "Android";
58 const char *const LLDB_NT_OWNER_CORE = "CORE";
59 const char *const LLDB_NT_OWNER_LINUX = "LINUX";
61 // ELF note type definitions
62 const elf_word LLDB_NT_FREEBSD_ABI_TAG = 0x01;
63 const elf_word LLDB_NT_FREEBSD_ABI_SIZE = 4;
65 const elf_word LLDB_NT_GNU_ABI_TAG = 0x01;
66 const elf_word LLDB_NT_GNU_ABI_SIZE = 16;
68 const elf_word LLDB_NT_GNU_BUILD_ID_TAG = 0x03;
70 const elf_word LLDB_NT_NETBSD_ABI_TAG = 0x01;
71 const elf_word LLDB_NT_NETBSD_ABI_SIZE = 4;
73 // GNU ABI note OS constants
74 const elf_word LLDB_NT_GNU_ABI_OS_LINUX = 0x00;
75 const elf_word LLDB_NT_GNU_ABI_OS_HURD = 0x01;
76 const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02;
78 // LLDB_NT_OWNER_CORE and LLDB_NT_OWNER_LINUX note contants
82 #define NT_TASKSTRUCT 4
84 #define NT_SIGINFO 0x53494749
85 #define NT_FILE 0x46494c45
86 #define NT_PRXFPREG 0x46e62b7f
87 #define NT_PPC_VMX 0x100
88 #define NT_PPC_SPE 0x101
89 #define NT_PPC_VSX 0x102
90 #define NT_386_TLS 0x200
91 #define NT_386_IOPERM 0x201
92 #define NT_X86_XSTATE 0x202
93 #define NT_S390_HIGH_GPRS 0x300
94 #define NT_S390_TIMER 0x301
95 #define NT_S390_TODCMP 0x302
96 #define NT_S390_TODPREG 0x303
97 #define NT_S390_CTRS 0x304
98 #define NT_S390_PREFIX 0x305
99 #define NT_S390_LAST_BREAK 0x306
100 #define NT_S390_SYSTEM_CALL 0x307
101 #define NT_S390_TDB 0x308
102 #define NT_S390_VXRS_LOW 0x309
103 #define NT_S390_VXRS_HIGH 0x30a
104 #define NT_ARM_VFP 0x400
105 #define NT_ARM_TLS 0x401
106 #define NT_ARM_HW_BREAK 0x402
107 #define NT_ARM_HW_WATCH 0x403
108 #define NT_ARM_SYSTEM_CALL 0x404
109 #define NT_METAG_CBUF 0x500
110 #define NT_METAG_RPIPE 0x501
111 #define NT_METAG_TLS 0x502
113 //===----------------------------------------------------------------------===//
114 /// @class ELFRelocation
115 /// @brief Generic wrapper for ELFRel and ELFRela.
117 /// This helper class allows us to parse both ELFRel and ELFRela relocation
118 /// entries in a generic manner.
119 class ELFRelocation {
121 /// Constructs an ELFRelocation entry with a personality as given by @p
124 /// @param type Either DT_REL or DT_RELA. Any other value is invalid.
125 ELFRelocation(unsigned type);
129 bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
131 static unsigned RelocType32(const ELFRelocation &rel);
133 static unsigned RelocType64(const ELFRelocation &rel);
135 static unsigned RelocSymbol32(const ELFRelocation &rel);
137 static unsigned RelocSymbol64(const ELFRelocation &rel);
139 static unsigned RelocOffset32(const ELFRelocation &rel);
141 static unsigned RelocOffset64(const ELFRelocation &rel);
143 static unsigned RelocAddend32(const ELFRelocation &rel);
145 static unsigned RelocAddend64(const ELFRelocation &rel);
148 typedef llvm::PointerUnion<ELFRel *, ELFRela *> RelocUnion;
153 ELFRelocation::ELFRelocation(unsigned type) {
154 if (type == DT_REL || type == SHT_REL)
155 reloc = new ELFRel();
156 else if (type == DT_RELA || type == SHT_RELA)
157 reloc = new ELFRela();
159 assert(false && "unexpected relocation type");
160 reloc = static_cast<ELFRel *>(NULL);
164 ELFRelocation::~ELFRelocation() {
165 if (reloc.is<ELFRel *>())
166 delete reloc.get<ELFRel *>();
168 delete reloc.get<ELFRela *>();
171 bool ELFRelocation::Parse(const lldb_private::DataExtractor &data,
172 lldb::offset_t *offset) {
173 if (reloc.is<ELFRel *>())
174 return reloc.get<ELFRel *>()->Parse(data, offset);
176 return reloc.get<ELFRela *>()->Parse(data, offset);
179 unsigned ELFRelocation::RelocType32(const ELFRelocation &rel) {
180 if (rel.reloc.is<ELFRel *>())
181 return ELFRel::RelocType32(*rel.reloc.get<ELFRel *>());
183 return ELFRela::RelocType32(*rel.reloc.get<ELFRela *>());
186 unsigned ELFRelocation::RelocType64(const ELFRelocation &rel) {
187 if (rel.reloc.is<ELFRel *>())
188 return ELFRel::RelocType64(*rel.reloc.get<ELFRel *>());
190 return ELFRela::RelocType64(*rel.reloc.get<ELFRela *>());
193 unsigned ELFRelocation::RelocSymbol32(const ELFRelocation &rel) {
194 if (rel.reloc.is<ELFRel *>())
195 return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel *>());
197 return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela *>());
200 unsigned ELFRelocation::RelocSymbol64(const ELFRelocation &rel) {
201 if (rel.reloc.is<ELFRel *>())
202 return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel *>());
204 return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela *>());
207 unsigned ELFRelocation::RelocOffset32(const ELFRelocation &rel) {
208 if (rel.reloc.is<ELFRel *>())
209 return rel.reloc.get<ELFRel *>()->r_offset;
211 return rel.reloc.get<ELFRela *>()->r_offset;
214 unsigned ELFRelocation::RelocOffset64(const ELFRelocation &rel) {
215 if (rel.reloc.is<ELFRel *>())
216 return rel.reloc.get<ELFRel *>()->r_offset;
218 return rel.reloc.get<ELFRela *>()->r_offset;
221 unsigned ELFRelocation::RelocAddend32(const ELFRelocation &rel) {
222 if (rel.reloc.is<ELFRel *>())
225 return rel.reloc.get<ELFRela *>()->r_addend;
228 unsigned ELFRelocation::RelocAddend64(const ELFRelocation &rel) {
229 if (rel.reloc.is<ELFRel *>())
232 return rel.reloc.get<ELFRela *>()->r_addend;
235 } // end anonymous namespace
237 bool ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset) {
239 if (data.GetU32(offset, &n_namesz, 3) == NULL)
242 // The name field is required to be nul-terminated, and n_namesz
243 // includes the terminating nul in observed implementations (contrary
244 // to the ELF-64 spec). A special case is needed for cores generated
245 // by some older Linux versions, which write a note named "CORE"
246 // without a nul terminator and n_namesz = 4.
249 if (data.ExtractBytes(*offset, 4, data.GetByteOrder(), buf) != 4)
251 if (strncmp(buf, "CORE", 4) == 0) {
258 const char *cstr = data.GetCStr(offset, llvm::alignTo(n_namesz, 4));
260 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS));
262 log->Printf("Failed to parse note name lacking nul terminator");
270 static uint32_t kalimbaVariantFromElfFlags(const elf::elf_word e_flags) {
271 const uint32_t dsp_rev = e_flags & 0xFF;
272 uint32_t kal_arch_variant = LLDB_INVALID_CPUTYPE;
274 // TODO(mg11) Support more variants
276 kal_arch_variant = llvm::Triple::KalimbaSubArch_v3;
279 kal_arch_variant = llvm::Triple::KalimbaSubArch_v4;
283 kal_arch_variant = llvm::Triple::KalimbaSubArch_v5;
288 return kal_arch_variant;
291 static uint32_t mipsVariantFromElfFlags (const elf::ELFHeader &header) {
292 const uint32_t mips_arch = header.e_flags & llvm::ELF::EF_MIPS_ARCH;
293 uint32_t endian = header.e_ident[EI_DATA];
294 uint32_t arch_variant = ArchSpec::eMIPSSubType_unknown;
295 uint32_t fileclass = header.e_ident[EI_CLASS];
297 // If there aren't any elf flags available (e.g core elf file) then return default
298 // 32 or 64 bit arch (without any architecture revision) based on object file's class.
299 if (header.e_type == ET_CORE) {
301 case llvm::ELF::ELFCLASS32:
302 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
303 : ArchSpec::eMIPSSubType_mips32;
304 case llvm::ELF::ELFCLASS64:
305 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
306 : ArchSpec::eMIPSSubType_mips64;
313 case llvm::ELF::EF_MIPS_ARCH_1:
314 case llvm::ELF::EF_MIPS_ARCH_2:
315 case llvm::ELF::EF_MIPS_ARCH_32:
316 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
317 : ArchSpec::eMIPSSubType_mips32;
318 case llvm::ELF::EF_MIPS_ARCH_32R2:
319 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r2el
320 : ArchSpec::eMIPSSubType_mips32r2;
321 case llvm::ELF::EF_MIPS_ARCH_32R6:
322 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r6el
323 : ArchSpec::eMIPSSubType_mips32r6;
324 case llvm::ELF::EF_MIPS_ARCH_3:
325 case llvm::ELF::EF_MIPS_ARCH_4:
326 case llvm::ELF::EF_MIPS_ARCH_5:
327 case llvm::ELF::EF_MIPS_ARCH_64:
328 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
329 : ArchSpec::eMIPSSubType_mips64;
330 case llvm::ELF::EF_MIPS_ARCH_64R2:
331 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r2el
332 : ArchSpec::eMIPSSubType_mips64r2;
333 case llvm::ELF::EF_MIPS_ARCH_64R6:
334 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r6el
335 : ArchSpec::eMIPSSubType_mips64r6;
343 static uint32_t subTypeFromElfHeader(const elf::ELFHeader &header) {
344 if (header.e_machine == llvm::ELF::EM_MIPS)
345 return mipsVariantFromElfFlags(header);
347 return llvm::ELF::EM_CSR_KALIMBA == header.e_machine
348 ? kalimbaVariantFromElfFlags(header.e_flags)
349 : LLDB_INVALID_CPUTYPE;
352 //! The kalimba toolchain identifies a code section as being
353 //! one with the SHT_PROGBITS set in the section sh_type and the top
354 //! bit in the 32-bit address field set.
355 static lldb::SectionType
356 kalimbaSectionType(const elf::ELFHeader &header,
357 const elf::ELFSectionHeader §_hdr) {
358 if (llvm::ELF::EM_CSR_KALIMBA != header.e_machine) {
359 return eSectionTypeOther;
362 if (llvm::ELF::SHT_NOBITS == sect_hdr.sh_type) {
363 return eSectionTypeZeroFill;
366 if (llvm::ELF::SHT_PROGBITS == sect_hdr.sh_type) {
367 const lldb::addr_t KAL_CODE_BIT = 1 << 31;
368 return KAL_CODE_BIT & sect_hdr.sh_addr ? eSectionTypeCode
372 return eSectionTypeOther;
375 // Arbitrary constant used as UUID prefix for core files.
376 const uint32_t ObjectFileELF::g_core_uuid_magic(0xE210C);
378 //------------------------------------------------------------------
380 //------------------------------------------------------------------
381 void ObjectFileELF::Initialize() {
382 PluginManager::RegisterPlugin(GetPluginNameStatic(),
383 GetPluginDescriptionStatic(), CreateInstance,
384 CreateMemoryInstance, GetModuleSpecifications);
387 void ObjectFileELF::Terminate() {
388 PluginManager::UnregisterPlugin(CreateInstance);
391 lldb_private::ConstString ObjectFileELF::GetPluginNameStatic() {
392 static ConstString g_name("elf");
396 const char *ObjectFileELF::GetPluginDescriptionStatic() {
397 return "ELF object file reader.";
400 ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp,
401 DataBufferSP &data_sp,
402 lldb::offset_t data_offset,
403 const lldb_private::FileSpec *file,
404 lldb::offset_t file_offset,
405 lldb::offset_t length) {
408 DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
416 if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
419 const uint8_t *magic = data_sp->GetBytes() + data_offset;
420 if (!ELFHeader::MagicBytesMatch(magic))
423 // Update the data to contain the entire file if it doesn't already
424 if (data_sp->GetByteSize() < length) {
426 DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
430 magic = data_sp->GetBytes();
433 unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
434 if (address_size == 4 || address_size == 8) {
435 std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(
436 module_sp, data_sp, data_offset, file, file_offset, length));
438 if (objfile_ap->GetArchitecture(spec) &&
439 objfile_ap->SetModulesArchitecture(spec))
440 return objfile_ap.release();
446 ObjectFile *ObjectFileELF::CreateMemoryInstance(
447 const lldb::ModuleSP &module_sp, DataBufferSP &data_sp,
448 const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
449 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) {
450 const uint8_t *magic = data_sp->GetBytes();
451 if (ELFHeader::MagicBytesMatch(magic)) {
452 unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
453 if (address_size == 4 || address_size == 8) {
454 std::auto_ptr<ObjectFileELF> objfile_ap(
455 new ObjectFileELF(module_sp, data_sp, process_sp, header_addr));
457 if (objfile_ap->GetArchitecture(spec) &&
458 objfile_ap->SetModulesArchitecture(spec))
459 return objfile_ap.release();
466 bool ObjectFileELF::MagicBytesMatch(DataBufferSP &data_sp,
467 lldb::addr_t data_offset,
468 lldb::addr_t data_length) {
470 data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
471 const uint8_t *magic = data_sp->GetBytes() + data_offset;
472 return ELFHeader::MagicBytesMatch(magic);
478 * crc function from http://svnweb.freebsd.org/base/head/sys/libkern/crc32.c
480 * COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or
481 * code or tables extracted from it, as desired without restriction.
483 static uint32_t calc_crc32(uint32_t crc, const void *buf, size_t size) {
484 static const uint32_t g_crc32_tab[] = {
485 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
486 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
487 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
488 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
489 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
490 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
491 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
492 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
493 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
494 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
495 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
496 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
497 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
498 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
499 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
500 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
501 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
502 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
503 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
504 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
505 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
506 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
507 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
508 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
509 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
510 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
511 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
512 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
513 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
514 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
515 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
516 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
517 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
518 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
519 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
520 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
521 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
522 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
523 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
524 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
525 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
526 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
527 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
528 const uint8_t *p = (const uint8_t *)buf;
532 crc = g_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
536 static uint32_t calc_gnu_debuglink_crc32(const void *buf, size_t size) {
537 return calc_crc32(0U, buf, size);
540 uint32_t ObjectFileELF::CalculateELFNotesSegmentsCRC32(
541 const ProgramHeaderColl &program_headers, DataExtractor &object_data) {
542 typedef ProgramHeaderCollConstIter Iter;
544 uint32_t core_notes_crc = 0;
546 for (Iter I = program_headers.begin(); I != program_headers.end(); ++I) {
547 if (I->p_type == llvm::ELF::PT_NOTE) {
548 const elf_off ph_offset = I->p_offset;
549 const size_t ph_size = I->p_filesz;
551 DataExtractor segment_data;
552 if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size) {
553 // The ELF program header contained incorrect data,
554 // probably corefile is incomplete or corrupted.
558 core_notes_crc = calc_crc32(core_notes_crc, segment_data.GetDataStart(),
559 segment_data.GetByteSize());
563 return core_notes_crc;
566 static const char *OSABIAsCString(unsigned char osabi_byte) {
567 #define _MAKE_OSABI_CASE(x) \
570 switch (osabi_byte) {
571 _MAKE_OSABI_CASE(ELFOSABI_NONE);
572 _MAKE_OSABI_CASE(ELFOSABI_HPUX);
573 _MAKE_OSABI_CASE(ELFOSABI_NETBSD);
574 _MAKE_OSABI_CASE(ELFOSABI_GNU);
575 _MAKE_OSABI_CASE(ELFOSABI_HURD);
576 _MAKE_OSABI_CASE(ELFOSABI_SOLARIS);
577 _MAKE_OSABI_CASE(ELFOSABI_AIX);
578 _MAKE_OSABI_CASE(ELFOSABI_IRIX);
579 _MAKE_OSABI_CASE(ELFOSABI_FREEBSD);
580 _MAKE_OSABI_CASE(ELFOSABI_TRU64);
581 _MAKE_OSABI_CASE(ELFOSABI_MODESTO);
582 _MAKE_OSABI_CASE(ELFOSABI_OPENBSD);
583 _MAKE_OSABI_CASE(ELFOSABI_OPENVMS);
584 _MAKE_OSABI_CASE(ELFOSABI_NSK);
585 _MAKE_OSABI_CASE(ELFOSABI_AROS);
586 _MAKE_OSABI_CASE(ELFOSABI_FENIXOS);
587 _MAKE_OSABI_CASE(ELFOSABI_C6000_ELFABI);
588 _MAKE_OSABI_CASE(ELFOSABI_C6000_LINUX);
589 _MAKE_OSABI_CASE(ELFOSABI_ARM);
590 _MAKE_OSABI_CASE(ELFOSABI_STANDALONE);
592 return "<unknown-osabi>";
594 #undef _MAKE_OSABI_CASE
598 // WARNING : This function is being deprecated
599 // It's functionality has moved to ArchSpec::SetArchitecture
600 // This function is only being kept to validate the move.
602 // TODO : Remove this function
603 static bool GetOsFromOSABI(unsigned char osabi_byte,
604 llvm::Triple::OSType &ostype) {
605 switch (osabi_byte) {
607 ostype = llvm::Triple::OSType::AIX;
609 case ELFOSABI_FREEBSD:
610 ostype = llvm::Triple::OSType::FreeBSD;
613 ostype = llvm::Triple::OSType::Linux;
615 case ELFOSABI_NETBSD:
616 ostype = llvm::Triple::OSType::NetBSD;
618 case ELFOSABI_OPENBSD:
619 ostype = llvm::Triple::OSType::OpenBSD;
621 case ELFOSABI_SOLARIS:
622 ostype = llvm::Triple::OSType::Solaris;
625 ostype = llvm::Triple::OSType::UnknownOS;
627 return ostype != llvm::Triple::OSType::UnknownOS;
630 size_t ObjectFileELF::GetModuleSpecifications(
631 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
632 lldb::offset_t data_offset, lldb::offset_t file_offset,
633 lldb::offset_t length, lldb_private::ModuleSpecList &specs) {
634 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
636 const size_t initial_count = specs.GetSize();
638 if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
640 data.SetData(data_sp);
641 elf::ELFHeader header;
642 lldb::offset_t header_offset = data_offset;
643 if (header.Parse(data, &header_offset)) {
645 ModuleSpec spec(file);
647 const uint32_t sub_type = subTypeFromElfHeader(header);
648 spec.GetArchitecture().SetArchitecture(
649 eArchTypeELF, header.e_machine, sub_type, header.e_ident[EI_OSABI]);
651 if (spec.GetArchitecture().IsValid()) {
652 llvm::Triple::OSType ostype;
653 llvm::Triple::VendorType vendor;
654 llvm::Triple::OSType spec_ostype =
655 spec.GetArchitecture().GetTriple().getOS();
658 log->Printf("ObjectFileELF::%s file '%s' module OSABI: %s",
659 __FUNCTION__, file.GetPath().c_str(),
660 OSABIAsCString(header.e_ident[EI_OSABI]));
662 // SetArchitecture should have set the vendor to unknown
663 vendor = spec.GetArchitecture().GetTriple().getVendor();
664 assert(vendor == llvm::Triple::UnknownVendor);
665 UNUSED_IF_ASSERT_DISABLED(vendor);
668 // Validate it is ok to remove GetOsFromOSABI
669 GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
670 assert(spec_ostype == ostype);
671 if (spec_ostype != llvm::Triple::OSType::UnknownOS) {
673 log->Printf("ObjectFileELF::%s file '%s' set ELF module OS type "
674 "from ELF header OSABI.",
675 __FUNCTION__, file.GetPath().c_str());
678 // In case there is header extension in the section #0, the header
679 // we parsed above could have sentinel values for e_phnum, e_shnum,
680 // and e_shstrndx. In this case we need to reparse the header
681 // with a bigger data source to get the actual values.
682 size_t section_header_end = header.e_shoff + header.e_shentsize;
683 if (header.HasHeaderExtension() &&
684 section_header_end > data_sp->GetByteSize()) {
685 data_sp = DataBufferLLVM::CreateSliceFromPath(
686 file.GetPath(), section_header_end, file_offset);
688 data.SetData(data_sp);
689 lldb::offset_t header_offset = data_offset;
690 header.Parse(data, &header_offset);
694 // Try to get the UUID from the section list. Usually that's at the
695 // end, so map the file in if we don't have it already.
697 header.e_shoff + header.e_shnum * header.e_shentsize;
698 if (section_header_end > data_sp->GetByteSize()) {
699 data_sp = DataBufferLLVM::CreateSliceFromPath(
700 file.GetPath(), section_header_end, file_offset);
702 data.SetData(data_sp);
705 uint32_t gnu_debuglink_crc = 0;
706 std::string gnu_debuglink_file;
707 SectionHeaderColl section_headers;
708 lldb_private::UUID &uuid = spec.GetUUID();
710 GetSectionHeaderInfo(section_headers, data, header, uuid,
711 gnu_debuglink_file, gnu_debuglink_crc,
712 spec.GetArchitecture());
714 llvm::Triple &spec_triple = spec.GetArchitecture().GetTriple();
717 log->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
719 __FUNCTION__, file.GetPath().c_str(),
720 spec_triple.getTriple().c_str(),
721 spec.GetArchitecture().GetArchitectureName());
723 if (!uuid.IsValid()) {
724 uint32_t core_notes_crc = 0;
726 if (!gnu_debuglink_crc) {
727 static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
728 lldb_private::Timer scoped_timer(
730 "Calculating module crc32 %s with size %" PRIu64 " KiB",
731 file.GetLastPathComponent().AsCString(),
732 (file.GetByteSize() - file_offset) / 1024);
734 // For core files - which usually don't happen to have a
735 // gnu_debuglink, and are pretty bulky - calculating whole
736 // contents crc32 would be too much of luxury. Thus we will need
737 // to fallback to something simpler.
738 if (header.e_type == llvm::ELF::ET_CORE) {
739 size_t program_headers_end =
740 header.e_phoff + header.e_phnum * header.e_phentsize;
741 if (program_headers_end > data_sp->GetByteSize()) {
742 data_sp = DataBufferLLVM::CreateSliceFromPath(
743 file.GetPath(), program_headers_end, file_offset);
745 data.SetData(data_sp);
747 ProgramHeaderColl program_headers;
748 GetProgramHeaderInfo(program_headers, data, header);
750 size_t segment_data_end = 0;
751 for (ProgramHeaderCollConstIter I = program_headers.begin();
752 I != program_headers.end(); ++I) {
753 segment_data_end = std::max<unsigned long long>(
754 I->p_offset + I->p_filesz, segment_data_end);
757 if (segment_data_end > data_sp->GetByteSize()) {
758 data_sp = DataBufferLLVM::CreateSliceFromPath(
759 file.GetPath(), segment_data_end, file_offset);
761 data.SetData(data_sp);
765 CalculateELFNotesSegmentsCRC32(program_headers, data);
767 // Need to map entire file into memory to calculate the crc.
768 data_sp = DataBufferLLVM::CreateSliceFromPath(file.GetPath(), -1,
771 data.SetData(data_sp);
772 gnu_debuglink_crc = calc_gnu_debuglink_crc32(
773 data.GetDataStart(), data.GetByteSize());
777 if (gnu_debuglink_crc) {
778 // Use 4 bytes of crc from the .gnu_debuglink section.
779 uint32_t uuidt[4] = {gnu_debuglink_crc, 0, 0, 0};
780 uuid.SetBytes(uuidt, sizeof(uuidt));
781 } else if (core_notes_crc) {
782 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make
783 // it look different form
784 // .gnu_debuglink crc followed by 4 bytes of note segments crc.
785 uint32_t uuidt[4] = {g_core_uuid_magic, core_notes_crc, 0, 0};
786 uuid.SetBytes(uuidt, sizeof(uuidt));
796 return specs.GetSize() - initial_count;
799 //------------------------------------------------------------------
800 // PluginInterface protocol
801 //------------------------------------------------------------------
802 lldb_private::ConstString ObjectFileELF::GetPluginName() {
803 return GetPluginNameStatic();
806 uint32_t ObjectFileELF::GetPluginVersion() { return m_plugin_version; }
807 //------------------------------------------------------------------
808 // ObjectFile protocol
809 //------------------------------------------------------------------
811 ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp,
812 DataBufferSP &data_sp, lldb::offset_t data_offset,
813 const FileSpec *file, lldb::offset_t file_offset,
814 lldb::offset_t length)
815 : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
816 m_header(), m_uuid(), m_gnu_debuglink_file(), m_gnu_debuglink_crc(0),
817 m_program_headers(), m_section_headers(), m_dynamic_symbols(),
818 m_filespec_ap(), m_entry_point_address(), m_arch_spec() {
821 ::memset(&m_header, 0, sizeof(m_header));
824 ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp,
825 DataBufferSP &header_data_sp,
826 const lldb::ProcessSP &process_sp,
828 : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
829 m_header(), m_uuid(), m_gnu_debuglink_file(), m_gnu_debuglink_crc(0),
830 m_program_headers(), m_section_headers(), m_dynamic_symbols(),
831 m_filespec_ap(), m_entry_point_address(), m_arch_spec() {
832 ::memset(&m_header, 0, sizeof(m_header));
835 ObjectFileELF::~ObjectFileELF() {}
837 bool ObjectFileELF::IsExecutable() const {
838 return ((m_header.e_type & ET_EXEC) != 0) || (m_header.e_entry != 0);
841 bool ObjectFileELF::SetLoadAddress(Target &target, lldb::addr_t value,
842 bool value_is_offset) {
843 ModuleSP module_sp = GetModule();
845 size_t num_loaded_sections = 0;
846 SectionList *section_list = GetSectionList();
848 if (!value_is_offset) {
849 bool found_offset = false;
850 for (size_t i = 1, count = GetProgramHeaderCount(); i <= count; ++i) {
851 const elf::ELFProgramHeader *header = GetProgramHeaderByIndex(i);
852 if (header == nullptr)
855 if (header->p_type != PT_LOAD || header->p_offset != 0)
858 value = value - header->p_vaddr;
866 const size_t num_sections = section_list->GetSize();
869 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
870 // Iterate through the object file sections to find all
871 // of the sections that have SHF_ALLOC in their flag bits.
872 SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
873 if (section_sp && section_sp->Test(SHF_ALLOC)) {
874 lldb::addr_t load_addr = section_sp->GetFileAddress();
875 // We don't want to update the load address of a section with type
876 // eSectionTypeAbsoluteAddress as they already have the absolute load
879 if (section_sp->GetType() != eSectionTypeAbsoluteAddress)
882 // On 32-bit systems the load address have to fit into 4 bytes. The
884 // the bytes are the overflow from the addition.
885 if (GetAddressByteSize() == 4)
886 load_addr &= 0xFFFFFFFF;
888 if (target.GetSectionLoadList().SetSectionLoadAddress(section_sp,
890 ++num_loaded_sections;
893 return num_loaded_sections > 0;
899 ByteOrder ObjectFileELF::GetByteOrder() const {
900 if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
901 return eByteOrderBig;
902 if (m_header.e_ident[EI_DATA] == ELFDATA2LSB)
903 return eByteOrderLittle;
904 return eByteOrderInvalid;
907 uint32_t ObjectFileELF::GetAddressByteSize() const {
908 return m_data.GetAddressByteSize();
911 AddressClass ObjectFileELF::GetAddressClass(addr_t file_addr) {
912 Symtab *symtab = GetSymtab();
914 return eAddressClassUnknown;
916 // The address class is determined based on the symtab. Ask it from the object
918 // contains the symtab information.
919 ObjectFile *symtab_objfile = symtab->GetObjectFile();
920 if (symtab_objfile != nullptr && symtab_objfile != this)
921 return symtab_objfile->GetAddressClass(file_addr);
923 auto res = ObjectFile::GetAddressClass(file_addr);
924 if (res != eAddressClassCode)
927 auto ub = m_address_class_map.upper_bound(file_addr);
928 if (ub == m_address_class_map.begin()) {
929 // No entry in the address class map before the address. Return
930 // default address class for an address in a code section.
931 return eAddressClassCode;
934 // Move iterator to the address class entry preceding address
940 size_t ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I) {
941 return std::distance(m_section_headers.begin(), I) + 1u;
944 size_t ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const {
945 return std::distance(m_section_headers.begin(), I) + 1u;
948 bool ObjectFileELF::ParseHeader() {
949 lldb::offset_t offset = 0;
950 return m_header.Parse(m_data, &offset);
953 bool ObjectFileELF::GetUUID(lldb_private::UUID *uuid) {
954 // Need to parse the section list to get the UUIDs, so make sure that's been
956 if (!ParseSectionHeaders() && GetType() != ObjectFile::eTypeCoreFile)
959 if (m_uuid.IsValid()) {
960 // We have the full build id uuid.
963 } else if (GetType() == ObjectFile::eTypeCoreFile) {
964 uint32_t core_notes_crc = 0;
966 if (!ParseProgramHeaders())
969 core_notes_crc = CalculateELFNotesSegmentsCRC32(m_program_headers, m_data);
971 if (core_notes_crc) {
972 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it
973 // look different form .gnu_debuglink crc - followed by 4 bytes of note
975 uint32_t uuidt[4] = {g_core_uuid_magic, core_notes_crc, 0, 0};
976 m_uuid.SetBytes(uuidt, sizeof(uuidt));
979 if (!m_gnu_debuglink_crc)
980 m_gnu_debuglink_crc =
981 calc_gnu_debuglink_crc32(m_data.GetDataStart(), m_data.GetByteSize());
982 if (m_gnu_debuglink_crc) {
983 // Use 4 bytes of crc from the .gnu_debuglink section.
984 uint32_t uuidt[4] = {m_gnu_debuglink_crc, 0, 0, 0};
985 m_uuid.SetBytes(uuidt, sizeof(uuidt));
989 if (m_uuid.IsValid()) {
997 lldb_private::FileSpecList ObjectFileELF::GetDebugSymbolFilePaths() {
998 FileSpecList file_spec_list;
1000 if (!m_gnu_debuglink_file.empty()) {
1001 FileSpec file_spec(m_gnu_debuglink_file, false);
1002 file_spec_list.Append(file_spec);
1004 return file_spec_list;
1007 uint32_t ObjectFileELF::GetDependentModules(FileSpecList &files) {
1008 size_t num_modules = ParseDependentModules();
1009 uint32_t num_specs = 0;
1011 for (unsigned i = 0; i < num_modules; ++i) {
1012 if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i)))
1019 Address ObjectFileELF::GetImageInfoAddress(Target *target) {
1020 if (!ParseDynamicSymbols())
1023 SectionList *section_list = GetSectionList();
1027 // Find the SHT_DYNAMIC (.dynamic) section.
1028 SectionSP dynsym_section_sp(
1029 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true));
1030 if (!dynsym_section_sp)
1032 assert(dynsym_section_sp->GetObjectFile() == this);
1034 user_id_t dynsym_id = dynsym_section_sp->GetID();
1035 const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id);
1039 for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) {
1040 ELFDynamic &symbol = m_dynamic_symbols[i];
1042 if (symbol.d_tag == DT_DEBUG) {
1043 // Compute the offset as the number of previous entries plus the
1045 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
1046 return Address(dynsym_section_sp, offset);
1048 // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP
1049 // exists in non-PIE.
1050 else if ((symbol.d_tag == DT_MIPS_RLD_MAP ||
1051 symbol.d_tag == DT_MIPS_RLD_MAP_REL) &&
1053 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
1054 addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target);
1055 if (dyn_base == LLDB_INVALID_ADDRESS)
1059 if (symbol.d_tag == DT_MIPS_RLD_MAP) {
1060 // DT_MIPS_RLD_MAP tag stores an absolute address of the debug pointer.
1062 if (target->ReadPointerFromMemory(dyn_base + offset, false, error,
1066 if (symbol.d_tag == DT_MIPS_RLD_MAP_REL) {
1067 // DT_MIPS_RLD_MAP_REL tag stores the offset to the debug pointer,
1068 // relative to the address of the tag.
1069 uint64_t rel_offset;
1070 rel_offset = target->ReadUnsignedIntegerFromMemory(
1071 dyn_base + offset, false, GetAddressByteSize(), UINT64_MAX, error);
1072 if (error.Success() && rel_offset != UINT64_MAX) {
1074 addr_t debug_ptr_address =
1075 dyn_base + (offset - GetAddressByteSize()) + rel_offset;
1076 addr.SetOffset(debug_ptr_address);
1086 lldb_private::Address ObjectFileELF::GetEntryPointAddress() {
1087 if (m_entry_point_address.IsValid())
1088 return m_entry_point_address;
1090 if (!ParseHeader() || !IsExecutable())
1091 return m_entry_point_address;
1093 SectionList *section_list = GetSectionList();
1094 addr_t offset = m_header.e_entry;
1097 m_entry_point_address.SetOffset(offset);
1099 m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list);
1100 return m_entry_point_address;
1103 //----------------------------------------------------------------------
1104 // ParseDependentModules
1105 //----------------------------------------------------------------------
1106 size_t ObjectFileELF::ParseDependentModules() {
1107 if (m_filespec_ap.get())
1108 return m_filespec_ap->GetSize();
1110 m_filespec_ap.reset(new FileSpecList());
1112 if (!ParseSectionHeaders())
1115 SectionList *section_list = GetSectionList();
1119 // Find the SHT_DYNAMIC section.
1121 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
1125 assert(dynsym->GetObjectFile() == this);
1127 const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex(dynsym->GetID());
1130 // sh_link: section header index of string table used by entries in the
1132 Section *dynstr = section_list->FindSectionByID(header->sh_link + 1).get();
1136 DataExtractor dynsym_data;
1137 DataExtractor dynstr_data;
1138 if (ReadSectionData(dynsym, dynsym_data) &&
1139 ReadSectionData(dynstr, dynstr_data)) {
1141 const lldb::offset_t section_size = dynsym_data.GetByteSize();
1142 lldb::offset_t offset = 0;
1144 // The only type of entries we are concerned with are tagged DT_NEEDED,
1145 // yielding the name of a required library.
1146 while (offset < section_size) {
1147 if (!symbol.Parse(dynsym_data, &offset))
1150 if (symbol.d_tag != DT_NEEDED)
1153 uint32_t str_index = static_cast<uint32_t>(symbol.d_val);
1154 const char *lib_name = dynstr_data.PeekCStr(str_index);
1155 m_filespec_ap->Append(FileSpec(lib_name, true));
1159 return m_filespec_ap->GetSize();
1162 //----------------------------------------------------------------------
1163 // GetProgramHeaderInfo
1164 //----------------------------------------------------------------------
1165 size_t ObjectFileELF::GetProgramHeaderInfo(ProgramHeaderColl &program_headers,
1166 DataExtractor &object_data,
1167 const ELFHeader &header) {
1168 // We have already parsed the program headers
1169 if (!program_headers.empty())
1170 return program_headers.size();
1172 // If there are no program headers to read we are done.
1173 if (header.e_phnum == 0)
1176 program_headers.resize(header.e_phnum);
1177 if (program_headers.size() != header.e_phnum)
1180 const size_t ph_size = header.e_phnum * header.e_phentsize;
1181 const elf_off ph_offset = header.e_phoff;
1183 if (data.SetData(object_data, ph_offset, ph_size) != ph_size)
1187 lldb::offset_t offset;
1188 for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) {
1189 if (program_headers[idx].Parse(data, &offset) == false)
1193 if (idx < program_headers.size())
1194 program_headers.resize(idx);
1196 return program_headers.size();
1199 //----------------------------------------------------------------------
1200 // ParseProgramHeaders
1201 //----------------------------------------------------------------------
1202 size_t ObjectFileELF::ParseProgramHeaders() {
1203 return GetProgramHeaderInfo(m_program_headers, m_data, m_header);
1206 lldb_private::Status
1207 ObjectFileELF::RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
1208 lldb_private::ArchSpec &arch_spec,
1209 lldb_private::UUID &uuid) {
1210 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
1213 lldb::offset_t offset = 0;
1216 // Parse the note header. If this fails, bail out.
1217 const lldb::offset_t note_offset = offset;
1218 ELFNote note = ELFNote();
1219 if (!note.Parse(data, &offset)) {
1225 log->Printf("ObjectFileELF::%s parsing note name='%s', type=%" PRIu32,
1226 __FUNCTION__, note.n_name.c_str(), note.n_type);
1228 // Process FreeBSD ELF notes.
1229 if ((note.n_name == LLDB_NT_OWNER_FREEBSD) &&
1230 (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) &&
1231 (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) {
1232 // Pull out the min version info.
1233 uint32_t version_info;
1234 if (data.GetU32(&offset, &version_info, 1) == nullptr) {
1235 error.SetErrorString("failed to read FreeBSD ABI note payload");
1239 // Convert the version info into a major/minor number.
1240 const uint32_t version_major = version_info / 100000;
1241 const uint32_t version_minor = (version_info / 1000) % 100;
1244 snprintf(os_name, sizeof(os_name), "freebsd%" PRIu32 ".%" PRIu32,
1245 version_major, version_minor);
1247 // Set the elf OS version to FreeBSD. Also clear the vendor.
1248 arch_spec.GetTriple().setOSName(os_name);
1249 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1252 log->Printf("ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32
1254 __FUNCTION__, version_major, version_minor,
1255 static_cast<uint32_t>(version_info % 1000));
1257 // Process GNU ELF notes.
1258 else if (note.n_name == LLDB_NT_OWNER_GNU) {
1259 switch (note.n_type) {
1260 case LLDB_NT_GNU_ABI_TAG:
1261 if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) {
1262 // Pull out the min OS version supporting the ABI.
1263 uint32_t version_info[4];
1264 if (data.GetU32(&offset, &version_info[0], note.n_descsz / 4) ==
1266 error.SetErrorString("failed to read GNU ABI note payload");
1270 // Set the OS per the OS field.
1271 switch (version_info[0]) {
1272 case LLDB_NT_GNU_ABI_OS_LINUX:
1273 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1274 arch_spec.GetTriple().setVendor(
1275 llvm::Triple::VendorType::UnknownVendor);
1278 "ObjectFileELF::%s detected Linux, min version %" PRIu32
1279 ".%" PRIu32 ".%" PRIu32,
1280 __FUNCTION__, version_info[1], version_info[2],
1282 // FIXME we have the minimal version number, we could be propagating
1283 // that. version_info[1] = OS Major, version_info[2] = OS Minor,
1284 // version_info[3] = Revision.
1286 case LLDB_NT_GNU_ABI_OS_HURD:
1287 arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
1288 arch_spec.GetTriple().setVendor(
1289 llvm::Triple::VendorType::UnknownVendor);
1291 log->Printf("ObjectFileELF::%s detected Hurd (unsupported), min "
1292 "version %" PRIu32 ".%" PRIu32 ".%" PRIu32,
1293 __FUNCTION__, version_info[1], version_info[2],
1296 case LLDB_NT_GNU_ABI_OS_SOLARIS:
1297 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Solaris);
1298 arch_spec.GetTriple().setVendor(
1299 llvm::Triple::VendorType::UnknownVendor);
1302 "ObjectFileELF::%s detected Solaris, min version %" PRIu32
1303 ".%" PRIu32 ".%" PRIu32,
1304 __FUNCTION__, version_info[1], version_info[2],
1310 "ObjectFileELF::%s unrecognized OS in note, id %" PRIu32
1311 ", min version %" PRIu32 ".%" PRIu32 ".%" PRIu32,
1312 __FUNCTION__, version_info[0], version_info[1],
1313 version_info[2], version_info[3]);
1319 case LLDB_NT_GNU_BUILD_ID_TAG:
1320 // Only bother processing this if we don't already have the uuid set.
1321 if (!uuid.IsValid()) {
1322 // 16 bytes is UUID|MD5, 20 bytes is SHA1. Other linkers may produce a
1323 // build-id of a different
1324 // length. Accept it as long as it's at least 4 bytes as it will be
1325 // better than our own crc32.
1326 if (note.n_descsz >= 4 && note.n_descsz <= 20) {
1327 uint8_t uuidbuf[20];
1328 if (data.GetU8(&offset, &uuidbuf, note.n_descsz) == nullptr) {
1329 error.SetErrorString("failed to read GNU_BUILD_ID note payload");
1333 // Save the build id as the UUID for the module.
1334 uuid.SetBytes(uuidbuf, note.n_descsz);
1339 if (arch_spec.IsMIPS() &&
1340 arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1341 // The note.n_name == LLDB_NT_OWNER_GNU is valid for Linux platform
1342 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1344 // Process NetBSD ELF notes.
1345 else if ((note.n_name == LLDB_NT_OWNER_NETBSD) &&
1346 (note.n_type == LLDB_NT_NETBSD_ABI_TAG) &&
1347 (note.n_descsz == LLDB_NT_NETBSD_ABI_SIZE)) {
1348 // Pull out the min version info.
1349 uint32_t version_info;
1350 if (data.GetU32(&offset, &version_info, 1) == nullptr) {
1351 error.SetErrorString("failed to read NetBSD ABI note payload");
1355 // Set the elf OS version to NetBSD. Also clear the vendor.
1356 arch_spec.GetTriple().setOS(llvm::Triple::OSType::NetBSD);
1357 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1361 "ObjectFileELF::%s detected NetBSD, min version constant %" PRIu32,
1362 __FUNCTION__, version_info);
1364 // Process OpenBSD ELF notes.
1365 else if (note.n_name == LLDB_NT_OWNER_OPENBSD) {
1366 // Set the elf OS version to OpenBSD. Also clear the vendor.
1367 arch_spec.GetTriple().setOS(llvm::Triple::OSType::OpenBSD);
1368 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1370 // Process CSR kalimba notes
1371 else if ((note.n_type == LLDB_NT_GNU_ABI_TAG) &&
1372 (note.n_name == LLDB_NT_OWNER_CSR)) {
1373 arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
1374 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::CSR);
1376 // TODO At some point the description string could be processed.
1377 // It could provide a steer towards the kalimba variant which
1378 // this ELF targets.
1379 if (note.n_descsz) {
1381 data.GetCStr(&offset, llvm::alignTo(note.n_descsz, 4));
1384 } else if (note.n_name == LLDB_NT_OWNER_ANDROID) {
1385 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1386 arch_spec.GetTriple().setEnvironment(
1387 llvm::Triple::EnvironmentType::Android);
1388 } else if (note.n_name == LLDB_NT_OWNER_LINUX) {
1389 // This is sometimes found in core files and usually contains extended
1391 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1392 } else if (note.n_name == LLDB_NT_OWNER_CORE) {
1393 // Parse the NT_FILE to look for stuff in paths to shared libraries
1394 // As the contents look like this in a 64 bit ELF core file:
1395 // count = 0x000000000000000a (10)
1396 // page_size = 0x0000000000001000 (4096)
1397 // Index start end file_ofs path
1398 // ===== ------------------ ------------------ ------------------
1399 // -------------------------------------
1400 // [ 0] 0x0000000000400000 0x0000000000401000 0x0000000000000000
1402 // [ 1] 0x0000000000600000 0x0000000000601000 0x0000000000000000
1404 // [ 2] 0x0000000000601000 0x0000000000602000 0x0000000000000001
1406 // [ 3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000
1407 // /lib/x86_64-linux-gnu/libc-2.19.so
1408 // [ 4] 0x00007fa79cba8000 0x00007fa79cda7000 0x00000000000001bb
1409 // /lib/x86_64-linux-gnu/libc-2.19.so
1410 // [ 5] 0x00007fa79cda7000 0x00007fa79cdab000 0x00000000000001ba
1411 // /lib/x86_64-linux-gnu/libc-2.19.so
1412 // [ 6] 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be
1413 // /lib/x86_64-linux-gnu/libc-2.19.so
1414 // [ 7] 0x00007fa79cdb2000 0x00007fa79cdd5000 0x0000000000000000
1415 // /lib/x86_64-linux-gnu/ld-2.19.so
1416 // [ 8] 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022
1417 // /lib/x86_64-linux-gnu/ld-2.19.so
1418 // [ 9] 0x00007fa79cfd5000 0x00007fa79cfd6000 0x0000000000000023
1419 // /lib/x86_64-linux-gnu/ld-2.19.so
1420 // In the 32 bit ELFs the count, page_size, start, end, file_ofs are
1422 // For reference: see readelf source code (in binutils).
1423 if (note.n_type == NT_FILE) {
1424 uint64_t count = data.GetAddress(&offset);
1426 data.GetAddress(&offset); // Skip page size
1427 offset += count * 3 *
1428 data.GetAddressByteSize(); // Skip all start/end/file_ofs
1429 for (size_t i = 0; i < count; ++i) {
1430 cstr = data.GetCStr(&offset);
1431 if (cstr == nullptr) {
1432 error.SetErrorStringWithFormat("ObjectFileELF::%s trying to read "
1433 "at an offset after the end "
1434 "(GetCStr returned nullptr)",
1438 llvm::StringRef path(cstr);
1439 if (path.contains("/lib/x86_64-linux-gnu") || path.contains("/lib/i386-linux-gnu")) {
1440 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1444 if (arch_spec.IsMIPS() &&
1445 arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
1446 // In case of MIPSR6, the LLDB_NT_OWNER_GNU note is missing
1447 // for some cases (e.g. compile with -nostdlib)
1448 // Hence set OS to Linux
1449 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1453 // Calculate the offset of the next note just in case "offset" has been used
1454 // to poke at the contents of the note data
1455 offset = note_offset + note.GetByteSize();
1461 void ObjectFileELF::ParseARMAttributes(DataExtractor &data, uint64_t length,
1462 ArchSpec &arch_spec) {
1463 lldb::offset_t Offset = 0;
1465 uint8_t FormatVersion = data.GetU8(&Offset);
1466 if (FormatVersion != llvm::ARMBuildAttrs::Format_Version)
1469 Offset = Offset + sizeof(uint32_t); // Section Length
1470 llvm::StringRef VendorName = data.GetCStr(&Offset);
1472 if (VendorName != "aeabi")
1475 if (arch_spec.GetTriple().getEnvironment() ==
1476 llvm::Triple::UnknownEnvironment)
1477 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI);
1479 while (Offset < length) {
1480 uint8_t Tag = data.GetU8(&Offset);
1481 uint32_t Size = data.GetU32(&Offset);
1483 if (Tag != llvm::ARMBuildAttrs::File || Size == 0)
1486 while (Offset < length) {
1487 uint64_t Tag = data.GetULEB128(&Offset);
1491 data.GetULEB128(&Offset);
1492 else if (Tag % 2 == 0)
1493 data.GetULEB128(&Offset);
1495 data.GetCStr(&Offset);
1499 case llvm::ARMBuildAttrs::CPU_raw_name:
1500 case llvm::ARMBuildAttrs::CPU_name:
1501 data.GetCStr(&Offset);
1505 case llvm::ARMBuildAttrs::ABI_VFP_args: {
1506 uint64_t VFPArgs = data.GetULEB128(&Offset);
1508 if (VFPArgs == llvm::ARMBuildAttrs::BaseAAPCS) {
1509 if (arch_spec.GetTriple().getEnvironment() ==
1510 llvm::Triple::UnknownEnvironment ||
1511 arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABIHF)
1512 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI);
1514 arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float);
1515 } else if (VFPArgs == llvm::ARMBuildAttrs::HardFPAAPCS) {
1516 if (arch_spec.GetTriple().getEnvironment() ==
1517 llvm::Triple::UnknownEnvironment ||
1518 arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABI)
1519 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABIHF);
1521 arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float);
1531 //----------------------------------------------------------------------
1532 // GetSectionHeaderInfo
1533 //----------------------------------------------------------------------
1534 size_t ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl §ion_headers,
1535 DataExtractor &object_data,
1536 const elf::ELFHeader &header,
1537 lldb_private::UUID &uuid,
1538 std::string &gnu_debuglink_file,
1539 uint32_t &gnu_debuglink_crc,
1540 ArchSpec &arch_spec) {
1541 // Don't reparse the section headers if we already did that.
1542 if (!section_headers.empty())
1543 return section_headers.size();
1545 // Only initialize the arch_spec to okay defaults if they're not already set.
1546 // We'll refine this with note data as we parse the notes.
1547 if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) {
1548 llvm::Triple::OSType ostype;
1549 llvm::Triple::OSType spec_ostype;
1550 const uint32_t sub_type = subTypeFromElfHeader(header);
1551 arch_spec.SetArchitecture(eArchTypeELF, header.e_machine, sub_type,
1552 header.e_ident[EI_OSABI]);
1554 // Validate if it is ok to remove GetOsFromOSABI.
1555 // Note, that now the OS is determined based on EI_OSABI flag and
1556 // the info extracted from ELF notes (see RefineModuleDetailsFromNote).
1557 // However in some cases that still might be not enough: for example
1558 // a shared library might not have any notes at all
1559 // and have EI_OSABI flag set to System V,
1560 // as result the OS will be set to UnknownOS.
1561 GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
1562 spec_ostype = arch_spec.GetTriple().getOS();
1563 assert(spec_ostype == ostype);
1564 UNUSED_IF_ASSERT_DISABLED(spec_ostype);
1567 if (arch_spec.GetMachine() == llvm::Triple::mips ||
1568 arch_spec.GetMachine() == llvm::Triple::mipsel ||
1569 arch_spec.GetMachine() == llvm::Triple::mips64 ||
1570 arch_spec.GetMachine() == llvm::Triple::mips64el) {
1571 switch (header.e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) {
1572 case llvm::ELF::EF_MIPS_MICROMIPS:
1573 arch_spec.SetFlags(ArchSpec::eMIPSAse_micromips);
1575 case llvm::ELF::EF_MIPS_ARCH_ASE_M16:
1576 arch_spec.SetFlags(ArchSpec::eMIPSAse_mips16);
1578 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX:
1579 arch_spec.SetFlags(ArchSpec::eMIPSAse_mdmx);
1586 if (arch_spec.GetMachine() == llvm::Triple::arm ||
1587 arch_spec.GetMachine() == llvm::Triple::thumb) {
1588 if (header.e_flags & llvm::ELF::EF_ARM_SOFT_FLOAT)
1589 arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float);
1590 else if (header.e_flags & llvm::ELF::EF_ARM_VFP_FLOAT)
1591 arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float);
1594 // If there are no section headers we are done.
1595 if (header.e_shnum == 0)
1598 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES));
1600 section_headers.resize(header.e_shnum);
1601 if (section_headers.size() != header.e_shnum)
1604 const size_t sh_size = header.e_shnum * header.e_shentsize;
1605 const elf_off sh_offset = header.e_shoff;
1606 DataExtractor sh_data;
1607 if (sh_data.SetData(object_data, sh_offset, sh_size) != sh_size)
1611 lldb::offset_t offset;
1612 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) {
1613 if (section_headers[idx].Parse(sh_data, &offset) == false)
1616 if (idx < section_headers.size())
1617 section_headers.resize(idx);
1619 const unsigned strtab_idx = header.e_shstrndx;
1620 if (strtab_idx && strtab_idx < section_headers.size()) {
1621 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx];
1622 const size_t byte_size = sheader.sh_size;
1623 const Elf64_Off offset = sheader.sh_offset;
1624 lldb_private::DataExtractor shstr_data;
1626 if (shstr_data.SetData(object_data, offset, byte_size) == byte_size) {
1627 for (SectionHeaderCollIter I = section_headers.begin();
1628 I != section_headers.end(); ++I) {
1629 static ConstString g_sect_name_gnu_debuglink(".gnu_debuglink");
1630 const ELFSectionHeaderInfo &sheader = *I;
1631 const uint64_t section_size =
1632 sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size;
1633 ConstString name(shstr_data.PeekCStr(I->sh_name));
1635 I->section_name = name;
1637 if (arch_spec.IsMIPS()) {
1638 uint32_t arch_flags = arch_spec.GetFlags();
1640 if (sheader.sh_type == SHT_MIPS_ABIFLAGS) {
1642 if (section_size && (data.SetData(object_data, sheader.sh_offset,
1643 section_size) == section_size)) {
1644 // MIPS ASE Mask is at offset 12 in MIPS.abiflags section
1645 lldb::offset_t offset = 12; // MIPS ABI Flags Version: 0
1646 arch_flags |= data.GetU32(&offset);
1648 // The floating point ABI is at offset 7
1650 switch (data.GetU8(&offset)) {
1651 case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY:
1652 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_ANY;
1654 case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE:
1655 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_DOUBLE;
1657 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE:
1658 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SINGLE;
1660 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT:
1661 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SOFT;
1663 case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64:
1664 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_OLD_64;
1666 case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX:
1667 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_XX;
1669 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64:
1670 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64;
1672 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A:
1673 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64A;
1678 // Settings appropriate ArchSpec ABI Flags
1679 switch (header.e_flags & llvm::ELF::EF_MIPS_ABI) {
1680 case llvm::ELF::EF_MIPS_ABI_O32:
1681 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32;
1683 case EF_MIPS_ABI_O64:
1684 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O64;
1686 case EF_MIPS_ABI_EABI32:
1687 arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI32;
1689 case EF_MIPS_ABI_EABI64:
1690 arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI64;
1693 // ABI Mask doesn't cover N32 and N64 ABI.
1694 if (header.e_ident[EI_CLASS] == llvm::ELF::ELFCLASS64)
1695 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N64;
1696 else if (header.e_flags & llvm::ELF::EF_MIPS_ABI2)
1697 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32;
1700 arch_spec.SetFlags(arch_flags);
1703 if (arch_spec.GetMachine() == llvm::Triple::arm ||
1704 arch_spec.GetMachine() == llvm::Triple::thumb) {
1707 if (sheader.sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 &&
1708 data.SetData(object_data, sheader.sh_offset, section_size) == section_size)
1709 ParseARMAttributes(data, section_size, arch_spec);
1712 if (name == g_sect_name_gnu_debuglink) {
1714 if (section_size && (data.SetData(object_data, sheader.sh_offset,
1715 section_size) == section_size)) {
1716 lldb::offset_t gnu_debuglink_offset = 0;
1717 gnu_debuglink_file = data.GetCStr(&gnu_debuglink_offset);
1718 gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4);
1719 data.GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1);
1723 // Process ELF note section entries.
1724 bool is_note_header = (sheader.sh_type == SHT_NOTE);
1726 // The section header ".note.android.ident" is stored as a
1727 // PROGBITS type header but it is actually a note header.
1728 static ConstString g_sect_name_android_ident(".note.android.ident");
1729 if (!is_note_header && name == g_sect_name_android_ident)
1730 is_note_header = true;
1732 if (is_note_header) {
1733 // Allow notes to refine module info.
1735 if (section_size && (data.SetData(object_data, sheader.sh_offset,
1736 section_size) == section_size)) {
1737 Status error = RefineModuleDetailsFromNote(data, arch_spec, uuid);
1740 log->Printf("ObjectFileELF::%s ELF note processing failed: %s",
1741 __FUNCTION__, error.AsCString());
1747 // Make any unknown triple components to be unspecified unknowns.
1748 if (arch_spec.GetTriple().getVendor() == llvm::Triple::UnknownVendor)
1749 arch_spec.GetTriple().setVendorName(llvm::StringRef());
1750 if (arch_spec.GetTriple().getOS() == llvm::Triple::UnknownOS)
1751 arch_spec.GetTriple().setOSName(llvm::StringRef());
1753 return section_headers.size();
1757 section_headers.clear();
1761 size_t ObjectFileELF::GetProgramHeaderCount() { return ParseProgramHeaders(); }
1763 const elf::ELFProgramHeader *
1764 ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) {
1765 if (!id || !ParseProgramHeaders())
1768 if (--id < m_program_headers.size())
1769 return &m_program_headers[id];
1774 DataExtractor ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) {
1775 const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id);
1776 if (segment_header == NULL)
1777 return DataExtractor();
1778 return DataExtractor(m_data, segment_header->p_offset,
1779 segment_header->p_filesz);
1783 ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const {
1784 size_t pos = symbol_name.find('@');
1785 return symbol_name.substr(0, pos);
1788 //----------------------------------------------------------------------
1789 // ParseSectionHeaders
1790 //----------------------------------------------------------------------
1791 size_t ObjectFileELF::ParseSectionHeaders() {
1792 return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid,
1793 m_gnu_debuglink_file, m_gnu_debuglink_crc,
1797 const ObjectFileELF::ELFSectionHeaderInfo *
1798 ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) {
1799 if (!id || !ParseSectionHeaders())
1802 if (--id < m_section_headers.size())
1803 return &m_section_headers[id];
1808 lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) {
1809 if (!name || !name[0] || !ParseSectionHeaders())
1811 for (size_t i = 1; i < m_section_headers.size(); ++i)
1812 if (m_section_headers[i].section_name == ConstString(name))
1817 void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
1818 if (!m_sections_ap.get() && ParseSectionHeaders()) {
1819 m_sections_ap.reset(new SectionList());
1821 for (SectionHeaderCollIter I = m_section_headers.begin();
1822 I != m_section_headers.end(); ++I) {
1823 const ELFSectionHeaderInfo &header = *I;
1825 ConstString &name = I->section_name;
1826 const uint64_t file_size =
1827 header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
1828 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0;
1830 static ConstString g_sect_name_text(".text");
1831 static ConstString g_sect_name_data(".data");
1832 static ConstString g_sect_name_bss(".bss");
1833 static ConstString g_sect_name_tdata(".tdata");
1834 static ConstString g_sect_name_tbss(".tbss");
1835 static ConstString g_sect_name_dwarf_debug_abbrev(".debug_abbrev");
1836 static ConstString g_sect_name_dwarf_debug_addr(".debug_addr");
1837 static ConstString g_sect_name_dwarf_debug_aranges(".debug_aranges");
1838 static ConstString g_sect_name_dwarf_debug_frame(".debug_frame");
1839 static ConstString g_sect_name_dwarf_debug_info(".debug_info");
1840 static ConstString g_sect_name_dwarf_debug_line(".debug_line");
1841 static ConstString g_sect_name_dwarf_debug_loc(".debug_loc");
1842 static ConstString g_sect_name_dwarf_debug_macinfo(".debug_macinfo");
1843 static ConstString g_sect_name_dwarf_debug_macro(".debug_macro");
1844 static ConstString g_sect_name_dwarf_debug_pubnames(".debug_pubnames");
1845 static ConstString g_sect_name_dwarf_debug_pubtypes(".debug_pubtypes");
1846 static ConstString g_sect_name_dwarf_debug_ranges(".debug_ranges");
1847 static ConstString g_sect_name_dwarf_debug_str(".debug_str");
1848 static ConstString g_sect_name_dwarf_debug_str_offsets(
1849 ".debug_str_offsets");
1850 static ConstString g_sect_name_dwarf_debug_abbrev_dwo(
1851 ".debug_abbrev.dwo");
1852 static ConstString g_sect_name_dwarf_debug_info_dwo(".debug_info.dwo");
1853 static ConstString g_sect_name_dwarf_debug_line_dwo(".debug_line.dwo");
1854 static ConstString g_sect_name_dwarf_debug_macro_dwo(".debug_macro.dwo");
1855 static ConstString g_sect_name_dwarf_debug_loc_dwo(".debug_loc.dwo");
1856 static ConstString g_sect_name_dwarf_debug_str_dwo(".debug_str.dwo");
1857 static ConstString g_sect_name_dwarf_debug_str_offsets_dwo(
1858 ".debug_str_offsets.dwo");
1859 static ConstString g_sect_name_eh_frame(".eh_frame");
1860 static ConstString g_sect_name_arm_exidx(".ARM.exidx");
1861 static ConstString g_sect_name_arm_extab(".ARM.extab");
1862 static ConstString g_sect_name_go_symtab(".gosymtab");
1864 SectionType sect_type = eSectionTypeOther;
1866 bool is_thread_specific = false;
1868 if (name == g_sect_name_text)
1869 sect_type = eSectionTypeCode;
1870 else if (name == g_sect_name_data)
1871 sect_type = eSectionTypeData;
1872 else if (name == g_sect_name_bss)
1873 sect_type = eSectionTypeZeroFill;
1874 else if (name == g_sect_name_tdata) {
1875 sect_type = eSectionTypeData;
1876 is_thread_specific = true;
1877 } else if (name == g_sect_name_tbss) {
1878 sect_type = eSectionTypeZeroFill;
1879 is_thread_specific = true;
1881 // .debug_abbrev – Abbreviations used in the .debug_info section
1882 // .debug_aranges – Lookup table for mapping addresses to compilation
1884 // .debug_frame – Call frame information
1885 // .debug_info – The core DWARF information section
1886 // .debug_line – Line number information
1887 // .debug_loc – Location lists used in DW_AT_location attributes
1888 // .debug_macinfo – Macro information
1889 // .debug_pubnames – Lookup table for mapping object and function names to
1890 // compilation units
1891 // .debug_pubtypes – Lookup table for mapping type names to compilation
1893 // .debug_ranges – Address ranges used in DW_AT_ranges attributes
1894 // .debug_str – String table used in .debug_info
1895 // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section,
1896 // http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html
1897 // MISSING? .debug-index -
1898 // http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644
1899 // MISSING? .debug_types - Type descriptions from DWARF 4? See
1900 // http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo
1901 else if (name == g_sect_name_dwarf_debug_abbrev)
1902 sect_type = eSectionTypeDWARFDebugAbbrev;
1903 else if (name == g_sect_name_dwarf_debug_addr)
1904 sect_type = eSectionTypeDWARFDebugAddr;
1905 else if (name == g_sect_name_dwarf_debug_aranges)
1906 sect_type = eSectionTypeDWARFDebugAranges;
1907 else if (name == g_sect_name_dwarf_debug_frame)
1908 sect_type = eSectionTypeDWARFDebugFrame;
1909 else if (name == g_sect_name_dwarf_debug_info)
1910 sect_type = eSectionTypeDWARFDebugInfo;
1911 else if (name == g_sect_name_dwarf_debug_line)
1912 sect_type = eSectionTypeDWARFDebugLine;
1913 else if (name == g_sect_name_dwarf_debug_loc)
1914 sect_type = eSectionTypeDWARFDebugLoc;
1915 else if (name == g_sect_name_dwarf_debug_macinfo)
1916 sect_type = eSectionTypeDWARFDebugMacInfo;
1917 else if (name == g_sect_name_dwarf_debug_macro)
1918 sect_type = eSectionTypeDWARFDebugMacro;
1919 else if (name == g_sect_name_dwarf_debug_pubnames)
1920 sect_type = eSectionTypeDWARFDebugPubNames;
1921 else if (name == g_sect_name_dwarf_debug_pubtypes)
1922 sect_type = eSectionTypeDWARFDebugPubTypes;
1923 else if (name == g_sect_name_dwarf_debug_ranges)
1924 sect_type = eSectionTypeDWARFDebugRanges;
1925 else if (name == g_sect_name_dwarf_debug_str)
1926 sect_type = eSectionTypeDWARFDebugStr;
1927 else if (name == g_sect_name_dwarf_debug_str_offsets)
1928 sect_type = eSectionTypeDWARFDebugStrOffsets;
1929 else if (name == g_sect_name_dwarf_debug_abbrev_dwo)
1930 sect_type = eSectionTypeDWARFDebugAbbrev;
1931 else if (name == g_sect_name_dwarf_debug_info_dwo)
1932 sect_type = eSectionTypeDWARFDebugInfo;
1933 else if (name == g_sect_name_dwarf_debug_line_dwo)
1934 sect_type = eSectionTypeDWARFDebugLine;
1935 else if (name == g_sect_name_dwarf_debug_macro_dwo)
1936 sect_type = eSectionTypeDWARFDebugMacro;
1937 else if (name == g_sect_name_dwarf_debug_loc_dwo)
1938 sect_type = eSectionTypeDWARFDebugLoc;
1939 else if (name == g_sect_name_dwarf_debug_str_dwo)
1940 sect_type = eSectionTypeDWARFDebugStr;
1941 else if (name == g_sect_name_dwarf_debug_str_offsets_dwo)
1942 sect_type = eSectionTypeDWARFDebugStrOffsets;
1943 else if (name == g_sect_name_eh_frame)
1944 sect_type = eSectionTypeEHFrame;
1945 else if (name == g_sect_name_arm_exidx)
1946 sect_type = eSectionTypeARMexidx;
1947 else if (name == g_sect_name_arm_extab)
1948 sect_type = eSectionTypeARMextab;
1949 else if (name == g_sect_name_go_symtab)
1950 sect_type = eSectionTypeGoSymtab;
1952 const uint32_t permissions =
1953 ((header.sh_flags & SHF_ALLOC) ? ePermissionsReadable : 0u) |
1954 ((header.sh_flags & SHF_WRITE) ? ePermissionsWritable : 0u) |
1955 ((header.sh_flags & SHF_EXECINSTR) ? ePermissionsExecutable : 0u);
1956 switch (header.sh_type) {
1958 assert(sect_type == eSectionTypeOther);
1959 sect_type = eSectionTypeELFSymbolTable;
1962 assert(sect_type == eSectionTypeOther);
1963 sect_type = eSectionTypeELFDynamicSymbols;
1967 assert(sect_type == eSectionTypeOther);
1968 sect_type = eSectionTypeELFRelocationEntries;
1971 assert(sect_type == eSectionTypeOther);
1972 sect_type = eSectionTypeELFDynamicLinkInfo;
1976 if (eSectionTypeOther == sect_type) {
1977 // the kalimba toolchain assumes that ELF section names are free-form.
1979 // support linkscripts which (can) give rise to various arbitrarily
1981 // sections being "Code" or "Data".
1982 sect_type = kalimbaSectionType(m_header, header);
1985 const uint32_t target_bytes_size =
1986 (eSectionTypeData == sect_type || eSectionTypeZeroFill == sect_type)
1987 ? m_arch_spec.GetDataByteSize()
1988 : eSectionTypeCode == sect_type ? m_arch_spec.GetCodeByteSize()
1991 elf::elf_xword log2align =
1992 (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign);
1993 SectionSP section_sp(new Section(
1994 GetModule(), // Module to which this section belongs.
1995 this, // ObjectFile to which this section belongs and should read
1996 // section data from.
1997 SectionIndex(I), // Section ID.
1998 name, // Section name.
1999 sect_type, // Section type.
2000 header.sh_addr, // VM address.
2001 vm_size, // VM size in bytes of this section.
2002 header.sh_offset, // Offset of this section in the file.
2003 file_size, // Size of the section as found in the file.
2004 log2align, // Alignment of the section
2005 header.sh_flags, // Flags for this section.
2006 target_bytes_size)); // Number of host bytes per target byte
2008 section_sp->SetPermissions(permissions);
2009 if (is_thread_specific)
2010 section_sp->SetIsThreadSpecific(is_thread_specific);
2011 m_sections_ap->AddSection(section_sp);
2015 if (m_sections_ap.get()) {
2016 if (GetType() == eTypeDebugInfo) {
2017 static const SectionType g_sections[] = {
2018 eSectionTypeDWARFDebugAbbrev, eSectionTypeDWARFDebugAddr,
2019 eSectionTypeDWARFDebugAranges, eSectionTypeDWARFDebugFrame,
2020 eSectionTypeDWARFDebugInfo, eSectionTypeDWARFDebugLine,
2021 eSectionTypeDWARFDebugLoc, eSectionTypeDWARFDebugMacInfo,
2022 eSectionTypeDWARFDebugPubNames, eSectionTypeDWARFDebugPubTypes,
2023 eSectionTypeDWARFDebugRanges, eSectionTypeDWARFDebugStr,
2024 eSectionTypeDWARFDebugStrOffsets, eSectionTypeELFSymbolTable,
2026 SectionList *elf_section_list = m_sections_ap.get();
2027 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]);
2029 SectionType section_type = g_sections[idx];
2030 SectionSP section_sp(
2031 elf_section_list->FindSectionByType(section_type, true));
2033 SectionSP module_section_sp(
2034 unified_section_list.FindSectionByType(section_type, true));
2035 if (module_section_sp)
2036 unified_section_list.ReplaceSection(module_section_sp->GetID(),
2039 unified_section_list.AddSection(section_sp);
2043 unified_section_list = *m_sections_ap;
2048 // Find the arm/aarch64 mapping symbol character in the given symbol name.
2049 // Mapping symbols have the
2050 // form of "$<char>[.<any>]*". Additionally we recognize cases when the mapping
2051 // symbol prefixed by
2052 // an arbitrary string because if a symbol prefix added to each symbol in the
2054 // objcopy then the mapping symbols are also prefixed.
2055 static char FindArmAarch64MappingSymbol(const char *symbol_name) {
2059 const char *dollar_pos = ::strchr(symbol_name, '$');
2060 if (!dollar_pos || dollar_pos[1] == '\0')
2063 if (dollar_pos[2] == '\0' || dollar_pos[2] == '.')
2064 return dollar_pos[1];
2068 #define STO_MIPS_ISA (3 << 6)
2069 #define STO_MICROMIPS (2 << 6)
2070 #define IS_MICROMIPS(ST_OTHER) (((ST_OTHER)&STO_MIPS_ISA) == STO_MICROMIPS)
2073 unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
2074 SectionList *section_list,
2075 const size_t num_symbols,
2076 const DataExtractor &symtab_data,
2077 const DataExtractor &strtab_data) {
2079 lldb::offset_t offset = 0;
2081 static ConstString text_section_name(".text");
2082 static ConstString init_section_name(".init");
2083 static ConstString fini_section_name(".fini");
2084 static ConstString ctors_section_name(".ctors");
2085 static ConstString dtors_section_name(".dtors");
2087 static ConstString data_section_name(".data");
2088 static ConstString rodata_section_name(".rodata");
2089 static ConstString rodata1_section_name(".rodata1");
2090 static ConstString data2_section_name(".data1");
2091 static ConstString bss_section_name(".bss");
2092 static ConstString opd_section_name(".opd"); // For ppc64
2094 // On Android the oatdata and the oatexec symbols in the oat and odex files
2096 // .text section what causes issues with displaying unusable symbol name to
2097 // the user and very
2098 // slow unwinding speed because the instruction emulation based unwind plans
2099 // try to emulate all
2100 // instructions in these symbols. Don't add these symbols to the symbol list
2102 // use for the debugger and they are causing a lot of trouble.
2103 // Filtering can't be restricted to Android because this special object file
2104 // don't contain the
2105 // note section specifying the environment to Android but the custom extension
2107 // makes it highly unlikely that this will collide with anything else.
2108 ConstString file_extension = m_file.GetFileNameExtension();
2109 bool skip_oatdata_oatexec = file_extension == ConstString("oat") ||
2110 file_extension == ConstString("odex");
2113 GetArchitecture(arch);
2114 ModuleSP module_sp(GetModule());
2115 SectionList *module_section_list =
2116 module_sp ? module_sp->GetSectionList() : nullptr;
2118 // Local cache to avoid doing a FindSectionByName for each symbol. The "const
2120 // came from a ConstString object so they can be compared by pointer
2121 std::unordered_map<const char *, lldb::SectionSP> section_name_to_section;
2124 for (i = 0; i < num_symbols; ++i) {
2125 if (symbol.Parse(symtab_data, &offset) == false)
2128 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
2132 // No need to add non-section symbols that have no names
2133 if (symbol.getType() != STT_SECTION &&
2134 (symbol_name == nullptr || symbol_name[0] == '\0'))
2137 // Skipping oatdata and oatexec sections if it is requested. See details
2139 // definition of skip_oatdata_oatexec for the reasons.
2140 if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 ||
2141 ::strcmp(symbol_name, "oatexec") == 0))
2144 SectionSP symbol_section_sp;
2145 SymbolType symbol_type = eSymbolTypeInvalid;
2146 Elf64_Half section_idx = symbol.st_shndx;
2148 switch (section_idx) {
2150 symbol_type = eSymbolTypeAbsolute;
2153 symbol_type = eSymbolTypeUndefined;
2156 symbol_section_sp = section_list->GetSectionAtIndex(section_idx);
2160 // If a symbol is undefined do not process it further even if it has a STT
2162 if (symbol_type != eSymbolTypeUndefined) {
2163 switch (symbol.getType()) {
2166 // The symbol's type is not specified.
2170 // The symbol is associated with a data object, such as a variable,
2172 symbol_type = eSymbolTypeData;
2176 // The symbol is associated with a function or other executable code.
2177 symbol_type = eSymbolTypeCode;
2181 // The symbol is associated with a section. Symbol table entries of
2182 // this type exist primarily for relocation and normally have
2183 // STB_LOCAL binding.
2187 // Conventionally, the symbol's name gives the name of the source
2188 // file associated with the object file. A file symbol has STB_LOCAL
2189 // binding, its section index is SHN_ABS, and it precedes the other
2190 // STB_LOCAL symbols for the file, if it is present.
2191 symbol_type = eSymbolTypeSourceFile;
2195 // The symbol is associated with an indirect function. The actual
2196 // function will be resolved if it is referenced.
2197 symbol_type = eSymbolTypeResolver;
2202 if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) {
2203 if (symbol_section_sp) {
2204 const ConstString §_name = symbol_section_sp->GetName();
2205 if (sect_name == text_section_name || sect_name == init_section_name ||
2206 sect_name == fini_section_name || sect_name == ctors_section_name ||
2207 sect_name == dtors_section_name) {
2208 symbol_type = eSymbolTypeCode;
2209 } else if (sect_name == data_section_name ||
2210 sect_name == data2_section_name ||
2211 sect_name == rodata_section_name ||
2212 sect_name == rodata1_section_name ||
2213 sect_name == bss_section_name) {
2214 symbol_type = eSymbolTypeData;
2219 int64_t symbol_value_offset = 0;
2220 uint32_t additional_flags = 0;
2222 if (arch.IsValid()) {
2223 if (arch.GetMachine() == llvm::Triple::arm) {
2224 if (symbol.getBinding() == STB_LOCAL) {
2225 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
2226 if (symbol_type == eSymbolTypeCode) {
2227 switch (mapping_symbol) {
2229 // $a[.<any>]* - marks an ARM instruction sequence
2230 m_address_class_map[symbol.st_value] = eAddressClassCode;
2234 // $b[.<any>]* - marks a THUMB BL instruction sequence
2235 // $t[.<any>]* - marks a THUMB instruction sequence
2236 m_address_class_map[symbol.st_value] =
2237 eAddressClassCodeAlternateISA;
2240 // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
2241 m_address_class_map[symbol.st_value] = eAddressClassData;
2248 } else if (arch.GetMachine() == llvm::Triple::aarch64) {
2249 if (symbol.getBinding() == STB_LOCAL) {
2250 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
2251 if (symbol_type == eSymbolTypeCode) {
2252 switch (mapping_symbol) {
2254 // $x[.<any>]* - marks an A64 instruction sequence
2255 m_address_class_map[symbol.st_value] = eAddressClassCode;
2258 // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
2259 m_address_class_map[symbol.st_value] = eAddressClassData;
2268 if (arch.GetMachine() == llvm::Triple::arm) {
2269 if (symbol_type == eSymbolTypeCode) {
2270 if (symbol.st_value & 1) {
2271 // Subtracting 1 from the address effectively unsets
2272 // the low order bit, which results in the address
2273 // actually pointing to the beginning of the symbol.
2274 // This delta will be used below in conjunction with
2275 // symbol.st_value to produce the final symbol_value
2276 // that we store in the symtab.
2277 symbol_value_offset = -1;
2278 m_address_class_map[symbol.st_value ^ 1] =
2279 eAddressClassCodeAlternateISA;
2281 // This address is ARM
2282 m_address_class_map[symbol.st_value] = eAddressClassCode;
2289 * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for
2291 * This allows processor to switch between microMIPS and MIPS without any
2293 * for special mode-control register. However, apart from .debug_line,
2295 * the ELF/DWARF sections set the ISA bit (for symbol or section). Use
2297 * flag to check whether the symbol is microMIPS and then set the address
2301 const llvm::Triple::ArchType llvm_arch = arch.GetMachine();
2302 if (llvm_arch == llvm::Triple::mips ||
2303 llvm_arch == llvm::Triple::mipsel ||
2304 llvm_arch == llvm::Triple::mips64 ||
2305 llvm_arch == llvm::Triple::mips64el) {
2306 if (IS_MICROMIPS(symbol.st_other))
2307 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA;
2308 else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) {
2309 symbol.st_value = symbol.st_value & (~1ull);
2310 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA;
2312 if (symbol_type == eSymbolTypeCode)
2313 m_address_class_map[symbol.st_value] = eAddressClassCode;
2314 else if (symbol_type == eSymbolTypeData)
2315 m_address_class_map[symbol.st_value] = eAddressClassData;
2317 m_address_class_map[symbol.st_value] = eAddressClassUnknown;
2322 // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB
2323 // symbols. See above for
2325 uint64_t symbol_value = symbol.st_value + symbol_value_offset;
2327 if (symbol_section_sp == nullptr && section_idx == SHN_ABS &&
2328 symbol.st_size != 0) {
2329 // We don't have a section for a symbol with non-zero size. Create a new
2331 // so the address range covered by the symbol is also covered by the
2332 // module (represented
2333 // through the section list). It is needed so module lookup for the
2334 // addresses covered
2335 // by this symbol will be successfull. This case happens for absolute
2337 ConstString fake_section_name(std::string(".absolute.") + symbol_name);
2339 std::make_shared<Section>(module_sp, this, SHN_ABS, fake_section_name,
2340 eSectionTypeAbsoluteAddress, symbol_value,
2341 symbol.st_size, 0, 0, 0, SHF_ALLOC);
2343 module_section_list->AddSection(symbol_section_sp);
2344 section_list->AddSection(symbol_section_sp);
2347 if (symbol_section_sp &&
2348 CalculateType() != ObjectFile::Type::eTypeObjectFile)
2349 symbol_value -= symbol_section_sp->GetFileAddress();
2351 if (symbol_section_sp && module_section_list &&
2352 module_section_list != section_list) {
2353 const ConstString §_name = symbol_section_sp->GetName();
2354 auto section_it = section_name_to_section.find(sect_name.GetCString());
2355 if (section_it == section_name_to_section.end())
2357 section_name_to_section
2358 .emplace(sect_name.GetCString(),
2359 module_section_list->FindSectionByName(sect_name))
2361 if (section_it->second)
2362 symbol_section_sp = section_it->second;
2365 bool is_global = symbol.getBinding() == STB_GLOBAL;
2366 uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags;
2367 bool is_mangled = (symbol_name[0] == '_' && symbol_name[1] == 'Z');
2369 llvm::StringRef symbol_ref(symbol_name);
2371 // Symbol names may contain @VERSION suffixes. Find those and strip them
2373 size_t version_pos = symbol_ref.find('@');
2374 bool has_suffix = version_pos != llvm::StringRef::npos;
2375 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
2376 Mangled mangled(ConstString(symbol_bare), is_mangled);
2378 // Now append the suffix back to mangled and unmangled names. Only do it if
2380 // demangling was successful (string is not empty).
2382 llvm::StringRef suffix = symbol_ref.substr(version_pos);
2384 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef();
2385 if (!mangled_name.empty())
2386 mangled.SetMangledName(ConstString((mangled_name + suffix).str()));
2388 ConstString demangled =
2389 mangled.GetDemangledName(lldb::eLanguageTypeUnknown);
2390 llvm::StringRef demangled_name = demangled.GetStringRef();
2391 if (!demangled_name.empty())
2392 mangled.SetDemangledName(ConstString((demangled_name + suffix).str()));
2395 // In ELF all symbol should have a valid size but it is not true for some
2397 // coming from hand written assembly. As none of the function symbol should
2399 // try to calculate the size for these symbols in the symtab with saying
2400 // that their original
2401 // size is not valid.
2402 bool symbol_size_valid =
2403 symbol.st_size != 0 || symbol.getType() != STT_FUNC;
2406 i + start_id, // ID is the original symbol table index.
2408 symbol_type, // Type of this symbol
2409 is_global, // Is this globally visible?
2410 false, // Is this symbol debug info?
2411 false, // Is this symbol a trampoline?
2412 false, // Is this symbol artificial?
2413 AddressRange(symbol_section_sp, // Section in which this symbol is
2415 symbol_value, // Offset in section or symbol value.
2416 symbol.st_size), // Size in bytes of this symbol.
2417 symbol_size_valid, // Symbol size is valid
2418 has_suffix, // Contains linker annotations?
2419 flags); // Symbol flags.
2420 symtab->AddSymbol(dc_symbol);
2425 unsigned ObjectFileELF::ParseSymbolTable(Symtab *symbol_table,
2427 lldb_private::Section *symtab) {
2428 if (symtab->GetObjectFile() != this) {
2429 // If the symbol table section is owned by a different object file, have it
2432 ObjectFileELF *obj_file_elf =
2433 static_cast<ObjectFileELF *>(symtab->GetObjectFile());
2434 return obj_file_elf->ParseSymbolTable(symbol_table, start_id, symtab);
2437 // Get section list for this object file.
2438 SectionList *section_list = m_sections_ap.get();
2442 user_id_t symtab_id = symtab->GetID();
2443 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
2444 assert(symtab_hdr->sh_type == SHT_SYMTAB ||
2445 symtab_hdr->sh_type == SHT_DYNSYM);
2447 // sh_link: section header index of associated string table.
2448 // Section ID's are ones based.
2449 user_id_t strtab_id = symtab_hdr->sh_link + 1;
2450 Section *strtab = section_list->FindSectionByID(strtab_id).get();
2452 if (symtab && strtab) {
2453 assert(symtab->GetObjectFile() == this);
2454 assert(strtab->GetObjectFile() == this);
2456 DataExtractor symtab_data;
2457 DataExtractor strtab_data;
2458 if (ReadSectionData(symtab, symtab_data) &&
2459 ReadSectionData(strtab, strtab_data)) {
2460 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize;
2462 return ParseSymbols(symbol_table, start_id, section_list, num_symbols,
2463 symtab_data, strtab_data);
2470 size_t ObjectFileELF::ParseDynamicSymbols() {
2471 if (m_dynamic_symbols.size())
2472 return m_dynamic_symbols.size();
2474 SectionList *section_list = GetSectionList();
2478 // Find the SHT_DYNAMIC section.
2480 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
2484 assert(dynsym->GetObjectFile() == this);
2487 DataExtractor dynsym_data;
2488 if (ReadSectionData(dynsym, dynsym_data)) {
2489 const lldb::offset_t section_size = dynsym_data.GetByteSize();
2490 lldb::offset_t cursor = 0;
2492 while (cursor < section_size) {
2493 if (!symbol.Parse(dynsym_data, &cursor))
2496 m_dynamic_symbols.push_back(symbol);
2500 return m_dynamic_symbols.size();
2503 const ELFDynamic *ObjectFileELF::FindDynamicSymbol(unsigned tag) {
2504 if (!ParseDynamicSymbols())
2507 DynamicSymbolCollIter I = m_dynamic_symbols.begin();
2508 DynamicSymbolCollIter E = m_dynamic_symbols.end();
2509 for (; I != E; ++I) {
2510 ELFDynamic *symbol = &*I;
2512 if (symbol->d_tag == tag)
2519 unsigned ObjectFileELF::PLTRelocationType() {
2521 // This member specifies the type of relocation entry to which the
2522 // procedure linkage table refers. The d_val member holds DT_REL or
2523 // DT_RELA, as appropriate. All relocations in a procedure linkage table
2524 // must use the same relocation.
2525 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL);
2528 return symbol->d_val;
2533 // Returns the size of the normal plt entries and the offset of the first normal
2535 // 0th entry in the plt table is usually a resolution entry which have different
2537 // architectures then the rest of the plt entries.
2538 static std::pair<uint64_t, uint64_t>
2539 GetPltEntrySizeAndOffset(const ELFSectionHeader *rel_hdr,
2540 const ELFSectionHeader *plt_hdr) {
2541 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2543 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16
2545 // So round the entsize up by the alignment if addralign is set.
2546 elf_xword plt_entsize =
2547 plt_hdr->sh_addralign
2548 ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign)
2549 : plt_hdr->sh_entsize;
2551 // Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field incorrectly.
2552 // PLT entries relocation code in general requires multiple instruction and
2553 // should be greater than 4 bytes in most cases. Try to guess correct size
2555 if (plt_entsize <= 4) {
2556 // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the
2558 // entries based on the number of entries and the size of the plt section
2560 // assumption that the size of the 0th entry is at least as big as the size
2562 // entries and it isn't much bigger then that.
2563 if (plt_hdr->sh_addralign)
2564 plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign /
2565 (num_relocations + 1) * plt_hdr->sh_addralign;
2567 plt_entsize = plt_hdr->sh_size / (num_relocations + 1);
2570 elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize;
2572 return std::make_pair(plt_entsize, plt_offset);
2575 static unsigned ParsePLTRelocations(
2576 Symtab *symbol_table, user_id_t start_id, unsigned rel_type,
2577 const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
2578 const ELFSectionHeader *plt_hdr, const ELFSectionHeader *sym_hdr,
2579 const lldb::SectionSP &plt_section_sp, DataExtractor &rel_data,
2580 DataExtractor &symtab_data, DataExtractor &strtab_data) {
2581 ELFRelocation rel(rel_type);
2583 lldb::offset_t offset = 0;
2585 uint64_t plt_offset, plt_entsize;
2586 std::tie(plt_entsize, plt_offset) =
2587 GetPltEntrySizeAndOffset(rel_hdr, plt_hdr);
2588 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2590 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
2591 reloc_info_fn reloc_type;
2592 reloc_info_fn reloc_symbol;
2594 if (hdr->Is32Bit()) {
2595 reloc_type = ELFRelocation::RelocType32;
2596 reloc_symbol = ELFRelocation::RelocSymbol32;
2598 reloc_type = ELFRelocation::RelocType64;
2599 reloc_symbol = ELFRelocation::RelocSymbol64;
2602 unsigned slot_type = hdr->GetRelocationJumpSlotType();
2604 for (i = 0; i < num_relocations; ++i) {
2605 if (rel.Parse(rel_data, &offset) == false)
2608 if (reloc_type(rel) != slot_type)
2611 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize;
2612 if (!symbol.Parse(symtab_data, &symbol_offset))
2615 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
2617 symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false;
2618 uint64_t plt_index = plt_offset + i * plt_entsize;
2621 i + start_id, // Symbol table index
2622 symbol_name, // symbol name.
2623 is_mangled, // is the symbol name mangled?
2624 eSymbolTypeTrampoline, // Type of this symbol
2625 false, // Is this globally visible?
2626 false, // Is this symbol debug info?
2627 true, // Is this symbol a trampoline?
2628 true, // Is this symbol artificial?
2629 plt_section_sp, // Section in which this symbol is defined or null.
2630 plt_index, // Offset in section or symbol value.
2631 plt_entsize, // Size in bytes of this symbol.
2632 true, // Size is valid
2633 false, // Contains linker annotations?
2634 0); // Symbol flags.
2636 symbol_table->AddSymbol(jump_symbol);
2643 ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, user_id_t start_id,
2644 const ELFSectionHeaderInfo *rel_hdr,
2646 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL);
2648 // The link field points to the associated symbol table.
2649 user_id_t symtab_id = rel_hdr->sh_link;
2651 // If the link field doesn't point to the appropriate symbol name table then
2652 // try to find it by name as some compiler don't fill in the link fields.
2654 symtab_id = GetSectionIndexByName(".dynsym");
2656 // Get PLT section. We cannot use rel_hdr->sh_info, since current linkers
2657 // point that to the .got.plt or .got section instead of .plt.
2658 user_id_t plt_id = GetSectionIndexByName(".plt");
2660 if (!symtab_id || !plt_id)
2663 // Section ID's are ones based;
2667 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id);
2671 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id);
2675 SectionList *section_list = m_sections_ap.get();
2679 Section *rel_section = section_list->FindSectionByID(rel_id).get();
2683 SectionSP plt_section_sp(section_list->FindSectionByID(plt_id));
2684 if (!plt_section_sp)
2687 Section *symtab = section_list->FindSectionByID(symtab_id).get();
2691 // sh_link points to associated string table.
2692 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get();
2696 DataExtractor rel_data;
2697 if (!ReadSectionData(rel_section, rel_data))
2700 DataExtractor symtab_data;
2701 if (!ReadSectionData(symtab, symtab_data))
2704 DataExtractor strtab_data;
2705 if (!ReadSectionData(strtab, strtab_data))
2708 unsigned rel_type = PLTRelocationType();
2712 return ParsePLTRelocations(symbol_table, start_id, rel_type, &m_header,
2713 rel_hdr, plt_hdr, sym_hdr, plt_section_sp,
2714 rel_data, symtab_data, strtab_data);
2717 unsigned ObjectFileELF::RelocateSection(
2718 Symtab *symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
2719 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr,
2720 DataExtractor &rel_data, DataExtractor &symtab_data,
2721 DataExtractor &debug_data, Section *rel_section) {
2722 ELFRelocation rel(rel_hdr->sh_type);
2723 lldb::addr_t offset = 0;
2724 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2725 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
2726 reloc_info_fn reloc_type;
2727 reloc_info_fn reloc_symbol;
2729 if (hdr->Is32Bit()) {
2730 reloc_type = ELFRelocation::RelocType32;
2731 reloc_symbol = ELFRelocation::RelocSymbol32;
2733 reloc_type = ELFRelocation::RelocType64;
2734 reloc_symbol = ELFRelocation::RelocSymbol64;
2737 for (unsigned i = 0; i < num_relocations; ++i) {
2738 if (rel.Parse(rel_data, &offset) == false)
2741 Symbol *symbol = NULL;
2743 if (hdr->Is32Bit()) {
2744 switch (reloc_type(rel)) {
2748 assert(false && "unexpected relocation type");
2751 switch (reloc_type(rel)) {
2753 symbol = symtab->FindSymbolByID(reloc_symbol(rel));
2755 addr_t value = symbol->GetAddressRef().GetFileAddress();
2756 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2757 uint64_t *dst = reinterpret_cast<uint64_t *>(
2758 data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
2759 ELFRelocation::RelocOffset64(rel));
2760 *dst = value + ELFRelocation::RelocAddend64(rel);
2765 case R_X86_64_32S: {
2766 symbol = symtab->FindSymbolByID(reloc_symbol(rel));
2768 addr_t value = symbol->GetAddressRef().GetFileAddress();
2769 value += ELFRelocation::RelocAddend32(rel);
2771 (reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) ||
2772 (reloc_type(rel) == R_X86_64_32S &&
2773 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN)));
2774 uint32_t truncated_addr = (value & 0xFFFFFFFF);
2775 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2776 uint32_t *dst = reinterpret_cast<uint32_t *>(
2777 data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
2778 ELFRelocation::RelocOffset32(rel));
2779 *dst = truncated_addr;
2785 assert(false && "unexpected relocation type");
2793 unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr,
2795 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL);
2797 // Parse in the section list if needed.
2798 SectionList *section_list = GetSectionList();
2802 // Section ID's are ones based.
2803 user_id_t symtab_id = rel_hdr->sh_link + 1;
2804 user_id_t debug_id = rel_hdr->sh_info + 1;
2806 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
2810 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id);
2814 Section *rel = section_list->FindSectionByID(rel_id).get();
2818 Section *symtab = section_list->FindSectionByID(symtab_id).get();
2822 Section *debug = section_list->FindSectionByID(debug_id).get();
2826 DataExtractor rel_data;
2827 DataExtractor symtab_data;
2828 DataExtractor debug_data;
2830 if (ReadSectionData(rel, rel_data) && ReadSectionData(symtab, symtab_data) &&
2831 ReadSectionData(debug, debug_data)) {
2832 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr,
2833 debug_hdr, rel_data, symtab_data, debug_data, debug);
2839 Symtab *ObjectFileELF::GetSymtab() {
2840 ModuleSP module_sp(GetModule());
2844 // We always want to use the main object file so we (hopefully) only have one
2846 // of our symtab, dynamic sections, etc.
2847 ObjectFile *module_obj_file = module_sp->GetObjectFile();
2848 if (module_obj_file && module_obj_file != this)
2849 return module_obj_file->GetSymtab();
2851 if (m_symtab_ap.get() == NULL) {
2852 SectionList *section_list = module_sp->GetSectionList();
2856 uint64_t symbol_id = 0;
2857 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
2859 // Sharable objects and dynamic executables usually have 2 distinct symbol
2860 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
2862 // version of the symtab that only contains global symbols. The information
2864 // in the dynsym is therefore also found in the symtab, while the reverse is
2866 // necessarily true.
2868 section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get();
2870 // The symtab section is non-allocable and can be stripped, so if it
2872 // then use the dynsym section which should always be there.
2874 section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true)
2878 m_symtab_ap.reset(new Symtab(symtab->GetObjectFile()));
2879 symbol_id += ParseSymbolTable(m_symtab_ap.get(), symbol_id, symtab);
2883 // If present, this entry's d_ptr member holds the address of
2885 // entries associated solely with the procedure linkage table.
2887 // these relocation entries lets the dynamic linker ignore them during
2888 // process initialization, if lazy binding is enabled. If this entry is
2889 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must
2891 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL);
2893 // Synthesize trampoline symbols to help navigate the PLT.
2894 addr_t addr = symbol->d_ptr;
2895 Section *reloc_section =
2896 section_list->FindSectionContainingFileAddress(addr).get();
2897 if (reloc_section) {
2898 user_id_t reloc_id = reloc_section->GetID();
2899 const ELFSectionHeaderInfo *reloc_header =
2900 GetSectionHeaderByIndex(reloc_id);
2901 assert(reloc_header);
2903 if (m_symtab_ap == nullptr)
2904 m_symtab_ap.reset(new Symtab(reloc_section->GetObjectFile()));
2906 ParseTrampolineSymbols(m_symtab_ap.get(), symbol_id, reloc_header,
2911 DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo();
2913 if (m_symtab_ap == nullptr)
2914 m_symtab_ap.reset(new Symtab(this));
2915 ParseUnwindSymbols(m_symtab_ap.get(), eh_frame);
2918 // If we still don't have any symtab then create an empty instance to avoid
2920 // lookup next time.
2921 if (m_symtab_ap == nullptr)
2922 m_symtab_ap.reset(new Symtab(this));
2924 m_symtab_ap->CalculateSymbolSizes();
2927 for (SectionHeaderCollIter I = m_section_headers.begin();
2928 I != m_section_headers.end(); ++I) {
2929 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) {
2930 if (CalculateType() == eTypeObjectFile) {
2931 const char *section_name = I->section_name.AsCString("");
2932 if (strstr(section_name, ".rela.debug") ||
2933 strstr(section_name, ".rel.debug")) {
2934 const ELFSectionHeader &reloc_header = *I;
2935 user_id_t reloc_id = SectionIndex(I);
2936 RelocateDebugSections(&reloc_header, reloc_id);
2941 return m_symtab_ap.get();
2944 void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table,
2945 DWARFCallFrameInfo *eh_frame) {
2946 SectionList *section_list = GetSectionList();
2950 // First we save the new symbols into a separate list and add them to the
2951 // symbol table after
2952 // we colleced all symbols we want to add. This is neccessary because adding a
2954 // invalidates the internal index of the symtab what causing the next lookup
2955 // to be slow because
2956 // it have to recalculate the index first.
2957 std::vector<Symbol> new_symbols;
2959 eh_frame->ForEachFDEEntries([this, symbol_table, section_list, &new_symbols](
2960 lldb::addr_t file_addr, uint32_t size, dw_offset_t) {
2961 Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr);
2963 if (!symbol->GetByteSizeIsValid()) {
2964 symbol->SetByteSize(size);
2965 symbol->SetSizeIsSynthesized(true);
2968 SectionSP section_sp =
2969 section_list->FindSectionContainingFileAddress(file_addr);
2971 addr_t offset = file_addr - section_sp->GetFileAddress();
2972 const char *symbol_name = GetNextSyntheticSymbolName().GetCString();
2973 uint64_t symbol_id = symbol_table->GetNumSymbols();
2975 symbol_id, // Symbol table index.
2976 symbol_name, // Symbol name.
2977 false, // Is the symbol name mangled?
2978 eSymbolTypeCode, // Type of this symbol.
2979 true, // Is this globally visible?
2980 false, // Is this symbol debug info?
2981 false, // Is this symbol a trampoline?
2982 true, // Is this symbol artificial?
2983 section_sp, // Section in which this symbol is defined or null.
2984 offset, // Offset in section or symbol value.
2985 0, // Size: Don't specify the size as an FDE can
2986 false, // Size is valid: cover multiple symbols.
2987 false, // Contains linker annotations?
2988 0); // Symbol flags.
2989 new_symbols.push_back(eh_symbol);
2995 for (const Symbol &s : new_symbols)
2996 symbol_table->AddSymbol(s);
2999 bool ObjectFileELF::IsStripped() {
3000 // TODO: determine this for ELF
3004 //===----------------------------------------------------------------------===//
3007 // Dump the specifics of the runtime file container (such as any headers
3008 // segments, sections, etc).
3009 //----------------------------------------------------------------------
3010 void ObjectFileELF::Dump(Stream *s) {
3011 ModuleSP module_sp(GetModule());
3016 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
3017 s->Printf("%p: ", static_cast<void *>(this));
3019 s->PutCString("ObjectFileELF");
3021 ArchSpec header_arch;
3022 GetArchitecture(header_arch);
3024 *s << ", file = '" << m_file
3025 << "', arch = " << header_arch.GetArchitectureName() << "\n";
3027 DumpELFHeader(s, m_header);
3029 DumpELFProgramHeaders(s);
3031 DumpELFSectionHeaders(s);
3033 SectionList *section_list = GetSectionList();
3035 section_list->Dump(s, NULL, true, UINT32_MAX);
3036 Symtab *symtab = GetSymtab();
3038 symtab->Dump(s, NULL, eSortOrderNone);
3040 DumpDependentModules(s);
3044 //----------------------------------------------------------------------
3047 // Dump the ELF header to the specified output stream
3048 //----------------------------------------------------------------------
3049 void ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) {
3050 s->PutCString("ELF Header\n");
3051 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]);
3052 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG1],
3053 header.e_ident[EI_MAG1]);
3054 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG2],
3055 header.e_ident[EI_MAG2]);
3056 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG3],
3057 header.e_ident[EI_MAG3]);
3059 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]);
3060 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]);
3061 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]);
3062 s->Printf("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]);
3063 s->Printf("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]);
3065 s->Printf("e_type = 0x%4.4x ", header.e_type);
3066 DumpELFHeader_e_type(s, header.e_type);
3067 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine);
3068 s->Printf("e_version = 0x%8.8x\n", header.e_version);
3069 s->Printf("e_entry = 0x%8.8" PRIx64 "\n", header.e_entry);
3070 s->Printf("e_phoff = 0x%8.8" PRIx64 "\n", header.e_phoff);
3071 s->Printf("e_shoff = 0x%8.8" PRIx64 "\n", header.e_shoff);
3072 s->Printf("e_flags = 0x%8.8x\n", header.e_flags);
3073 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize);
3074 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize);
3075 s->Printf("e_phnum = 0x%8.8x\n", header.e_phnum);
3076 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize);
3077 s->Printf("e_shnum = 0x%8.8x\n", header.e_shnum);
3078 s->Printf("e_shstrndx = 0x%8.8x\n", header.e_shstrndx);
3081 //----------------------------------------------------------------------
3082 // DumpELFHeader_e_type
3084 // Dump an token value for the ELF header member e_type
3085 //----------------------------------------------------------------------
3086 void ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) {
3108 //----------------------------------------------------------------------
3109 // DumpELFHeader_e_ident_EI_DATA
3111 // Dump an token value for the ELF header member e_ident[EI_DATA]
3112 //----------------------------------------------------------------------
3113 void ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s,
3114 unsigned char ei_data) {
3117 *s << "ELFDATANONE";
3120 *s << "ELFDATA2LSB - Little Endian";
3123 *s << "ELFDATA2MSB - Big Endian";
3130 //----------------------------------------------------------------------
3131 // DumpELFProgramHeader
3133 // Dump a single ELF program header to the specified output stream
3134 //----------------------------------------------------------------------
3135 void ObjectFileELF::DumpELFProgramHeader(Stream *s,
3136 const ELFProgramHeader &ph) {
3137 DumpELFProgramHeader_p_type(s, ph.p_type);
3138 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, ph.p_offset,
3139 ph.p_vaddr, ph.p_paddr);
3140 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64 " %8.8x (", ph.p_filesz, ph.p_memsz,
3143 DumpELFProgramHeader_p_flags(s, ph.p_flags);
3144 s->Printf(") %8.8" PRIx64, ph.p_align);
3147 //----------------------------------------------------------------------
3148 // DumpELFProgramHeader_p_type
3150 // Dump an token value for the ELF program header member p_type which
3151 // describes the type of the program header
3152 // ----------------------------------------------------------------------
3153 void ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) {
3154 const int kStrWidth = 15;
3156 CASE_AND_STREAM(s, PT_NULL, kStrWidth);
3157 CASE_AND_STREAM(s, PT_LOAD, kStrWidth);
3158 CASE_AND_STREAM(s, PT_DYNAMIC, kStrWidth);
3159 CASE_AND_STREAM(s, PT_INTERP, kStrWidth);
3160 CASE_AND_STREAM(s, PT_NOTE, kStrWidth);
3161 CASE_AND_STREAM(s, PT_SHLIB, kStrWidth);
3162 CASE_AND_STREAM(s, PT_PHDR, kStrWidth);
3163 CASE_AND_STREAM(s, PT_TLS, kStrWidth);
3164 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth);
3166 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, "");
3171 //----------------------------------------------------------------------
3172 // DumpELFProgramHeader_p_flags
3174 // Dump an token value for the ELF program header member p_flags
3175 //----------------------------------------------------------------------
3176 void ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) {
3177 *s << ((p_flags & PF_X) ? "PF_X" : " ")
3178 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ')
3179 << ((p_flags & PF_W) ? "PF_W" : " ")
3180 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ')
3181 << ((p_flags & PF_R) ? "PF_R" : " ");
3184 //----------------------------------------------------------------------
3185 // DumpELFProgramHeaders
3187 // Dump all of the ELF program header to the specified output stream
3188 //----------------------------------------------------------------------
3189 void ObjectFileELF::DumpELFProgramHeaders(Stream *s) {
3190 if (!ParseProgramHeaders())
3193 s->PutCString("Program Headers\n");
3194 s->PutCString("IDX p_type p_offset p_vaddr p_paddr "
3195 "p_filesz p_memsz p_flags p_align\n");
3196 s->PutCString("==== --------------- -------- -------- -------- "
3197 "-------- -------- ------------------------- --------\n");
3200 for (ProgramHeaderCollConstIter I = m_program_headers.begin();
3201 I != m_program_headers.end(); ++I, ++idx) {
3202 s->Printf("[%2u] ", idx);
3203 ObjectFileELF::DumpELFProgramHeader(s, *I);
3208 //----------------------------------------------------------------------
3209 // DumpELFSectionHeader
3211 // Dump a single ELF section header to the specified output stream
3212 //----------------------------------------------------------------------
3213 void ObjectFileELF::DumpELFSectionHeader(Stream *s,
3214 const ELFSectionHeaderInfo &sh) {
3215 s->Printf("%8.8x ", sh.sh_name);
3216 DumpELFSectionHeader_sh_type(s, sh.sh_type);
3217 s->Printf(" %8.8" PRIx64 " (", sh.sh_flags);
3218 DumpELFSectionHeader_sh_flags(s, sh.sh_flags);
3219 s->Printf(") %8.8" PRIx64 " %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addr,
3220 sh.sh_offset, sh.sh_size);
3221 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info);
3222 s->Printf(" %8.8" PRIx64 " %8.8" PRIx64, sh.sh_addralign, sh.sh_entsize);
3225 //----------------------------------------------------------------------
3226 // DumpELFSectionHeader_sh_type
3228 // Dump an token value for the ELF section header member sh_type which
3229 // describes the type of the section
3230 //----------------------------------------------------------------------
3231 void ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) {
3232 const int kStrWidth = 12;
3234 CASE_AND_STREAM(s, SHT_NULL, kStrWidth);
3235 CASE_AND_STREAM(s, SHT_PROGBITS, kStrWidth);
3236 CASE_AND_STREAM(s, SHT_SYMTAB, kStrWidth);
3237 CASE_AND_STREAM(s, SHT_STRTAB, kStrWidth);
3238 CASE_AND_STREAM(s, SHT_RELA, kStrWidth);
3239 CASE_AND_STREAM(s, SHT_HASH, kStrWidth);
3240 CASE_AND_STREAM(s, SHT_DYNAMIC, kStrWidth);
3241 CASE_AND_STREAM(s, SHT_NOTE, kStrWidth);
3242 CASE_AND_STREAM(s, SHT_NOBITS, kStrWidth);
3243 CASE_AND_STREAM(s, SHT_REL, kStrWidth);
3244 CASE_AND_STREAM(s, SHT_SHLIB, kStrWidth);
3245 CASE_AND_STREAM(s, SHT_DYNSYM, kStrWidth);
3246 CASE_AND_STREAM(s, SHT_LOPROC, kStrWidth);
3247 CASE_AND_STREAM(s, SHT_HIPROC, kStrWidth);
3248 CASE_AND_STREAM(s, SHT_LOUSER, kStrWidth);
3249 CASE_AND_STREAM(s, SHT_HIUSER, kStrWidth);
3251 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, "");
3256 //----------------------------------------------------------------------
3257 // DumpELFSectionHeader_sh_flags
3259 // Dump an token value for the ELF section header member sh_flags
3260 //----------------------------------------------------------------------
3261 void ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s,
3262 elf_xword sh_flags) {
3263 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ")
3264 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ')
3265 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ")
3266 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ')
3267 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " ");
3270 //----------------------------------------------------------------------
3271 // DumpELFSectionHeaders
3273 // Dump all of the ELF section header to the specified output stream
3274 //----------------------------------------------------------------------
3275 void ObjectFileELF::DumpELFSectionHeaders(Stream *s) {
3276 if (!ParseSectionHeaders())
3279 s->PutCString("Section Headers\n");
3280 s->PutCString("IDX name type flags "
3281 "addr offset size link info addralgn "
3283 s->PutCString("==== -------- ------------ -------------------------------- "
3284 "-------- -------- -------- -------- -------- -------- "
3285 "-------- ====================\n");
3288 for (SectionHeaderCollConstIter I = m_section_headers.begin();
3289 I != m_section_headers.end(); ++I, ++idx) {
3290 s->Printf("[%2u] ", idx);
3291 ObjectFileELF::DumpELFSectionHeader(s, *I);
3292 const char *section_name = I->section_name.AsCString("");
3294 *s << ' ' << section_name << "\n";
3298 void ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) {
3299 size_t num_modules = ParseDependentModules();
3301 if (num_modules > 0) {
3302 s->PutCString("Dependent Modules:\n");
3303 for (unsigned i = 0; i < num_modules; ++i) {
3304 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i);
3305 s->Printf(" %s\n", spec.GetFilename().GetCString());
3310 bool ObjectFileELF::GetArchitecture(ArchSpec &arch) {
3314 if (m_section_headers.empty()) {
3315 // Allow elf notes to be parsed which may affect the detected architecture.
3316 ParseSectionHeaders();
3319 if (CalculateType() == eTypeCoreFile &&
3320 m_arch_spec.TripleOSIsUnspecifiedUnknown()) {
3321 // Core files don't have section headers yet they have PT_NOTE program
3323 // that might shed more light on the architecture
3324 if (ParseProgramHeaders()) {
3325 for (size_t i = 1, count = GetProgramHeaderCount(); i <= count; ++i) {
3326 const elf::ELFProgramHeader *header = GetProgramHeaderByIndex(i);
3327 if (header && header->p_type == PT_NOTE && header->p_offset != 0 &&
3328 header->p_filesz > 0) {
3330 if (data.SetData(m_data, header->p_offset, header->p_filesz) ==
3332 lldb_private::UUID uuid;
3333 RefineModuleDetailsFromNote(data, m_arch_spec, uuid);
3343 ObjectFile::Type ObjectFileELF::CalculateType() {
3344 switch (m_header.e_type) {
3345 case llvm::ELF::ET_NONE:
3347 return eTypeUnknown;
3349 case llvm::ELF::ET_REL:
3350 // 1 - Relocatable file
3351 return eTypeObjectFile;
3353 case llvm::ELF::ET_EXEC:
3354 // 2 - Executable file
3355 return eTypeExecutable;
3357 case llvm::ELF::ET_DYN:
3358 // 3 - Shared object file
3359 return eTypeSharedLibrary;
3363 return eTypeCoreFile;
3368 return eTypeUnknown;
3371 ObjectFile::Strata ObjectFileELF::CalculateStrata() {
3372 switch (m_header.e_type) {
3373 case llvm::ELF::ET_NONE:
3375 return eStrataUnknown;
3377 case llvm::ELF::ET_REL:
3378 // 1 - Relocatable file
3379 return eStrataUnknown;
3381 case llvm::ELF::ET_EXEC:
3382 // 2 - Executable file
3383 // TODO: is there any way to detect that an executable is a kernel
3384 // related executable by inspecting the program headers, section
3385 // headers, symbols, or any other flag bits???
3388 case llvm::ELF::ET_DYN:
3389 // 3 - Shared object file
3390 // TODO: is there any way to detect that an shared library is a kernel
3391 // related executable by inspecting the program headers, section
3392 // headers, symbols, or any other flag bits???
3393 return eStrataUnknown;
3397 // TODO: is there any way to detect that an core file is a kernel
3398 // related executable by inspecting the program headers, section
3399 // headers, symbols, or any other flag bits???
3400 return eStrataUnknown;
3405 return eStrataUnknown;