Bug Summary

File:tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
Warning:line 161, column 1
Potential memory leak

Annotated Source Code

1//===-- ObjectFileELF.cpp ------------------------------------- -*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "ObjectFileELF.h"
11
12#include <algorithm>
13#include <cassert>
14#include <unordered_map>
15
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/Error.h"
29#include "lldb/Utility/Log.h"
30#include "lldb/Utility/Stream.h"
31
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"
38
39#define CASE_AND_STREAM(s, def, width)case def: s->Printf("%-*s", width, "def"); break; \
40 case def: \
41 s->Printf("%-*s", width, #def); \
42 break;
43
44using namespace lldb;
45using namespace lldb_private;
46using namespace elf;
47using namespace llvm::ELF;
48
49namespace {
50
51// ELF note owner definitions
52const char *const LLDB_NT_OWNER_FREEBSD = "FreeBSD";
53const char *const LLDB_NT_OWNER_GNU = "GNU";
54const char *const LLDB_NT_OWNER_NETBSD = "NetBSD";
55const char *const LLDB_NT_OWNER_CSR = "csr";
56const char *const LLDB_NT_OWNER_ANDROID = "Android";
57const char *const LLDB_NT_OWNER_CORE = "CORE";
58const char *const LLDB_NT_OWNER_LINUX = "LINUX";
59
60// ELF note type definitions
61const elf_word LLDB_NT_FREEBSD_ABI_TAG = 0x01;
62const elf_word LLDB_NT_FREEBSD_ABI_SIZE = 4;
63
64const elf_word LLDB_NT_GNU_ABI_TAG = 0x01;
65const elf_word LLDB_NT_GNU_ABI_SIZE = 16;
66
67const elf_word LLDB_NT_GNU_BUILD_ID_TAG = 0x03;
68
69const elf_word LLDB_NT_NETBSD_ABI_TAG = 0x01;
70const elf_word LLDB_NT_NETBSD_ABI_SIZE = 4;
71
72// GNU ABI note OS constants
73const elf_word LLDB_NT_GNU_ABI_OS_LINUX = 0x00;
74const elf_word LLDB_NT_GNU_ABI_OS_HURD = 0x01;
75const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02;
76
77// LLDB_NT_OWNER_CORE and LLDB_NT_OWNER_LINUX note contants
78#define NT_PRSTATUS1 1
79#define NT_PRFPREG2 2
80#define NT_PRPSINFO3 3
81#define NT_TASKSTRUCT4 4
82#define NT_AUXV6 6
83#define NT_SIGINFO0x53494749 0x53494749
84#define NT_FILE0x46494c45 0x46494c45
85#define NT_PRXFPREG0x46e62b7f 0x46e62b7f
86#define NT_PPC_VMX0x100 0x100
87#define NT_PPC_SPE0x101 0x101
88#define NT_PPC_VSX0x102 0x102
89#define NT_386_TLS0x200 0x200
90#define NT_386_IOPERM0x201 0x201
91#define NT_X86_XSTATE0x202 0x202
92#define NT_S390_HIGH_GPRS0x300 0x300
93#define NT_S390_TIMER0x301 0x301
94#define NT_S390_TODCMP0x302 0x302
95#define NT_S390_TODPREG0x303 0x303
96#define NT_S390_CTRS0x304 0x304
97#define NT_S390_PREFIX0x305 0x305
98#define NT_S390_LAST_BREAK0x306 0x306
99#define NT_S390_SYSTEM_CALL0x307 0x307
100#define NT_S390_TDB0x308 0x308
101#define NT_S390_VXRS_LOW0x309 0x309
102#define NT_S390_VXRS_HIGH0x30a 0x30a
103#define NT_ARM_VFP0x400 0x400
104#define NT_ARM_TLS0x401 0x401
105#define NT_ARM_HW_BREAK0x402 0x402
106#define NT_ARM_HW_WATCH0x403 0x403
107#define NT_ARM_SYSTEM_CALL0x404 0x404
108#define NT_METAG_CBUF0x500 0x500
109#define NT_METAG_RPIPE0x501 0x501
110#define NT_METAG_TLS0x502 0x502
111
112//===----------------------------------------------------------------------===//
113/// @class ELFRelocation
114/// @brief Generic wrapper for ELFRel and ELFRela.
115///
116/// This helper class allows us to parse both ELFRel and ELFRela relocation
117/// entries in a generic manner.
118class ELFRelocation {
119public:
120 /// Constructs an ELFRelocation entry with a personality as given by @p
121 /// type.
122 ///
123 /// @param type Either DT_REL or DT_RELA. Any other value is invalid.
124 ELFRelocation(unsigned type);
125
126 ~ELFRelocation();
127
128 bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);
129
130 static unsigned RelocType32(const ELFRelocation &rel);
131
132 static unsigned RelocType64(const ELFRelocation &rel);
133
134 static unsigned RelocSymbol32(const ELFRelocation &rel);
135
136 static unsigned RelocSymbol64(const ELFRelocation &rel);
137
138 static unsigned RelocOffset32(const ELFRelocation &rel);
139
140 static unsigned RelocOffset64(const ELFRelocation &rel);
141
142 static unsigned RelocAddend32(const ELFRelocation &rel);
143
144 static unsigned RelocAddend64(const ELFRelocation &rel);
145
146private:
147 typedef llvm::PointerUnion<ELFRel *, ELFRela *> RelocUnion;
148
149 RelocUnion reloc;
150};
151
152ELFRelocation::ELFRelocation(unsigned type) {
153 if (type == DT_REL || type == SHT_REL)
2
Assuming 'type' is not equal to DT_REL
3
Assuming 'type' is not equal to SHT_REL
4
Taking false branch
154 reloc = new ELFRel();
155 else if (type == DT_RELA || type == SHT_RELA)
5
Assuming 'type' is not equal to DT_RELA
6
Assuming 'type' is equal to SHT_RELA
7
Taking true branch
156 reloc = new ELFRela();
8
Memory is allocated
157 else {
158 assert(false && "unexpected relocation type")((false && "unexpected relocation type") ? static_cast
<void> (0) : __assert_fail ("false && \"unexpected relocation type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 158, __PRETTY_FUNCTION__))
;
159 reloc = static_cast<ELFRel *>(NULL__null);
160 }
161}
9
Potential memory leak
162
163ELFRelocation::~ELFRelocation() {
164 if (reloc.is<ELFRel *>())
165 delete reloc.get<ELFRel *>();
166 else
167 delete reloc.get<ELFRela *>();
168}
169
170bool ELFRelocation::Parse(const lldb_private::DataExtractor &data,
171 lldb::offset_t *offset) {
172 if (reloc.is<ELFRel *>())
173 return reloc.get<ELFRel *>()->Parse(data, offset);
174 else
175 return reloc.get<ELFRela *>()->Parse(data, offset);
176}
177
178unsigned ELFRelocation::RelocType32(const ELFRelocation &rel) {
179 if (rel.reloc.is<ELFRel *>())
180 return ELFRel::RelocType32(*rel.reloc.get<ELFRel *>());
181 else
182 return ELFRela::RelocType32(*rel.reloc.get<ELFRela *>());
183}
184
185unsigned ELFRelocation::RelocType64(const ELFRelocation &rel) {
186 if (rel.reloc.is<ELFRel *>())
187 return ELFRel::RelocType64(*rel.reloc.get<ELFRel *>());
188 else
189 return ELFRela::RelocType64(*rel.reloc.get<ELFRela *>());
190}
191
192unsigned ELFRelocation::RelocSymbol32(const ELFRelocation &rel) {
193 if (rel.reloc.is<ELFRel *>())
194 return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel *>());
195 else
196 return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela *>());
197}
198
199unsigned ELFRelocation::RelocSymbol64(const ELFRelocation &rel) {
200 if (rel.reloc.is<ELFRel *>())
201 return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel *>());
202 else
203 return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela *>());
204}
205
206unsigned ELFRelocation::RelocOffset32(const ELFRelocation &rel) {
207 if (rel.reloc.is<ELFRel *>())
208 return rel.reloc.get<ELFRel *>()->r_offset;
209 else
210 return rel.reloc.get<ELFRela *>()->r_offset;
211}
212
213unsigned ELFRelocation::RelocOffset64(const ELFRelocation &rel) {
214 if (rel.reloc.is<ELFRel *>())
215 return rel.reloc.get<ELFRel *>()->r_offset;
216 else
217 return rel.reloc.get<ELFRela *>()->r_offset;
218}
219
220unsigned ELFRelocation::RelocAddend32(const ELFRelocation &rel) {
221 if (rel.reloc.is<ELFRel *>())
222 return 0;
223 else
224 return rel.reloc.get<ELFRela *>()->r_addend;
225}
226
227unsigned ELFRelocation::RelocAddend64(const ELFRelocation &rel) {
228 if (rel.reloc.is<ELFRel *>())
229 return 0;
230 else
231 return rel.reloc.get<ELFRela *>()->r_addend;
232}
233
234} // end anonymous namespace
235
236bool ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset) {
237 // Read all fields.
238 if (data.GetU32(offset, &n_namesz, 3) == NULL__null)
239 return false;
240
241 // The name field is required to be nul-terminated, and n_namesz
242 // includes the terminating nul in observed implementations (contrary
243 // to the ELF-64 spec). A special case is needed for cores generated
244 // by some older Linux versions, which write a note named "CORE"
245 // without a nul terminator and n_namesz = 4.
246 if (n_namesz == 4) {
247 char buf[4];
248 if (data.ExtractBytes(*offset, 4, data.GetByteOrder(), buf) != 4)
249 return false;
250 if (strncmp(buf, "CORE", 4) == 0) {
251 n_name = "CORE";
252 *offset += 4;
253 return true;
254 }
255 }
256
257 const char *cstr = data.GetCStr(offset, llvm::alignTo(n_namesz, 4));
258 if (cstr == NULL__null) {
259 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS(1u << 20)));
260 if (log)
261 log->Printf("Failed to parse note name lacking nul terminator");
262
263 return false;
264 }
265 n_name = cstr;
266 return true;
267}
268
269static uint32_t kalimbaVariantFromElfFlags(const elf::elf_word e_flags) {
270 const uint32_t dsp_rev = e_flags & 0xFF;
271 uint32_t kal_arch_variant = LLDB_INVALID_CPUTYPE(0xFFFFFFFEu);
272 switch (dsp_rev) {
273 // TODO(mg11) Support more variants
274 case 10:
275 kal_arch_variant = llvm::Triple::KalimbaSubArch_v3;
276 break;
277 case 14:
278 kal_arch_variant = llvm::Triple::KalimbaSubArch_v4;
279 break;
280 case 17:
281 case 20:
282 kal_arch_variant = llvm::Triple::KalimbaSubArch_v5;
283 break;
284 default:
285 break;
286 }
287 return kal_arch_variant;
288}
289
290static uint32_t mipsVariantFromElfFlags(const elf::elf_word e_flags,
291 uint32_t endian) {
292 const uint32_t mips_arch = e_flags & llvm::ELF::EF_MIPS_ARCH;
293 uint32_t arch_variant = ArchSpec::eMIPSSubType_unknown;
294
295 switch (mips_arch) {
296 case llvm::ELF::EF_MIPS_ARCH_1:
297 case llvm::ELF::EF_MIPS_ARCH_2:
298 case llvm::ELF::EF_MIPS_ARCH_32:
299 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
300 : ArchSpec::eMIPSSubType_mips32;
301 case llvm::ELF::EF_MIPS_ARCH_32R2:
302 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r2el
303 : ArchSpec::eMIPSSubType_mips32r2;
304 case llvm::ELF::EF_MIPS_ARCH_32R6:
305 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r6el
306 : ArchSpec::eMIPSSubType_mips32r6;
307 case llvm::ELF::EF_MIPS_ARCH_3:
308 case llvm::ELF::EF_MIPS_ARCH_4:
309 case llvm::ELF::EF_MIPS_ARCH_5:
310 case llvm::ELF::EF_MIPS_ARCH_64:
311 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
312 : ArchSpec::eMIPSSubType_mips64;
313 case llvm::ELF::EF_MIPS_ARCH_64R2:
314 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r2el
315 : ArchSpec::eMIPSSubType_mips64r2;
316 case llvm::ELF::EF_MIPS_ARCH_64R6:
317 return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r6el
318 : ArchSpec::eMIPSSubType_mips64r6;
319 default:
320 break;
321 }
322
323 return arch_variant;
324}
325
326static uint32_t subTypeFromElfHeader(const elf::ELFHeader &header) {
327 if (header.e_machine == llvm::ELF::EM_MIPS)
328 return mipsVariantFromElfFlags(header.e_flags, header.e_ident[EI_DATA]);
329
330 return llvm::ELF::EM_CSR_KALIMBA == header.e_machine
331 ? kalimbaVariantFromElfFlags(header.e_flags)
332 : LLDB_INVALID_CPUTYPE(0xFFFFFFFEu);
333}
334
335//! The kalimba toolchain identifies a code section as being
336//! one with the SHT_PROGBITS set in the section sh_type and the top
337//! bit in the 32-bit address field set.
338static lldb::SectionType
339kalimbaSectionType(const elf::ELFHeader &header,
340 const elf::ELFSectionHeader &sect_hdr) {
341 if (llvm::ELF::EM_CSR_KALIMBA != header.e_machine) {
342 return eSectionTypeOther;
343 }
344
345 if (llvm::ELF::SHT_NOBITS == sect_hdr.sh_type) {
346 return eSectionTypeZeroFill;
347 }
348
349 if (llvm::ELF::SHT_PROGBITS == sect_hdr.sh_type) {
350 const lldb::addr_t KAL_CODE_BIT = 1 << 31;
351 return KAL_CODE_BIT & sect_hdr.sh_addr ? eSectionTypeCode
352 : eSectionTypeData;
353 }
354
355 return eSectionTypeOther;
356}
357
358// Arbitrary constant used as UUID prefix for core files.
359const uint32_t ObjectFileELF::g_core_uuid_magic(0xE210C);
360
361//------------------------------------------------------------------
362// Static methods.
363//------------------------------------------------------------------
364void ObjectFileELF::Initialize() {
365 PluginManager::RegisterPlugin(GetPluginNameStatic(),
366 GetPluginDescriptionStatic(), CreateInstance,
367 CreateMemoryInstance, GetModuleSpecifications);
368}
369
370void ObjectFileELF::Terminate() {
371 PluginManager::UnregisterPlugin(CreateInstance);
372}
373
374lldb_private::ConstString ObjectFileELF::GetPluginNameStatic() {
375 static ConstString g_name("elf");
376 return g_name;
377}
378
379const char *ObjectFileELF::GetPluginDescriptionStatic() {
380 return "ELF object file reader.";
381}
382
383ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp,
384 DataBufferSP &data_sp,
385 lldb::offset_t data_offset,
386 const lldb_private::FileSpec *file,
387 lldb::offset_t file_offset,
388 lldb::offset_t length) {
389 if (!data_sp) {
390 data_sp =
391 DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
392 if (!data_sp)
393 return nullptr;
394 data_offset = 0;
395 }
396
397 assert(data_sp)((data_sp) ? static_cast<void> (0) : __assert_fail ("data_sp"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 397, __PRETTY_FUNCTION__))
;
398
399 if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
400 return nullptr;
401
402 const uint8_t *magic = data_sp->GetBytes() + data_offset;
403 if (!ELFHeader::MagicBytesMatch(magic))
404 return nullptr;
405
406 // Update the data to contain the entire file if it doesn't already
407 if (data_sp->GetByteSize() < length) {
408 data_sp =
409 DataBufferLLVM::CreateSliceFromPath(file->GetPath(), length, file_offset);
410 if (!data_sp)
411 return nullptr;
412 data_offset = 0;
413 magic = data_sp->GetBytes();
414 }
415
416 unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
417 if (address_size == 4 || address_size == 8) {
418 std::unique_ptr<ObjectFileELF> objfile_ap(new ObjectFileELF(
419 module_sp, data_sp, data_offset, file, file_offset, length));
420 ArchSpec spec;
421 if (objfile_ap->GetArchitecture(spec) &&
422 objfile_ap->SetModulesArchitecture(spec))
423 return objfile_ap.release();
424 }
425
426 return NULL__null;
427}
428
429ObjectFile *ObjectFileELF::CreateMemoryInstance(
430 const lldb::ModuleSP &module_sp, DataBufferSP &data_sp,
431 const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
432 if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) {
433 const uint8_t *magic = data_sp->GetBytes();
434 if (ELFHeader::MagicBytesMatch(magic)) {
435 unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
436 if (address_size == 4 || address_size == 8) {
437 std::auto_ptr<ObjectFileELF> objfile_ap(
438 new ObjectFileELF(module_sp, data_sp, process_sp, header_addr));
439 ArchSpec spec;
440 if (objfile_ap->GetArchitecture(spec) &&
441 objfile_ap->SetModulesArchitecture(spec))
442 return objfile_ap.release();
443 }
444 }
445 }
446 return NULL__null;
447}
448
449bool ObjectFileELF::MagicBytesMatch(DataBufferSP &data_sp,
450 lldb::addr_t data_offset,
451 lldb::addr_t data_length) {
452 if (data_sp &&
453 data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
454 const uint8_t *magic = data_sp->GetBytes() + data_offset;
455 return ELFHeader::MagicBytesMatch(magic);
456 }
457 return false;
458}
459
460/*
461 * crc function from http://svnweb.freebsd.org/base/head/sys/libkern/crc32.c
462 *
463 * COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or
464 * code or tables extracted from it, as desired without restriction.
465 */
466static uint32_t calc_crc32(uint32_t crc, const void *buf, size_t size) {
467 static const uint32_t g_crc32_tab[] = {
468 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
469 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
470 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
471 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
472 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
473 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
474 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
475 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
476 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
477 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
478 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
479 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
480 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
481 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
482 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
483 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
484 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
485 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
486 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
487 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
488 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
489 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
490 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
491 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
492 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
493 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
494 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
495 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
496 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
497 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
498 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
499 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
500 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
501 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
502 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
503 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
504 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
505 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
506 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
507 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
508 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
509 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
510 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d};
511 const uint8_t *p = (const uint8_t *)buf;
512
513 crc = crc ^ ~0U;
514 while (size--)
515 crc = g_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
516 return crc ^ ~0U;
517}
518
519static uint32_t calc_gnu_debuglink_crc32(const void *buf, size_t size) {
520 return calc_crc32(0U, buf, size);
521}
522
523uint32_t ObjectFileELF::CalculateELFNotesSegmentsCRC32(
524 const ProgramHeaderColl &program_headers, DataExtractor &object_data) {
525 typedef ProgramHeaderCollConstIter Iter;
526
527 uint32_t core_notes_crc = 0;
528
529 for (Iter I = program_headers.begin(); I != program_headers.end(); ++I) {
530 if (I->p_type == llvm::ELF::PT_NOTE) {
531 const elf_off ph_offset = I->p_offset;
532 const size_t ph_size = I->p_filesz;
533
534 DataExtractor segment_data;
535 if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size) {
536 // The ELF program header contained incorrect data,
537 // probably corefile is incomplete or corrupted.
538 break;
539 }
540
541 core_notes_crc = calc_crc32(core_notes_crc, segment_data.GetDataStart(),
542 segment_data.GetByteSize());
543 }
544 }
545
546 return core_notes_crc;
547}
548
549static const char *OSABIAsCString(unsigned char osabi_byte) {
550#define _MAKE_OSABI_CASE(x) \
551 case x: \
552 return #x
553 switch (osabi_byte) {
554 _MAKE_OSABI_CASE(ELFOSABI_NONE);
555 _MAKE_OSABI_CASE(ELFOSABI_HPUX);
556 _MAKE_OSABI_CASE(ELFOSABI_NETBSD);
557 _MAKE_OSABI_CASE(ELFOSABI_GNU);
558 _MAKE_OSABI_CASE(ELFOSABI_HURD);
559 _MAKE_OSABI_CASE(ELFOSABI_SOLARIS);
560 _MAKE_OSABI_CASE(ELFOSABI_AIX);
561 _MAKE_OSABI_CASE(ELFOSABI_IRIX);
562 _MAKE_OSABI_CASE(ELFOSABI_FREEBSD);
563 _MAKE_OSABI_CASE(ELFOSABI_TRU64);
564 _MAKE_OSABI_CASE(ELFOSABI_MODESTO);
565 _MAKE_OSABI_CASE(ELFOSABI_OPENBSD);
566 _MAKE_OSABI_CASE(ELFOSABI_OPENVMS);
567 _MAKE_OSABI_CASE(ELFOSABI_NSK);
568 _MAKE_OSABI_CASE(ELFOSABI_AROS);
569 _MAKE_OSABI_CASE(ELFOSABI_FENIXOS);
570 _MAKE_OSABI_CASE(ELFOSABI_C6000_ELFABI);
571 _MAKE_OSABI_CASE(ELFOSABI_C6000_LINUX);
572 _MAKE_OSABI_CASE(ELFOSABI_ARM);
573 _MAKE_OSABI_CASE(ELFOSABI_STANDALONE);
574 default:
575 return "<unknown-osabi>";
576 }
577#undef _MAKE_OSABI_CASE
578}
579
580//
581// WARNING : This function is being deprecated
582// It's functionality has moved to ArchSpec::SetArchitecture
583// This function is only being kept to validate the move.
584//
585// TODO : Remove this function
586static bool GetOsFromOSABI(unsigned char osabi_byte,
587 llvm::Triple::OSType &ostype) {
588 switch (osabi_byte) {
589 case ELFOSABI_AIX:
590 ostype = llvm::Triple::OSType::AIX;
591 break;
592 case ELFOSABI_FREEBSD:
593 ostype = llvm::Triple::OSType::FreeBSD;
594 break;
595 case ELFOSABI_GNU:
596 ostype = llvm::Triple::OSType::Linux;
597 break;
598 case ELFOSABI_NETBSD:
599 ostype = llvm::Triple::OSType::NetBSD;
600 break;
601 case ELFOSABI_OPENBSD:
602 ostype = llvm::Triple::OSType::OpenBSD;
603 break;
604 case ELFOSABI_SOLARIS:
605 ostype = llvm::Triple::OSType::Solaris;
606 break;
607 default:
608 ostype = llvm::Triple::OSType::UnknownOS;
609 }
610 return ostype != llvm::Triple::OSType::UnknownOS;
611}
612
613size_t ObjectFileELF::GetModuleSpecifications(
614 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
615 lldb::offset_t data_offset, lldb::offset_t file_offset,
616 lldb::offset_t length, lldb_private::ModuleSpecList &specs) {
617 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES(1u << 21)));
618
619 const size_t initial_count = specs.GetSize();
620
621 if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
622 DataExtractor data;
623 data.SetData(data_sp);
624 elf::ELFHeader header;
625 lldb::offset_t header_offset = data_offset;
626 if (header.Parse(data, &header_offset)) {
627 if (data_sp) {
628 ModuleSpec spec(file);
629
630 const uint32_t sub_type = subTypeFromElfHeader(header);
631 spec.GetArchitecture().SetArchitecture(
632 eArchTypeELF, header.e_machine, sub_type, header.e_ident[EI_OSABI]);
633
634 if (spec.GetArchitecture().IsValid()) {
635 llvm::Triple::OSType ostype;
636 llvm::Triple::VendorType vendor;
637 llvm::Triple::OSType spec_ostype =
638 spec.GetArchitecture().GetTriple().getOS();
639
640 if (log)
641 log->Printf("ObjectFileELF::%s file '%s' module OSABI: %s",
642 __FUNCTION__, file.GetPath().c_str(),
643 OSABIAsCString(header.e_ident[EI_OSABI]));
644
645 // SetArchitecture should have set the vendor to unknown
646 vendor = spec.GetArchitecture().GetTriple().getVendor();
647 assert(vendor == llvm::Triple::UnknownVendor)((vendor == llvm::Triple::UnknownVendor) ? static_cast<void
> (0) : __assert_fail ("vendor == llvm::Triple::UnknownVendor"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 647, __PRETTY_FUNCTION__))
;
648 UNUSED_IF_ASSERT_DISABLED(vendor)((void)(vendor));
649
650 //
651 // Validate it is ok to remove GetOsFromOSABI
652 GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
653 assert(spec_ostype == ostype)((spec_ostype == ostype) ? static_cast<void> (0) : __assert_fail
("spec_ostype == ostype", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 653, __PRETTY_FUNCTION__))
;
654 if (spec_ostype != llvm::Triple::OSType::UnknownOS) {
655 if (log)
656 log->Printf("ObjectFileELF::%s file '%s' set ELF module OS type "
657 "from ELF header OSABI.",
658 __FUNCTION__, file.GetPath().c_str());
659 }
660
661 // In case there is header extension in the section #0, the header
662 // we parsed above could have sentinel values for e_phnum, e_shnum,
663 // and e_shstrndx. In this case we need to reparse the header
664 // with a bigger data source to get the actual values.
665 size_t section_header_end = header.e_shoff + header.e_shentsize;
666 if (header.HasHeaderExtension() &&
667 section_header_end > data_sp->GetByteSize()) {
668 data_sp = DataBufferLLVM::CreateSliceFromPath(
669 file.GetPath(), section_header_end, file_offset);
670 if (data_sp) {
671 data.SetData(data_sp);
672 lldb::offset_t header_offset = data_offset;
673 header.Parse(data, &header_offset);
674 }
675 }
676
677 // Try to get the UUID from the section list. Usually that's at the
678 // end, so map the file in if we don't have it already.
679 section_header_end =
680 header.e_shoff + header.e_shnum * header.e_shentsize;
681 if (section_header_end > data_sp->GetByteSize()) {
682 data_sp = DataBufferLLVM::CreateSliceFromPath(
683 file.GetPath(), section_header_end, file_offset);
684 if (data_sp)
685 data.SetData(data_sp);
686 }
687
688 uint32_t gnu_debuglink_crc = 0;
689 std::string gnu_debuglink_file;
690 SectionHeaderColl section_headers;
691 lldb_private::UUID &uuid = spec.GetUUID();
692
693 using namespace std::placeholders;
694 const SetDataFunction set_data =
695 std::bind(&ObjectFileELF::SetData, std::cref(data), _1, _2, _3);
696 GetSectionHeaderInfo(section_headers, set_data, header, uuid,
697 gnu_debuglink_file, gnu_debuglink_crc,
698 spec.GetArchitecture());
699
700 llvm::Triple &spec_triple = spec.GetArchitecture().GetTriple();
701
702 if (log)
703 log->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
704 "(architecture %s)",
705 __FUNCTION__, file.GetPath().c_str(),
706 spec_triple.getTriple().c_str(),
707 spec.GetArchitecture().GetArchitectureName());
708
709 if (!uuid.IsValid()) {
710 uint32_t core_notes_crc = 0;
711
712 if (!gnu_debuglink_crc) {
713 lldb_private::Timer scoped_timer(
714 LLVM_PRETTY_FUNCTION__PRETTY_FUNCTION__,
715 "Calculating module crc32 %s with size %" PRIu64"l" "u" " KiB",
716 file.GetLastPathComponent().AsCString(),
717 (file.GetByteSize() - file_offset) / 1024);
718
719 // For core files - which usually don't happen to have a
720 // gnu_debuglink, and are pretty bulky - calculating whole
721 // contents crc32 would be too much of luxury. Thus we will need
722 // to fallback to something simpler.
723 if (header.e_type == llvm::ELF::ET_CORE) {
724 size_t program_headers_end =
725 header.e_phoff + header.e_phnum * header.e_phentsize;
726 if (program_headers_end > data_sp->GetByteSize()) {
727 data_sp = DataBufferLLVM::CreateSliceFromPath(
728 file.GetPath(), program_headers_end, file_offset);
729 if (data_sp)
730 data.SetData(data_sp);
731 }
732 ProgramHeaderColl program_headers;
733 GetProgramHeaderInfo(program_headers, set_data, header);
734
735 size_t segment_data_end = 0;
736 for (ProgramHeaderCollConstIter I = program_headers.begin();
737 I != program_headers.end(); ++I) {
738 segment_data_end = std::max<unsigned long long>(
739 I->p_offset + I->p_filesz, segment_data_end);
740 }
741
742 if (segment_data_end > data_sp->GetByteSize()) {
743 data_sp = DataBufferLLVM::CreateSliceFromPath(
744 file.GetPath(), segment_data_end, file_offset);
745 if (data_sp)
746 data.SetData(data_sp);
747 }
748
749 core_notes_crc =
750 CalculateELFNotesSegmentsCRC32(program_headers, data);
751 } else {
752 // Need to map entire file into memory to calculate the crc.
753 data_sp = DataBufferLLVM::CreateSliceFromPath(file.GetPath(), -1,
754 file_offset);
755 if (data_sp) {
756 data.SetData(data_sp);
757 gnu_debuglink_crc = calc_gnu_debuglink_crc32(
758 data.GetDataStart(), data.GetByteSize());
759 }
760 }
761 }
762 if (gnu_debuglink_crc) {
763 // Use 4 bytes of crc from the .gnu_debuglink section.
764 uint32_t uuidt[4] = {gnu_debuglink_crc, 0, 0, 0};
765 uuid.SetBytes(uuidt, sizeof(uuidt));
766 } else if (core_notes_crc) {
767 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make
768 // it look different form
769 // .gnu_debuglink crc followed by 4 bytes of note segments crc.
770 uint32_t uuidt[4] = {g_core_uuid_magic, core_notes_crc, 0, 0};
771 uuid.SetBytes(uuidt, sizeof(uuidt));
772 }
773 }
774
775 specs.Append(spec);
776 }
777 }
778 }
779 }
780
781 return specs.GetSize() - initial_count;
782}
783
784//------------------------------------------------------------------
785// PluginInterface protocol
786//------------------------------------------------------------------
787lldb_private::ConstString ObjectFileELF::GetPluginName() {
788 return GetPluginNameStatic();
789}
790
791uint32_t ObjectFileELF::GetPluginVersion() { return m_plugin_version; }
792//------------------------------------------------------------------
793// ObjectFile protocol
794//------------------------------------------------------------------
795
796ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp,
797 DataBufferSP &data_sp, lldb::offset_t data_offset,
798 const FileSpec *file, lldb::offset_t file_offset,
799 lldb::offset_t length)
800 : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset),
801 m_header(), m_uuid(), m_gnu_debuglink_file(), m_gnu_debuglink_crc(0),
802 m_program_headers(), m_section_headers(), m_dynamic_symbols(),
803 m_filespec_ap(), m_entry_point_address(), m_arch_spec() {
804 if (file)
805 m_file = *file;
806 ::memset(&m_header, 0, sizeof(m_header));
807}
808
809ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp,
810 DataBufferSP &header_data_sp,
811 const lldb::ProcessSP &process_sp,
812 addr_t header_addr)
813 : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
814 m_header(), m_uuid(), m_gnu_debuglink_file(), m_gnu_debuglink_crc(0),
815 m_program_headers(), m_section_headers(), m_dynamic_symbols(),
816 m_filespec_ap(), m_entry_point_address(), m_arch_spec() {
817 ::memset(&m_header, 0, sizeof(m_header));
818}
819
820ObjectFileELF::~ObjectFileELF() {}
821
822bool ObjectFileELF::IsExecutable() const {
823 return ((m_header.e_type & ET_EXEC) != 0) || (m_header.e_entry != 0);
824}
825
826bool ObjectFileELF::SetLoadAddress(Target &target, lldb::addr_t value,
827 bool value_is_offset) {
828 ModuleSP module_sp = GetModule();
829 if (module_sp) {
830 size_t num_loaded_sections = 0;
831 SectionList *section_list = GetSectionList();
832 if (section_list) {
833 if (!value_is_offset) {
834 bool found_offset = false;
835 for (size_t i = 0, count = GetProgramHeaderCount(); i < count; ++i) {
836 const elf::ELFProgramHeader *header = GetProgramHeaderByIndex(i);
837 if (header == nullptr)
838 continue;
839
840 if (header->p_type != PT_LOAD || header->p_offset != 0)
841 continue;
842
843 value = value - header->p_vaddr;
844 found_offset = true;
845 break;
846 }
847 if (!found_offset)
848 return false;
849 }
850
851 const size_t num_sections = section_list->GetSize();
852 size_t sect_idx = 0;
853
854 for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
855 // Iterate through the object file sections to find all
856 // of the sections that have SHF_ALLOC in their flag bits.
857 SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
858 if (section_sp && section_sp->Test(SHF_ALLOC)) {
859 lldb::addr_t load_addr = section_sp->GetFileAddress();
860 // We don't want to update the load address of a section with type
861 // eSectionTypeAbsoluteAddress as they already have the absolute load
862 // address
863 // already specified
864 if (section_sp->GetType() != eSectionTypeAbsoluteAddress)
865 load_addr += value;
866
867 // On 32-bit systems the load address have to fit into 4 bytes. The
868 // rest of
869 // the bytes are the overflow from the addition.
870 if (GetAddressByteSize() == 4)
871 load_addr &= 0xFFFFFFFF;
872
873 if (target.GetSectionLoadList().SetSectionLoadAddress(section_sp,
874 load_addr))
875 ++num_loaded_sections;
876 }
877 }
878 return num_loaded_sections > 0;
879 }
880 }
881 return false;
882}
883
884ByteOrder ObjectFileELF::GetByteOrder() const {
885 if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
886 return eByteOrderBig;
887 if (m_header.e_ident[EI_DATA] == ELFDATA2LSB)
888 return eByteOrderLittle;
889 return eByteOrderInvalid;
890}
891
892uint32_t ObjectFileELF::GetAddressByteSize() const {
893 return m_data.GetAddressByteSize();
894}
895
896AddressClass ObjectFileELF::GetAddressClass(addr_t file_addr) {
897 Symtab *symtab = GetSymtab();
898 if (!symtab)
899 return eAddressClassUnknown;
900
901 // The address class is determined based on the symtab. Ask it from the object
902 // file what
903 // contains the symtab information.
904 ObjectFile *symtab_objfile = symtab->GetObjectFile();
905 if (symtab_objfile != nullptr && symtab_objfile != this)
906 return symtab_objfile->GetAddressClass(file_addr);
907
908 auto res = ObjectFile::GetAddressClass(file_addr);
909 if (res != eAddressClassCode)
910 return res;
911
912 auto ub = m_address_class_map.upper_bound(file_addr);
913 if (ub == m_address_class_map.begin()) {
914 // No entry in the address class map before the address. Return
915 // default address class for an address in a code section.
916 return eAddressClassCode;
917 }
918
919 // Move iterator to the address class entry preceding address
920 --ub;
921
922 return ub->second;
923}
924
925size_t ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I) {
926 return std::distance(m_section_headers.begin(), I) + 1u;
927}
928
929size_t ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const {
930 return std::distance(m_section_headers.begin(), I) + 1u;
931}
932
933bool ObjectFileELF::ParseHeader() {
934 lldb::offset_t offset = 0;
935 if (!m_header.Parse(m_data, &offset))
936 return false;
937
938 if (!IsInMemory())
939 return true;
940
941 // For in memory object files m_data might not contain the full object file.
942 // Try to load it
943 // until the end of the "Section header table" what is at the end of the ELF
944 // file.
945 addr_t file_size = m_header.e_shoff + m_header.e_shnum * m_header.e_shentsize;
946 if (m_data.GetByteSize() < file_size) {
947 ProcessSP process_sp(m_process_wp.lock());
948 if (!process_sp)
949 return false;
950
951 DataBufferSP data_sp = ReadMemory(process_sp, m_memory_addr, file_size);
952 if (!data_sp)
953 return false;
954 m_data.SetData(data_sp, 0, file_size);
955 }
956
957 return true;
958}
959
960bool ObjectFileELF::GetUUID(lldb_private::UUID *uuid) {
961 // Need to parse the section list to get the UUIDs, so make sure that's been
962 // done.
963 if (!ParseSectionHeaders() && GetType() != ObjectFile::eTypeCoreFile)
964 return false;
965
966 if (m_uuid.IsValid()) {
967 // We have the full build id uuid.
968 *uuid = m_uuid;
969 return true;
970 } else if (GetType() == ObjectFile::eTypeCoreFile) {
971 uint32_t core_notes_crc = 0;
972
973 if (!ParseProgramHeaders())
974 return false;
975
976 core_notes_crc = CalculateELFNotesSegmentsCRC32(m_program_headers, m_data);
977
978 if (core_notes_crc) {
979 // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it
980 // look different form .gnu_debuglink crc - followed by 4 bytes of note
981 // segments crc.
982 uint32_t uuidt[4] = {g_core_uuid_magic, core_notes_crc, 0, 0};
983 m_uuid.SetBytes(uuidt, sizeof(uuidt));
984 }
985 } else {
986 if (!m_gnu_debuglink_crc)
987 m_gnu_debuglink_crc =
988 calc_gnu_debuglink_crc32(m_data.GetDataStart(), m_data.GetByteSize());
989 if (m_gnu_debuglink_crc) {
990 // Use 4 bytes of crc from the .gnu_debuglink section.
991 uint32_t uuidt[4] = {m_gnu_debuglink_crc, 0, 0, 0};
992 m_uuid.SetBytes(uuidt, sizeof(uuidt));
993 }
994 }
995
996 if (m_uuid.IsValid()) {
997 *uuid = m_uuid;
998 return true;
999 }
1000
1001 return false;
1002}
1003
1004lldb_private::FileSpecList ObjectFileELF::GetDebugSymbolFilePaths() {
1005 FileSpecList file_spec_list;
1006
1007 if (!m_gnu_debuglink_file.empty()) {
1008 FileSpec file_spec(m_gnu_debuglink_file, false);
1009 file_spec_list.Append(file_spec);
1010 }
1011 return file_spec_list;
1012}
1013
1014uint32_t ObjectFileELF::GetDependentModules(FileSpecList &files) {
1015 size_t num_modules = ParseDependentModules();
1016 uint32_t num_specs = 0;
1017
1018 for (unsigned i = 0; i < num_modules; ++i) {
1019 if (files.AppendIfUnique(m_filespec_ap->GetFileSpecAtIndex(i)))
1020 num_specs++;
1021 }
1022
1023 return num_specs;
1024}
1025
1026Address ObjectFileELF::GetImageInfoAddress(Target *target) {
1027 if (!ParseDynamicSymbols())
1028 return Address();
1029
1030 SectionList *section_list = GetSectionList();
1031 if (!section_list)
1032 return Address();
1033
1034 // Find the SHT_DYNAMIC (.dynamic) section.
1035 SectionSP dynsym_section_sp(
1036 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true));
1037 if (!dynsym_section_sp)
1038 return Address();
1039 assert(dynsym_section_sp->GetObjectFile() == this)((dynsym_section_sp->GetObjectFile() == this) ? static_cast
<void> (0) : __assert_fail ("dynsym_section_sp->GetObjectFile() == this"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 1039, __PRETTY_FUNCTION__))
;
1040
1041 user_id_t dynsym_id = dynsym_section_sp->GetID();
1042 const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id);
1043 if (!dynsym_hdr)
1044 return Address();
1045
1046 for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) {
1047 ELFDynamic &symbol = m_dynamic_symbols[i];
1048
1049 if (symbol.d_tag == DT_DEBUG) {
1050 // Compute the offset as the number of previous entries plus the
1051 // size of d_tag.
1052 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
1053 return Address(dynsym_section_sp, offset);
1054 }
1055 // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP
1056 // exists in non-PIE.
1057 else if ((symbol.d_tag == DT_MIPS_RLD_MAP ||
1058 symbol.d_tag == DT_MIPS_RLD_MAP_REL) &&
1059 target) {
1060 addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
1061 addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target);
1062 if (dyn_base == LLDB_INVALID_ADDRESS(18446744073709551615UL))
1063 return Address();
1064
1065 Error error;
1066 if (symbol.d_tag == DT_MIPS_RLD_MAP) {
1067 // DT_MIPS_RLD_MAP tag stores an absolute address of the debug pointer.
1068 Address addr;
1069 if (target->ReadPointerFromMemory(dyn_base + offset, false, error,
1070 addr))
1071 return addr;
1072 }
1073 if (symbol.d_tag == DT_MIPS_RLD_MAP_REL) {
1074 // DT_MIPS_RLD_MAP_REL tag stores the offset to the debug pointer,
1075 // relative to the address of the tag.
1076 uint64_t rel_offset;
1077 rel_offset = target->ReadUnsignedIntegerFromMemory(
1078 dyn_base + offset, false, GetAddressByteSize(), UINT64_MAX(18446744073709551615UL), error);
1079 if (error.Success() && rel_offset != UINT64_MAX(18446744073709551615UL)) {
1080 Address addr;
1081 addr_t debug_ptr_address =
1082 dyn_base + (offset - GetAddressByteSize()) + rel_offset;
1083 addr.SetOffset(debug_ptr_address);
1084 return addr;
1085 }
1086 }
1087 }
1088 }
1089
1090 return Address();
1091}
1092
1093lldb_private::Address ObjectFileELF::GetEntryPointAddress() {
1094 if (m_entry_point_address.IsValid())
1095 return m_entry_point_address;
1096
1097 if (!ParseHeader() || !IsExecutable())
1098 return m_entry_point_address;
1099
1100 SectionList *section_list = GetSectionList();
1101 addr_t offset = m_header.e_entry;
1102
1103 if (!section_list)
1104 m_entry_point_address.SetOffset(offset);
1105 else
1106 m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list);
1107 return m_entry_point_address;
1108}
1109
1110//----------------------------------------------------------------------
1111// ParseDependentModules
1112//----------------------------------------------------------------------
1113size_t ObjectFileELF::ParseDependentModules() {
1114 if (m_filespec_ap.get())
1115 return m_filespec_ap->GetSize();
1116
1117 m_filespec_ap.reset(new FileSpecList());
1118
1119 if (!ParseSectionHeaders())
1120 return 0;
1121
1122 SectionList *section_list = GetSectionList();
1123 if (!section_list)
1124 return 0;
1125
1126 // Find the SHT_DYNAMIC section.
1127 Section *dynsym =
1128 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
1129 .get();
1130 if (!dynsym)
1131 return 0;
1132 assert(dynsym->GetObjectFile() == this)((dynsym->GetObjectFile() == this) ? static_cast<void>
(0) : __assert_fail ("dynsym->GetObjectFile() == this", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 1132, __PRETTY_FUNCTION__))
;
1133
1134 const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex(dynsym->GetID());
1135 if (!header)
1136 return 0;
1137 // sh_link: section header index of string table used by entries in the
1138 // section.
1139 Section *dynstr = section_list->FindSectionByID(header->sh_link + 1).get();
1140 if (!dynstr)
1141 return 0;
1142
1143 DataExtractor dynsym_data;
1144 DataExtractor dynstr_data;
1145 if (ReadSectionData(dynsym, dynsym_data) &&
1146 ReadSectionData(dynstr, dynstr_data)) {
1147 ELFDynamic symbol;
1148 const lldb::offset_t section_size = dynsym_data.GetByteSize();
1149 lldb::offset_t offset = 0;
1150
1151 // The only type of entries we are concerned with are tagged DT_NEEDED,
1152 // yielding the name of a required library.
1153 while (offset < section_size) {
1154 if (!symbol.Parse(dynsym_data, &offset))
1155 break;
1156
1157 if (symbol.d_tag != DT_NEEDED)
1158 continue;
1159
1160 uint32_t str_index = static_cast<uint32_t>(symbol.d_val);
1161 const char *lib_name = dynstr_data.PeekCStr(str_index);
1162 m_filespec_ap->Append(FileSpec(lib_name, true));
1163 }
1164 }
1165
1166 return m_filespec_ap->GetSize();
1167}
1168
1169//----------------------------------------------------------------------
1170// GetProgramHeaderInfo
1171//----------------------------------------------------------------------
1172size_t ObjectFileELF::GetProgramHeaderInfo(ProgramHeaderColl &program_headers,
1173 const SetDataFunction &set_data,
1174 const ELFHeader &header) {
1175 // We have already parsed the program headers
1176 if (!program_headers.empty())
1177 return program_headers.size();
1178
1179 // If there are no program headers to read we are done.
1180 if (header.e_phnum == 0)
1181 return 0;
1182
1183 program_headers.resize(header.e_phnum);
1184 if (program_headers.size() != header.e_phnum)
1185 return 0;
1186
1187 const size_t ph_size = header.e_phnum * header.e_phentsize;
1188 const elf_off ph_offset = header.e_phoff;
1189 DataExtractor data;
1190 if (set_data(data, ph_offset, ph_size) != ph_size)
1191 return 0;
1192
1193 uint32_t idx;
1194 lldb::offset_t offset;
1195 for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) {
1196 if (program_headers[idx].Parse(data, &offset) == false)
1197 break;
1198 }
1199
1200 if (idx < program_headers.size())
1201 program_headers.resize(idx);
1202
1203 return program_headers.size();
1204}
1205
1206//----------------------------------------------------------------------
1207// ParseProgramHeaders
1208//----------------------------------------------------------------------
1209size_t ObjectFileELF::ParseProgramHeaders() {
1210 using namespace std::placeholders;
1211 return GetProgramHeaderInfo(
1212 m_program_headers,
1213 std::bind(&ObjectFileELF::SetDataWithReadMemoryFallback, this, _1, _2,
1214 _3),
1215 m_header);
1216}
1217
1218lldb_private::Error
1219ObjectFileELF::RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
1220 lldb_private::ArchSpec &arch_spec,
1221 lldb_private::UUID &uuid) {
1222 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES(1u << 21)));
1223 Error error;
1224
1225 lldb::offset_t offset = 0;
1226
1227 while (true) {
1228 // Parse the note header. If this fails, bail out.
1229 const lldb::offset_t note_offset = offset;
1230 ELFNote note = ELFNote();
1231 if (!note.Parse(data, &offset)) {
1232 // We're done.
1233 return error;
1234 }
1235
1236 if (log)
1237 log->Printf("ObjectFileELF::%s parsing note name='%s', type=%" PRIu32"u",
1238 __FUNCTION__, note.n_name.c_str(), note.n_type);
1239
1240 // Process FreeBSD ELF notes.
1241 if ((note.n_name == LLDB_NT_OWNER_FREEBSD) &&
1242 (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) &&
1243 (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) {
1244 // Pull out the min version info.
1245 uint32_t version_info;
1246 if (data.GetU32(&offset, &version_info, 1) == nullptr) {
1247 error.SetErrorString("failed to read FreeBSD ABI note payload");
1248 return error;
1249 }
1250
1251 // Convert the version info into a major/minor number.
1252 const uint32_t version_major = version_info / 100000;
1253 const uint32_t version_minor = (version_info / 1000) % 100;
1254
1255 char os_name[32];
1256 snprintf(os_name, sizeof(os_name), "freebsd%" PRIu32"u" ".%" PRIu32"u",
1257 version_major, version_minor);
1258
1259 // Set the elf OS version to FreeBSD. Also clear the vendor.
1260 arch_spec.GetTriple().setOSName(os_name);
1261 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1262
1263 if (log)
1264 log->Printf("ObjectFileELF::%s detected FreeBSD %" PRIu32"u" ".%" PRIu32"u"
1265 ".%" PRIu32"u",
1266 __FUNCTION__, version_major, version_minor,
1267 static_cast<uint32_t>(version_info % 1000));
1268 }
1269 // Process GNU ELF notes.
1270 else if (note.n_name == LLDB_NT_OWNER_GNU) {
1271 switch (note.n_type) {
1272 case LLDB_NT_GNU_ABI_TAG:
1273 if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) {
1274 // Pull out the min OS version supporting the ABI.
1275 uint32_t version_info[4];
1276 if (data.GetU32(&offset, &version_info[0], note.n_descsz / 4) ==
1277 nullptr) {
1278 error.SetErrorString("failed to read GNU ABI note payload");
1279 return error;
1280 }
1281
1282 // Set the OS per the OS field.
1283 switch (version_info[0]) {
1284 case LLDB_NT_GNU_ABI_OS_LINUX:
1285 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1286 arch_spec.GetTriple().setVendor(
1287 llvm::Triple::VendorType::UnknownVendor);
1288 if (log)
1289 log->Printf(
1290 "ObjectFileELF::%s detected Linux, min version %" PRIu32"u"
1291 ".%" PRIu32"u" ".%" PRIu32"u",
1292 __FUNCTION__, version_info[1], version_info[2],
1293 version_info[3]);
1294 // FIXME we have the minimal version number, we could be propagating
1295 // that. version_info[1] = OS Major, version_info[2] = OS Minor,
1296 // version_info[3] = Revision.
1297 break;
1298 case LLDB_NT_GNU_ABI_OS_HURD:
1299 arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
1300 arch_spec.GetTriple().setVendor(
1301 llvm::Triple::VendorType::UnknownVendor);
1302 if (log)
1303 log->Printf("ObjectFileELF::%s detected Hurd (unsupported), min "
1304 "version %" PRIu32"u" ".%" PRIu32"u" ".%" PRIu32"u",
1305 __FUNCTION__, version_info[1], version_info[2],
1306 version_info[3]);
1307 break;
1308 case LLDB_NT_GNU_ABI_OS_SOLARIS:
1309 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Solaris);
1310 arch_spec.GetTriple().setVendor(
1311 llvm::Triple::VendorType::UnknownVendor);
1312 if (log)
1313 log->Printf(
1314 "ObjectFileELF::%s detected Solaris, min version %" PRIu32"u"
1315 ".%" PRIu32"u" ".%" PRIu32"u",
1316 __FUNCTION__, version_info[1], version_info[2],
1317 version_info[3]);
1318 break;
1319 default:
1320 if (log)
1321 log->Printf(
1322 "ObjectFileELF::%s unrecognized OS in note, id %" PRIu32"u"
1323 ", min version %" PRIu32"u" ".%" PRIu32"u" ".%" PRIu32"u",
1324 __FUNCTION__, version_info[0], version_info[1],
1325 version_info[2], version_info[3]);
1326 break;
1327 }
1328 }
1329 break;
1330
1331 case LLDB_NT_GNU_BUILD_ID_TAG:
1332 // Only bother processing this if we don't already have the uuid set.
1333 if (!uuid.IsValid()) {
1334 // 16 bytes is UUID|MD5, 20 bytes is SHA1. Other linkers may produce a
1335 // build-id of a different
1336 // length. Accept it as long as it's at least 4 bytes as it will be
1337 // better than our own crc32.
1338 if (note.n_descsz >= 4 && note.n_descsz <= 20) {
1339 uint8_t uuidbuf[20];
1340 if (data.GetU8(&offset, &uuidbuf, note.n_descsz) == nullptr) {
1341 error.SetErrorString("failed to read GNU_BUILD_ID note payload");
1342 return error;
1343 }
1344
1345 // Save the build id as the UUID for the module.
1346 uuid.SetBytes(uuidbuf, note.n_descsz);
1347 }
1348 }
1349 break;
1350 }
1351 }
1352 // Process NetBSD ELF notes.
1353 else if ((note.n_name == LLDB_NT_OWNER_NETBSD) &&
1354 (note.n_type == LLDB_NT_NETBSD_ABI_TAG) &&
1355 (note.n_descsz == LLDB_NT_NETBSD_ABI_SIZE)) {
1356 // Pull out the min version info.
1357 uint32_t version_info;
1358 if (data.GetU32(&offset, &version_info, 1) == nullptr) {
1359 error.SetErrorString("failed to read NetBSD ABI note payload");
1360 return error;
1361 }
1362
1363 // Set the elf OS version to NetBSD. Also clear the vendor.
1364 arch_spec.GetTriple().setOS(llvm::Triple::OSType::NetBSD);
1365 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
1366
1367 if (log)
1368 log->Printf(
1369 "ObjectFileELF::%s detected NetBSD, min version constant %" PRIu32"u",
1370 __FUNCTION__, version_info);
1371 }
1372 // Process CSR kalimba notes
1373 else if ((note.n_type == LLDB_NT_GNU_ABI_TAG) &&
1374 (note.n_name == LLDB_NT_OWNER_CSR)) {
1375 arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
1376 arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::CSR);
1377
1378 // TODO At some point the description string could be processed.
1379 // It could provide a steer towards the kalimba variant which
1380 // this ELF targets.
1381 if (note.n_descsz) {
1382 const char *cstr =
1383 data.GetCStr(&offset, llvm::alignTo(note.n_descsz, 4));
1384 (void)cstr;
1385 }
1386 } else if (note.n_name == LLDB_NT_OWNER_ANDROID) {
1387 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1388 arch_spec.GetTriple().setEnvironment(
1389 llvm::Triple::EnvironmentType::Android);
1390 } else if (note.n_name == LLDB_NT_OWNER_LINUX) {
1391 // This is sometimes found in core files and usually contains extended
1392 // register info
1393 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1394 } else if (note.n_name == LLDB_NT_OWNER_CORE) {
1395 // Parse the NT_FILE to look for stuff in paths to shared libraries
1396 // As the contents look like this in a 64 bit ELF core file:
1397 // count = 0x000000000000000a (10)
1398 // page_size = 0x0000000000001000 (4096)
1399 // Index start end file_ofs path
1400 // ===== ------------------ ------------------ ------------------
1401 // -------------------------------------
1402 // [ 0] 0x0000000000400000 0x0000000000401000 0x0000000000000000
1403 // /tmp/a.out
1404 // [ 1] 0x0000000000600000 0x0000000000601000 0x0000000000000000
1405 // /tmp/a.out
1406 // [ 2] 0x0000000000601000 0x0000000000602000 0x0000000000000001
1407 // /tmp/a.out
1408 // [ 3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000
1409 // /lib/x86_64-linux-gnu/libc-2.19.so
1410 // [ 4] 0x00007fa79cba8000 0x00007fa79cda7000 0x00000000000001bb
1411 // /lib/x86_64-linux-gnu/libc-2.19.so
1412 // [ 5] 0x00007fa79cda7000 0x00007fa79cdab000 0x00000000000001ba
1413 // /lib/x86_64-linux-gnu/libc-2.19.so
1414 // [ 6] 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be
1415 // /lib/x86_64-linux-gnu/libc-2.19.so
1416 // [ 7] 0x00007fa79cdb2000 0x00007fa79cdd5000 0x0000000000000000
1417 // /lib/x86_64-linux-gnu/ld-2.19.so
1418 // [ 8] 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022
1419 // /lib/x86_64-linux-gnu/ld-2.19.so
1420 // [ 9] 0x00007fa79cfd5000 0x00007fa79cfd6000 0x0000000000000023
1421 // /lib/x86_64-linux-gnu/ld-2.19.so
1422 // In the 32 bit ELFs the count, page_size, start, end, file_ofs are
1423 // uint32_t
1424 // For reference: see readelf source code (in binutils).
1425 if (note.n_type == NT_FILE0x46494c45) {
1426 uint64_t count = data.GetAddress(&offset);
1427 const char *cstr;
1428 data.GetAddress(&offset); // Skip page size
1429 offset += count * 3 *
1430 data.GetAddressByteSize(); // Skip all start/end/file_ofs
1431 for (size_t i = 0; i < count; ++i) {
1432 cstr = data.GetCStr(&offset);
1433 if (cstr == nullptr) {
1434 error.SetErrorStringWithFormat("ObjectFileELF::%s trying to read "
1435 "at an offset after the end "
1436 "(GetCStr returned nullptr)",
1437 __FUNCTION__);
1438 return error;
1439 }
1440 llvm::StringRef path(cstr);
1441 if (path.contains("/lib/x86_64-linux-gnu") || path.contains("/lib/i386-linux-gnu")) {
1442 arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
1443 break;
1444 }
1445 }
1446 }
1447 }
1448
1449 // Calculate the offset of the next note just in case "offset" has been used
1450 // to poke at the contents of the note data
1451 offset = note_offset + note.GetByteSize();
1452 }
1453
1454 return error;
1455}
1456
1457void ObjectFileELF::ParseARMAttributes(DataExtractor &data, uint64_t length,
1458 ArchSpec &arch_spec) {
1459 lldb::offset_t Offset = 0;
1460
1461 uint8_t FormatVersion = data.GetU8(&Offset);
1462 if (FormatVersion != llvm::ARMBuildAttrs::Format_Version)
1463 return;
1464
1465 Offset = Offset + sizeof(uint32_t); // Section Length
1466 llvm::StringRef VendorName = data.GetCStr(&Offset);
1467
1468 if (VendorName != "aeabi")
1469 return;
1470
1471 if (arch_spec.GetTriple().getEnvironment() ==
1472 llvm::Triple::UnknownEnvironment)
1473 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI);
1474
1475 while (Offset < length) {
1476 uint8_t Tag = data.GetU8(&Offset);
1477 uint32_t Size = data.GetU32(&Offset);
1478
1479 if (Tag != llvm::ARMBuildAttrs::File || Size == 0)
1480 continue;
1481
1482 while (Offset < length) {
1483 uint64_t Tag = data.GetULEB128(&Offset);
1484 switch (Tag) {
1485 default:
1486 if (Tag < 32)
1487 data.GetULEB128(&Offset);
1488 else if (Tag % 2 == 0)
1489 data.GetULEB128(&Offset);
1490 else
1491 data.GetCStr(&Offset);
1492
1493 break;
1494
1495 case llvm::ARMBuildAttrs::CPU_raw_name:
1496 case llvm::ARMBuildAttrs::CPU_name:
1497 data.GetCStr(&Offset);
1498
1499 break;
1500
1501 case llvm::ARMBuildAttrs::ABI_VFP_args: {
1502 uint64_t VFPArgs = data.GetULEB128(&Offset);
1503
1504 if (VFPArgs == llvm::ARMBuildAttrs::BaseAAPCS) {
1505 if (arch_spec.GetTriple().getEnvironment() ==
1506 llvm::Triple::UnknownEnvironment ||
1507 arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABIHF)
1508 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI);
1509
1510 arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float);
1511 } else if (VFPArgs == llvm::ARMBuildAttrs::HardFPAAPCS) {
1512 if (arch_spec.GetTriple().getEnvironment() ==
1513 llvm::Triple::UnknownEnvironment ||
1514 arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABI)
1515 arch_spec.GetTriple().setEnvironment(llvm::Triple::EABIHF);
1516
1517 arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float);
1518 }
1519
1520 break;
1521 }
1522 }
1523 }
1524 }
1525}
1526
1527//----------------------------------------------------------------------
1528// GetSectionHeaderInfo
1529//----------------------------------------------------------------------
1530size_t ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl &section_headers,
1531 const SetDataFunction &set_data,
1532 const elf::ELFHeader &header,
1533 lldb_private::UUID &uuid,
1534 std::string &gnu_debuglink_file,
1535 uint32_t &gnu_debuglink_crc,
1536 ArchSpec &arch_spec) {
1537 // Don't reparse the section headers if we already did that.
1538 if (!section_headers.empty())
1539 return section_headers.size();
1540
1541 // Only initialize the arch_spec to okay defaults if they're not already set.
1542 // We'll refine this with note data as we parse the notes.
1543 if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) {
1544 llvm::Triple::OSType ostype;
1545 llvm::Triple::OSType spec_ostype;
1546 const uint32_t sub_type = subTypeFromElfHeader(header);
1547 arch_spec.SetArchitecture(eArchTypeELF, header.e_machine, sub_type,
1548 header.e_ident[EI_OSABI]);
1549
1550 // Validate if it is ok to remove GetOsFromOSABI.
1551 // Note, that now the OS is determined based on EI_OSABI flag and
1552 // the info extracted from ELF notes (see RefineModuleDetailsFromNote).
1553 // However in some cases that still might be not enough: for example
1554 // a shared library might not have any notes at all
1555 // and have EI_OSABI flag set to System V,
1556 // as result the OS will be set to UnknownOS.
1557 GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
1558 spec_ostype = arch_spec.GetTriple().getOS();
1559 assert(spec_ostype == ostype)((spec_ostype == ostype) ? static_cast<void> (0) : __assert_fail
("spec_ostype == ostype", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 1559, __PRETTY_FUNCTION__))
;
1560 UNUSED_IF_ASSERT_DISABLED(spec_ostype)((void)(spec_ostype));
1561 }
1562
1563 if (arch_spec.GetMachine() == llvm::Triple::mips ||
1564 arch_spec.GetMachine() == llvm::Triple::mipsel ||
1565 arch_spec.GetMachine() == llvm::Triple::mips64 ||
1566 arch_spec.GetMachine() == llvm::Triple::mips64el) {
1567 switch (header.e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) {
1568 case llvm::ELF::EF_MIPS_MICROMIPS:
1569 arch_spec.SetFlags(ArchSpec::eMIPSAse_micromips);
1570 break;
1571 case llvm::ELF::EF_MIPS_ARCH_ASE_M16:
1572 arch_spec.SetFlags(ArchSpec::eMIPSAse_mips16);
1573 break;
1574 case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX:
1575 arch_spec.SetFlags(ArchSpec::eMIPSAse_mdmx);
1576 break;
1577 default:
1578 break;
1579 }
1580 }
1581
1582 if (arch_spec.GetMachine() == llvm::Triple::arm ||
1583 arch_spec.GetMachine() == llvm::Triple::thumb) {
1584 if (header.e_flags & llvm::ELF::EF_ARM_SOFT_FLOAT)
1585 arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float);
1586 else if (header.e_flags & llvm::ELF::EF_ARM_VFP_FLOAT)
1587 arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float);
1588 }
1589
1590 // If there are no section headers we are done.
1591 if (header.e_shnum == 0)
1592 return 0;
1593
1594 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES(1u << 21)));
1595
1596 section_headers.resize(header.e_shnum);
1597 if (section_headers.size() != header.e_shnum)
1598 return 0;
1599
1600 const size_t sh_size = header.e_shnum * header.e_shentsize;
1601 const elf_off sh_offset = header.e_shoff;
1602 DataExtractor sh_data;
1603 if (set_data(sh_data, sh_offset, sh_size) != sh_size)
1604 return 0;
1605
1606 uint32_t idx;
1607 lldb::offset_t offset;
1608 for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) {
1609 if (section_headers[idx].Parse(sh_data, &offset) == false)
1610 break;
1611 }
1612 if (idx < section_headers.size())
1613 section_headers.resize(idx);
1614
1615 const unsigned strtab_idx = header.e_shstrndx;
1616 if (strtab_idx && strtab_idx < section_headers.size()) {
1617 const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx];
1618 const size_t byte_size = sheader.sh_size;
1619 const Elf64_Off offset = sheader.sh_offset;
1620 lldb_private::DataExtractor shstr_data;
1621
1622 if (set_data(shstr_data, offset, byte_size) == byte_size) {
1623 for (SectionHeaderCollIter I = section_headers.begin();
1624 I != section_headers.end(); ++I) {
1625 static ConstString g_sect_name_gnu_debuglink(".gnu_debuglink");
1626 const ELFSectionHeaderInfo &sheader = *I;
1627 const uint64_t section_size =
1628 sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size;
1629 ConstString name(shstr_data.PeekCStr(I->sh_name));
1630
1631 I->section_name = name;
1632
1633 if (arch_spec.IsMIPS()) {
1634 uint32_t arch_flags = arch_spec.GetFlags();
1635 DataExtractor data;
1636 if (sheader.sh_type == SHT_MIPS_ABIFLAGS) {
1637
1638 if (section_size && (set_data(data, sheader.sh_offset,
1639 section_size) == section_size)) {
1640 // MIPS ASE Mask is at offset 12 in MIPS.abiflags section
1641 lldb::offset_t offset = 12; // MIPS ABI Flags Version: 0
1642 arch_flags |= data.GetU32(&offset);
1643
1644 // The floating point ABI is at offset 7
1645 offset = 7;
1646 switch (data.GetU8(&offset)) {
1647 case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY:
1648 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_ANY;
1649 break;
1650 case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE:
1651 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_DOUBLE;
1652 break;
1653 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE:
1654 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SINGLE;
1655 break;
1656 case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT:
1657 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SOFT;
1658 break;
1659 case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64:
1660 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_OLD_64;
1661 break;
1662 case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX:
1663 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_XX;
1664 break;
1665 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64:
1666 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64;
1667 break;
1668 case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A:
1669 arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64A;
1670 break;
1671 }
1672 }
1673 }
1674 // Settings appropriate ArchSpec ABI Flags
1675 switch (header.e_flags & llvm::ELF::EF_MIPS_ABI) {
1676 case llvm::ELF::EF_MIPS_ABI_O32:
1677 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32;
1678 break;
1679 case EF_MIPS_ABI_O64:
1680 arch_flags |= lldb_private::ArchSpec::eMIPSABI_O64;
1681 break;
1682 case EF_MIPS_ABI_EABI32:
1683 arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI32;
1684 break;
1685 case EF_MIPS_ABI_EABI64:
1686 arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI64;
1687 break;
1688 default:
1689 // ABI Mask doesn't cover N32 and N64 ABI.
1690 if (header.e_ident[EI_CLASS] == llvm::ELF::ELFCLASS64)
1691 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N64;
1692 else if (header.e_flags && llvm::ELF::EF_MIPS_ABI2)
1693 arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32;
1694 break;
1695 }
1696 arch_spec.SetFlags(arch_flags);
1697 }
1698
1699 if (arch_spec.GetMachine() == llvm::Triple::arm ||
1700 arch_spec.GetMachine() == llvm::Triple::thumb) {
1701 DataExtractor data;
1702
1703 if (sheader.sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 &&
1704 set_data(data, sheader.sh_offset, section_size) == section_size)
1705 ParseARMAttributes(data, section_size, arch_spec);
1706 }
1707
1708 if (name == g_sect_name_gnu_debuglink) {
1709 DataExtractor data;
1710 if (section_size && (set_data(data, sheader.sh_offset,
1711 section_size) == section_size)) {
1712 lldb::offset_t gnu_debuglink_offset = 0;
1713 gnu_debuglink_file = data.GetCStr(&gnu_debuglink_offset);
1714 gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4);
1715 data.GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1);
1716 }
1717 }
1718
1719 // Process ELF note section entries.
1720 bool is_note_header = (sheader.sh_type == SHT_NOTE);
1721
1722 // The section header ".note.android.ident" is stored as a
1723 // PROGBITS type header but it is actually a note header.
1724 static ConstString g_sect_name_android_ident(".note.android.ident");
1725 if (!is_note_header && name == g_sect_name_android_ident)
1726 is_note_header = true;
1727
1728 if (is_note_header) {
1729 // Allow notes to refine module info.
1730 DataExtractor data;
1731 if (section_size && (set_data(data, sheader.sh_offset,
1732 section_size) == section_size)) {
1733 Error error = RefineModuleDetailsFromNote(data, arch_spec, uuid);
1734 if (error.Fail()) {
1735 if (log)
1736 log->Printf("ObjectFileELF::%s ELF note processing failed: %s",
1737 __FUNCTION__, error.AsCString());
1738 }
1739 }
1740 }
1741 }
1742
1743 // Make any unknown triple components to be unspecified unknowns.
1744 if (arch_spec.GetTriple().getVendor() == llvm::Triple::UnknownVendor)
1745 arch_spec.GetTriple().setVendorName(llvm::StringRef());
1746 if (arch_spec.GetTriple().getOS() == llvm::Triple::UnknownOS)
1747 arch_spec.GetTriple().setOSName(llvm::StringRef());
1748
1749 return section_headers.size();
1750 }
1751 }
1752
1753 section_headers.clear();
1754 return 0;
1755}
1756
1757size_t ObjectFileELF::GetProgramHeaderCount() { return ParseProgramHeaders(); }
1758
1759const elf::ELFProgramHeader *
1760ObjectFileELF::GetProgramHeaderByIndex(lldb::user_id_t id) {
1761 if (!id || !ParseProgramHeaders())
1762 return NULL__null;
1763
1764 if (--id < m_program_headers.size())
1765 return &m_program_headers[id];
1766
1767 return NULL__null;
1768}
1769
1770DataExtractor ObjectFileELF::GetSegmentDataByIndex(lldb::user_id_t id) {
1771 const elf::ELFProgramHeader *segment_header = GetProgramHeaderByIndex(id);
1772 if (segment_header == NULL__null)
1773 return DataExtractor();
1774 return DataExtractor(m_data, segment_header->p_offset,
1775 segment_header->p_filesz);
1776}
1777
1778std::string
1779ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const {
1780 size_t pos = symbol_name.find('@');
1781 return symbol_name.substr(0, pos).str();
1782}
1783
1784//----------------------------------------------------------------------
1785// ParseSectionHeaders
1786//----------------------------------------------------------------------
1787size_t ObjectFileELF::ParseSectionHeaders() {
1788 using namespace std::placeholders;
1789
1790 return GetSectionHeaderInfo(
1791 m_section_headers,
1792 std::bind(&ObjectFileELF::SetDataWithReadMemoryFallback, this, _1, _2,
1793 _3),
1794 m_header, m_uuid, m_gnu_debuglink_file, m_gnu_debuglink_crc, m_arch_spec);
1795}
1796
1797lldb::offset_t ObjectFileELF::SetData(const lldb_private::DataExtractor &src,
1798 lldb_private::DataExtractor &dst,
1799 lldb::offset_t offset,
1800 lldb::offset_t length) {
1801 return dst.SetData(src, offset, length);
1802}
1803
1804lldb::offset_t
1805ObjectFileELF::SetDataWithReadMemoryFallback(lldb_private::DataExtractor &dst,
1806 lldb::offset_t offset,
1807 lldb::offset_t length) {
1808 if (offset + length <= m_data.GetByteSize())
1809 return dst.SetData(m_data, offset, length);
1810
1811 const auto process_sp = m_process_wp.lock();
1812 if (process_sp != nullptr) {
1813 addr_t file_size = offset + length;
1814
1815 DataBufferSP data_sp = ReadMemory(process_sp, m_memory_addr, file_size);
1816 if (!data_sp)
1817 return false;
1818 m_data.SetData(data_sp, 0, file_size);
1819 }
1820
1821 return dst.SetData(m_data, offset, length);
1822}
1823
1824const ObjectFileELF::ELFSectionHeaderInfo *
1825ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) {
1826 if (!id || !ParseSectionHeaders())
1827 return NULL__null;
1828
1829 if (--id < m_section_headers.size())
1830 return &m_section_headers[id];
1831
1832 return NULL__null;
1833}
1834
1835lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) {
1836 if (!name || !name[0] || !ParseSectionHeaders())
1837 return 0;
1838 for (size_t i = 1; i < m_section_headers.size(); ++i)
1839 if (m_section_headers[i].section_name == ConstString(name))
1840 return i;
1841 return 0;
1842}
1843
1844void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
1845 if (!m_sections_ap.get() && ParseSectionHeaders()) {
1846 m_sections_ap.reset(new SectionList());
1847
1848 for (SectionHeaderCollIter I = m_section_headers.begin();
1849 I != m_section_headers.end(); ++I) {
1850 const ELFSectionHeaderInfo &header = *I;
1851
1852 ConstString &name = I->section_name;
1853 const uint64_t file_size =
1854 header.sh_type == SHT_NOBITS ? 0 : header.sh_size;
1855 const uint64_t vm_size = header.sh_flags & SHF_ALLOC ? header.sh_size : 0;
1856
1857 static ConstString g_sect_name_text(".text");
1858 static ConstString g_sect_name_data(".data");
1859 static ConstString g_sect_name_bss(".bss");
1860 static ConstString g_sect_name_tdata(".tdata");
1861 static ConstString g_sect_name_tbss(".tbss");
1862 static ConstString g_sect_name_dwarf_debug_abbrev(".debug_abbrev");
1863 static ConstString g_sect_name_dwarf_debug_addr(".debug_addr");
1864 static ConstString g_sect_name_dwarf_debug_aranges(".debug_aranges");
1865 static ConstString g_sect_name_dwarf_debug_frame(".debug_frame");
1866 static ConstString g_sect_name_dwarf_debug_info(".debug_info");
1867 static ConstString g_sect_name_dwarf_debug_line(".debug_line");
1868 static ConstString g_sect_name_dwarf_debug_loc(".debug_loc");
1869 static ConstString g_sect_name_dwarf_debug_macinfo(".debug_macinfo");
1870 static ConstString g_sect_name_dwarf_debug_macro(".debug_macro");
1871 static ConstString g_sect_name_dwarf_debug_pubnames(".debug_pubnames");
1872 static ConstString g_sect_name_dwarf_debug_pubtypes(".debug_pubtypes");
1873 static ConstString g_sect_name_dwarf_debug_ranges(".debug_ranges");
1874 static ConstString g_sect_name_dwarf_debug_str(".debug_str");
1875 static ConstString g_sect_name_dwarf_debug_str_offsets(
1876 ".debug_str_offsets");
1877 static ConstString g_sect_name_dwarf_debug_abbrev_dwo(
1878 ".debug_abbrev.dwo");
1879 static ConstString g_sect_name_dwarf_debug_info_dwo(".debug_info.dwo");
1880 static ConstString g_sect_name_dwarf_debug_line_dwo(".debug_line.dwo");
1881 static ConstString g_sect_name_dwarf_debug_macro_dwo(".debug_macro.dwo");
1882 static ConstString g_sect_name_dwarf_debug_loc_dwo(".debug_loc.dwo");
1883 static ConstString g_sect_name_dwarf_debug_str_dwo(".debug_str.dwo");
1884 static ConstString g_sect_name_dwarf_debug_str_offsets_dwo(
1885 ".debug_str_offsets.dwo");
1886 static ConstString g_sect_name_eh_frame(".eh_frame");
1887 static ConstString g_sect_name_arm_exidx(".ARM.exidx");
1888 static ConstString g_sect_name_arm_extab(".ARM.extab");
1889 static ConstString g_sect_name_go_symtab(".gosymtab");
1890
1891 SectionType sect_type = eSectionTypeOther;
1892
1893 bool is_thread_specific = false;
1894
1895 if (name == g_sect_name_text)
1896 sect_type = eSectionTypeCode;
1897 else if (name == g_sect_name_data)
1898 sect_type = eSectionTypeData;
1899 else if (name == g_sect_name_bss)
1900 sect_type = eSectionTypeZeroFill;
1901 else if (name == g_sect_name_tdata) {
1902 sect_type = eSectionTypeData;
1903 is_thread_specific = true;
1904 } else if (name == g_sect_name_tbss) {
1905 sect_type = eSectionTypeZeroFill;
1906 is_thread_specific = true;
1907 }
1908 // .debug_abbrev – Abbreviations used in the .debug_info section
1909 // .debug_aranges – Lookup table for mapping addresses to compilation
1910 // units
1911 // .debug_frame – Call frame information
1912 // .debug_info – The core DWARF information section
1913 // .debug_line – Line number information
1914 // .debug_loc – Location lists used in DW_AT_location attributes
1915 // .debug_macinfo – Macro information
1916 // .debug_pubnames – Lookup table for mapping object and function names to
1917 // compilation units
1918 // .debug_pubtypes – Lookup table for mapping type names to compilation
1919 // units
1920 // .debug_ranges – Address ranges used in DW_AT_ranges attributes
1921 // .debug_str – String table used in .debug_info
1922 // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section,
1923 // http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html
1924 // MISSING? .debug-index -
1925 // http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644
1926 // MISSING? .debug_types - Type descriptions from DWARF 4? See
1927 // http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo
1928 else if (name == g_sect_name_dwarf_debug_abbrev)
1929 sect_type = eSectionTypeDWARFDebugAbbrev;
1930 else if (name == g_sect_name_dwarf_debug_addr)
1931 sect_type = eSectionTypeDWARFDebugAddr;
1932 else if (name == g_sect_name_dwarf_debug_aranges)
1933 sect_type = eSectionTypeDWARFDebugAranges;
1934 else if (name == g_sect_name_dwarf_debug_frame)
1935 sect_type = eSectionTypeDWARFDebugFrame;
1936 else if (name == g_sect_name_dwarf_debug_info)
1937 sect_type = eSectionTypeDWARFDebugInfo;
1938 else if (name == g_sect_name_dwarf_debug_line)
1939 sect_type = eSectionTypeDWARFDebugLine;
1940 else if (name == g_sect_name_dwarf_debug_loc)
1941 sect_type = eSectionTypeDWARFDebugLoc;
1942 else if (name == g_sect_name_dwarf_debug_macinfo)
1943 sect_type = eSectionTypeDWARFDebugMacInfo;
1944 else if (name == g_sect_name_dwarf_debug_macro)
1945 sect_type = eSectionTypeDWARFDebugMacro;
1946 else if (name == g_sect_name_dwarf_debug_pubnames)
1947 sect_type = eSectionTypeDWARFDebugPubNames;
1948 else if (name == g_sect_name_dwarf_debug_pubtypes)
1949 sect_type = eSectionTypeDWARFDebugPubTypes;
1950 else if (name == g_sect_name_dwarf_debug_ranges)
1951 sect_type = eSectionTypeDWARFDebugRanges;
1952 else if (name == g_sect_name_dwarf_debug_str)
1953 sect_type = eSectionTypeDWARFDebugStr;
1954 else if (name == g_sect_name_dwarf_debug_str_offsets)
1955 sect_type = eSectionTypeDWARFDebugStrOffsets;
1956 else if (name == g_sect_name_dwarf_debug_abbrev_dwo)
1957 sect_type = eSectionTypeDWARFDebugAbbrev;
1958 else if (name == g_sect_name_dwarf_debug_info_dwo)
1959 sect_type = eSectionTypeDWARFDebugInfo;
1960 else if (name == g_sect_name_dwarf_debug_line_dwo)
1961 sect_type = eSectionTypeDWARFDebugLine;
1962 else if (name == g_sect_name_dwarf_debug_macro_dwo)
1963 sect_type = eSectionTypeDWARFDebugMacro;
1964 else if (name == g_sect_name_dwarf_debug_loc_dwo)
1965 sect_type = eSectionTypeDWARFDebugLoc;
1966 else if (name == g_sect_name_dwarf_debug_str_dwo)
1967 sect_type = eSectionTypeDWARFDebugStr;
1968 else if (name == g_sect_name_dwarf_debug_str_offsets_dwo)
1969 sect_type = eSectionTypeDWARFDebugStrOffsets;
1970 else if (name == g_sect_name_eh_frame)
1971 sect_type = eSectionTypeEHFrame;
1972 else if (name == g_sect_name_arm_exidx)
1973 sect_type = eSectionTypeARMexidx;
1974 else if (name == g_sect_name_arm_extab)
1975 sect_type = eSectionTypeARMextab;
1976 else if (name == g_sect_name_go_symtab)
1977 sect_type = eSectionTypeGoSymtab;
1978
1979 const uint32_t permissions =
1980 ((header.sh_flags & SHF_ALLOC) ? ePermissionsReadable : 0u) |
1981 ((header.sh_flags & SHF_WRITE) ? ePermissionsWritable : 0u) |
1982 ((header.sh_flags & SHF_EXECINSTR) ? ePermissionsExecutable : 0u);
1983 switch (header.sh_type) {
1984 case SHT_SYMTAB:
1985 assert(sect_type == eSectionTypeOther)((sect_type == eSectionTypeOther) ? static_cast<void> (
0) : __assert_fail ("sect_type == eSectionTypeOther", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 1985, __PRETTY_FUNCTION__))
;
1986 sect_type = eSectionTypeELFSymbolTable;
1987 break;
1988 case SHT_DYNSYM:
1989 assert(sect_type == eSectionTypeOther)((sect_type == eSectionTypeOther) ? static_cast<void> (
0) : __assert_fail ("sect_type == eSectionTypeOther", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 1989, __PRETTY_FUNCTION__))
;
1990 sect_type = eSectionTypeELFDynamicSymbols;
1991 break;
1992 case SHT_RELA:
1993 case SHT_REL:
1994 assert(sect_type == eSectionTypeOther)((sect_type == eSectionTypeOther) ? static_cast<void> (
0) : __assert_fail ("sect_type == eSectionTypeOther", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 1994, __PRETTY_FUNCTION__))
;
1995 sect_type = eSectionTypeELFRelocationEntries;
1996 break;
1997 case SHT_DYNAMIC:
1998 assert(sect_type == eSectionTypeOther)((sect_type == eSectionTypeOther) ? static_cast<void> (
0) : __assert_fail ("sect_type == eSectionTypeOther", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 1998, __PRETTY_FUNCTION__))
;
1999 sect_type = eSectionTypeELFDynamicLinkInfo;
2000 break;
2001 }
2002
2003 if (eSectionTypeOther == sect_type) {
2004 // the kalimba toolchain assumes that ELF section names are free-form.
2005 // It does
2006 // support linkscripts which (can) give rise to various arbitrarily
2007 // named
2008 // sections being "Code" or "Data".
2009 sect_type = kalimbaSectionType(m_header, header);
2010 }
2011
2012 const uint32_t target_bytes_size =
2013 (eSectionTypeData == sect_type || eSectionTypeZeroFill == sect_type)
2014 ? m_arch_spec.GetDataByteSize()
2015 : eSectionTypeCode == sect_type ? m_arch_spec.GetCodeByteSize()
2016 : 1;
2017
2018 elf::elf_xword log2align =
2019 (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign);
2020 SectionSP section_sp(new Section(
2021 GetModule(), // Module to which this section belongs.
2022 this, // ObjectFile to which this section belongs and should read
2023 // section data from.
2024 SectionIndex(I), // Section ID.
2025 name, // Section name.
2026 sect_type, // Section type.
2027 header.sh_addr, // VM address.
2028 vm_size, // VM size in bytes of this section.
2029 header.sh_offset, // Offset of this section in the file.
2030 file_size, // Size of the section as found in the file.
2031 log2align, // Alignment of the section
2032 header.sh_flags, // Flags for this section.
2033 target_bytes_size)); // Number of host bytes per target byte
2034
2035 section_sp->SetPermissions(permissions);
2036 if (is_thread_specific)
2037 section_sp->SetIsThreadSpecific(is_thread_specific);
2038 m_sections_ap->AddSection(section_sp);
2039 }
2040 }
2041
2042 if (m_sections_ap.get()) {
2043 if (GetType() == eTypeDebugInfo) {
2044 static const SectionType g_sections[] = {
2045 eSectionTypeDWARFDebugAbbrev, eSectionTypeDWARFDebugAddr,
2046 eSectionTypeDWARFDebugAranges, eSectionTypeDWARFDebugFrame,
2047 eSectionTypeDWARFDebugInfo, eSectionTypeDWARFDebugLine,
2048 eSectionTypeDWARFDebugLoc, eSectionTypeDWARFDebugMacInfo,
2049 eSectionTypeDWARFDebugPubNames, eSectionTypeDWARFDebugPubTypes,
2050 eSectionTypeDWARFDebugRanges, eSectionTypeDWARFDebugStr,
2051 eSectionTypeDWARFDebugStrOffsets, eSectionTypeELFSymbolTable,
2052 };
2053 SectionList *elf_section_list = m_sections_ap.get();
2054 for (size_t idx = 0; idx < sizeof(g_sections) / sizeof(g_sections[0]);
2055 ++idx) {
2056 SectionType section_type = g_sections[idx];
2057 SectionSP section_sp(
2058 elf_section_list->FindSectionByType(section_type, true));
2059 if (section_sp) {
2060 SectionSP module_section_sp(
2061 unified_section_list.FindSectionByType(section_type, true));
2062 if (module_section_sp)
2063 unified_section_list.ReplaceSection(module_section_sp->GetID(),
2064 section_sp);
2065 else
2066 unified_section_list.AddSection(section_sp);
2067 }
2068 }
2069 } else {
2070 unified_section_list = *m_sections_ap;
2071 }
2072 }
2073}
2074
2075// Find the arm/aarch64 mapping symbol character in the given symbol name.
2076// Mapping symbols have the
2077// form of "$<char>[.<any>]*". Additionally we recognize cases when the mapping
2078// symbol prefixed by
2079// an arbitrary string because if a symbol prefix added to each symbol in the
2080// object file with
2081// objcopy then the mapping symbols are also prefixed.
2082static char FindArmAarch64MappingSymbol(const char *symbol_name) {
2083 if (!symbol_name)
2084 return '\0';
2085
2086 const char *dollar_pos = ::strchr(symbol_name, '$');
2087 if (!dollar_pos || dollar_pos[1] == '\0')
2088 return '\0';
2089
2090 if (dollar_pos[2] == '\0' || dollar_pos[2] == '.')
2091 return dollar_pos[1];
2092 return '\0';
2093}
2094
2095#define STO_MIPS_ISA(3 << 6) (3 << 6)
2096#define STO_MICROMIPS(2 << 6) (2 << 6)
2097#define IS_MICROMIPS(ST_OTHER)(((ST_OTHER)&(3 << 6)) == (2 << 6)) (((ST_OTHER)&STO_MIPS_ISA(3 << 6)) == STO_MICROMIPS(2 << 6))
2098
2099// private
2100unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
2101 SectionList *section_list,
2102 const size_t num_symbols,
2103 const DataExtractor &symtab_data,
2104 const DataExtractor &strtab_data) {
2105 ELFSymbol symbol;
2106 lldb::offset_t offset = 0;
2107
2108 static ConstString text_section_name(".text");
2109 static ConstString init_section_name(".init");
2110 static ConstString fini_section_name(".fini");
2111 static ConstString ctors_section_name(".ctors");
2112 static ConstString dtors_section_name(".dtors");
2113
2114 static ConstString data_section_name(".data");
2115 static ConstString rodata_section_name(".rodata");
2116 static ConstString rodata1_section_name(".rodata1");
2117 static ConstString data2_section_name(".data1");
2118 static ConstString bss_section_name(".bss");
2119 static ConstString opd_section_name(".opd"); // For ppc64
2120
2121 // On Android the oatdata and the oatexec symbols in the oat and odex files
2122 // covers the full
2123 // .text section what causes issues with displaying unusable symbol name to
2124 // the user and very
2125 // slow unwinding speed because the instruction emulation based unwind plans
2126 // try to emulate all
2127 // instructions in these symbols. Don't add these symbols to the symbol list
2128 // as they have no
2129 // use for the debugger and they are causing a lot of trouble.
2130 // Filtering can't be restricted to Android because this special object file
2131 // don't contain the
2132 // note section specifying the environment to Android but the custom extension
2133 // and file name
2134 // makes it highly unlikely that this will collide with anything else.
2135 ConstString file_extension = m_file.GetFileNameExtension();
2136 bool skip_oatdata_oatexec = file_extension == ConstString("oat") ||
2137 file_extension == ConstString("odex");
2138
2139 ArchSpec arch;
2140 GetArchitecture(arch);
2141 ModuleSP module_sp(GetModule());
2142 SectionList *module_section_list =
2143 module_sp ? module_sp->GetSectionList() : nullptr;
2144
2145 // Local cache to avoid doing a FindSectionByName for each symbol. The "const
2146 // char*" key must
2147 // came from a ConstString object so they can be compared by pointer
2148 std::unordered_map<const char *, lldb::SectionSP> section_name_to_section;
2149
2150 unsigned i;
2151 for (i = 0; i < num_symbols; ++i) {
2152 if (symbol.Parse(symtab_data, &offset) == false)
2153 break;
2154
2155 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
2156 if (!symbol_name)
2157 symbol_name = "";
2158
2159 // No need to add non-section symbols that have no names
2160 if (symbol.getType() != STT_SECTION &&
2161 (symbol_name == nullptr || symbol_name[0] == '\0'))
2162 continue;
2163
2164 // Skipping oatdata and oatexec sections if it is requested. See details
2165 // above the
2166 // definition of skip_oatdata_oatexec for the reasons.
2167 if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 ||
2168 ::strcmp(symbol_name, "oatexec") == 0))
2169 continue;
2170
2171 SectionSP symbol_section_sp;
2172 SymbolType symbol_type = eSymbolTypeInvalid;
2173 Elf64_Half section_idx = symbol.st_shndx;
2174
2175 switch (section_idx) {
2176 case SHN_ABS:
2177 symbol_type = eSymbolTypeAbsolute;
2178 break;
2179 case SHN_UNDEF:
2180 symbol_type = eSymbolTypeUndefined;
2181 break;
2182 default:
2183 symbol_section_sp = section_list->GetSectionAtIndex(section_idx);
2184 break;
2185 }
2186
2187 // If a symbol is undefined do not process it further even if it has a STT
2188 // type
2189 if (symbol_type != eSymbolTypeUndefined) {
2190 switch (symbol.getType()) {
2191 default:
2192 case STT_NOTYPE:
2193 // The symbol's type is not specified.
2194 break;
2195
2196 case STT_OBJECT:
2197 // The symbol is associated with a data object, such as a variable,
2198 // an array, etc.
2199 symbol_type = eSymbolTypeData;
2200 break;
2201
2202 case STT_FUNC:
2203 // The symbol is associated with a function or other executable code.
2204 symbol_type = eSymbolTypeCode;
2205 break;
2206
2207 case STT_SECTION:
2208 // The symbol is associated with a section. Symbol table entries of
2209 // this type exist primarily for relocation and normally have
2210 // STB_LOCAL binding.
2211 break;
2212
2213 case STT_FILE:
2214 // Conventionally, the symbol's name gives the name of the source
2215 // file associated with the object file. A file symbol has STB_LOCAL
2216 // binding, its section index is SHN_ABS, and it precedes the other
2217 // STB_LOCAL symbols for the file, if it is present.
2218 symbol_type = eSymbolTypeSourceFile;
2219 break;
2220
2221 case STT_GNU_IFUNC:
2222 // The symbol is associated with an indirect function. The actual
2223 // function will be resolved if it is referenced.
2224 symbol_type = eSymbolTypeResolver;
2225 break;
2226 }
2227 }
2228
2229 if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) {
2230 if (symbol_section_sp) {
2231 const ConstString &sect_name = symbol_section_sp->GetName();
2232 if (sect_name == text_section_name || sect_name == init_section_name ||
2233 sect_name == fini_section_name || sect_name == ctors_section_name ||
2234 sect_name == dtors_section_name) {
2235 symbol_type = eSymbolTypeCode;
2236 } else if (sect_name == data_section_name ||
2237 sect_name == data2_section_name ||
2238 sect_name == rodata_section_name ||
2239 sect_name == rodata1_section_name ||
2240 sect_name == bss_section_name) {
2241 symbol_type = eSymbolTypeData;
2242 }
2243 }
2244 }
2245
2246 int64_t symbol_value_offset = 0;
2247 uint32_t additional_flags = 0;
2248
2249 if (arch.IsValid()) {
2250 if (arch.GetMachine() == llvm::Triple::arm) {
2251 if (symbol.getBinding() == STB_LOCAL) {
2252 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
2253 if (symbol_type == eSymbolTypeCode) {
2254 switch (mapping_symbol) {
2255 case 'a':
2256 // $a[.<any>]* - marks an ARM instruction sequence
2257 m_address_class_map[symbol.st_value] = eAddressClassCode;
2258 break;
2259 case 'b':
2260 case 't':
2261 // $b[.<any>]* - marks a THUMB BL instruction sequence
2262 // $t[.<any>]* - marks a THUMB instruction sequence
2263 m_address_class_map[symbol.st_value] =
2264 eAddressClassCodeAlternateISA;
2265 break;
2266 case 'd':
2267 // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
2268 m_address_class_map[symbol.st_value] = eAddressClassData;
2269 break;
2270 }
2271 }
2272 if (mapping_symbol)
2273 continue;
2274 }
2275 } else if (arch.GetMachine() == llvm::Triple::aarch64) {
2276 if (symbol.getBinding() == STB_LOCAL) {
2277 char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
2278 if (symbol_type == eSymbolTypeCode) {
2279 switch (mapping_symbol) {
2280 case 'x':
2281 // $x[.<any>]* - marks an A64 instruction sequence
2282 m_address_class_map[symbol.st_value] = eAddressClassCode;
2283 break;
2284 case 'd':
2285 // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
2286 m_address_class_map[symbol.st_value] = eAddressClassData;
2287 break;
2288 }
2289 }
2290 if (mapping_symbol)
2291 continue;
2292 }
2293 }
2294
2295 if (arch.GetMachine() == llvm::Triple::arm) {
2296 if (symbol_type == eSymbolTypeCode) {
2297 if (symbol.st_value & 1) {
2298 // Subtracting 1 from the address effectively unsets
2299 // the low order bit, which results in the address
2300 // actually pointing to the beginning of the symbol.
2301 // This delta will be used below in conjunction with
2302 // symbol.st_value to produce the final symbol_value
2303 // that we store in the symtab.
2304 symbol_value_offset = -1;
2305 m_address_class_map[symbol.st_value ^ 1] =
2306 eAddressClassCodeAlternateISA;
2307 } else {
2308 // This address is ARM
2309 m_address_class_map[symbol.st_value] = eAddressClassCode;
2310 }
2311 }
2312 }
2313
2314 /*
2315 * MIPS:
2316 * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for
2317 * MIPS).
2318 * This allows processor to switch between microMIPS and MIPS without any
2319 * need
2320 * for special mode-control register. However, apart from .debug_line,
2321 * none of
2322 * the ELF/DWARF sections set the ISA bit (for symbol or section). Use
2323 * st_other
2324 * flag to check whether the symbol is microMIPS and then set the address
2325 * class
2326 * accordingly.
2327 */
2328 const llvm::Triple::ArchType llvm_arch = arch.GetMachine();
2329 if (llvm_arch == llvm::Triple::mips ||
2330 llvm_arch == llvm::Triple::mipsel ||
2331 llvm_arch == llvm::Triple::mips64 ||
2332 llvm_arch == llvm::Triple::mips64el) {
2333 if (IS_MICROMIPS(symbol.st_other)(((symbol.st_other)&(3 << 6)) == (2 << 6)))
2334 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA;
2335 else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) {
2336 symbol.st_value = symbol.st_value & (~1ull);
2337 m_address_class_map[symbol.st_value] = eAddressClassCodeAlternateISA;
2338 } else {
2339 if (symbol_type == eSymbolTypeCode)
2340 m_address_class_map[symbol.st_value] = eAddressClassCode;
2341 else if (symbol_type == eSymbolTypeData)
2342 m_address_class_map[symbol.st_value] = eAddressClassData;
2343 else
2344 m_address_class_map[symbol.st_value] = eAddressClassUnknown;
2345 }
2346 }
2347 }
2348
2349 // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB
2350 // symbols. See above for
2351 // more details.
2352 uint64_t symbol_value = symbol.st_value + symbol_value_offset;
2353
2354 if (symbol_section_sp == nullptr && section_idx == SHN_ABS &&
2355 symbol.st_size != 0) {
2356 // We don't have a section for a symbol with non-zero size. Create a new
2357 // section for it
2358 // so the address range covered by the symbol is also covered by the
2359 // module (represented
2360 // through the section list). It is needed so module lookup for the
2361 // addresses covered
2362 // by this symbol will be successfull. This case happens for absolute
2363 // symbols.
2364 ConstString fake_section_name(std::string(".absolute.") + symbol_name);
2365 symbol_section_sp =
2366 std::make_shared<Section>(module_sp, this, SHN_ABS, fake_section_name,
2367 eSectionTypeAbsoluteAddress, symbol_value,
2368 symbol.st_size, 0, 0, 0, SHF_ALLOC);
2369
2370 module_section_list->AddSection(symbol_section_sp);
2371 section_list->AddSection(symbol_section_sp);
2372 }
2373
2374 if (symbol_section_sp &&
2375 CalculateType() != ObjectFile::Type::eTypeObjectFile)
2376 symbol_value -= symbol_section_sp->GetFileAddress();
2377
2378 if (symbol_section_sp && module_section_list &&
2379 module_section_list != section_list) {
2380 const ConstString &sect_name = symbol_section_sp->GetName();
2381 auto section_it = section_name_to_section.find(sect_name.GetCString());
2382 if (section_it == section_name_to_section.end())
2383 section_it =
2384 section_name_to_section
2385 .emplace(sect_name.GetCString(),
2386 module_section_list->FindSectionByName(sect_name))
2387 .first;
2388 if (section_it->second && section_it->second->GetFileSize())
2389 symbol_section_sp = section_it->second;
2390 }
2391
2392 bool is_global = symbol.getBinding() == STB_GLOBAL;
2393 uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags;
2394 bool is_mangled = (symbol_name[0] == '_' && symbol_name[1] == 'Z');
2395
2396 llvm::StringRef symbol_ref(symbol_name);
2397
2398 // Symbol names may contain @VERSION suffixes. Find those and strip them
2399 // temporarily.
2400 size_t version_pos = symbol_ref.find('@');
2401 bool has_suffix = version_pos != llvm::StringRef::npos;
2402 llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
2403 Mangled mangled(ConstString(symbol_bare), is_mangled);
2404
2405 // Now append the suffix back to mangled and unmangled names. Only do it if
2406 // the
2407 // demangling was successful (string is not empty).
2408 if (has_suffix) {
2409 llvm::StringRef suffix = symbol_ref.substr(version_pos);
2410
2411 llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef();
2412 if (!mangled_name.empty())
2413 mangled.SetMangledName(ConstString((mangled_name + suffix).str()));
2414
2415 ConstString demangled =
2416 mangled.GetDemangledName(lldb::eLanguageTypeUnknown);
2417 llvm::StringRef demangled_name = demangled.GetStringRef();
2418 if (!demangled_name.empty())
2419 mangled.SetDemangledName(ConstString((demangled_name + suffix).str()));
2420 }
2421
2422 // In ELF all symbol should have a valid size but it is not true for some
2423 // function symbols
2424 // coming from hand written assembly. As none of the function symbol should
2425 // have 0 size we
2426 // try to calculate the size for these symbols in the symtab with saying
2427 // that their original
2428 // size is not valid.
2429 bool symbol_size_valid =
2430 symbol.st_size != 0 || symbol.getType() != STT_FUNC;
2431
2432 Symbol dc_symbol(
2433 i + start_id, // ID is the original symbol table index.
2434 mangled,
2435 symbol_type, // Type of this symbol
2436 is_global, // Is this globally visible?
2437 false, // Is this symbol debug info?
2438 false, // Is this symbol a trampoline?
2439 false, // Is this symbol artificial?
2440 AddressRange(symbol_section_sp, // Section in which this symbol is
2441 // defined or null.
2442 symbol_value, // Offset in section or symbol value.
2443 symbol.st_size), // Size in bytes of this symbol.
2444 symbol_size_valid, // Symbol size is valid
2445 has_suffix, // Contains linker annotations?
2446 flags); // Symbol flags.
2447 symtab->AddSymbol(dc_symbol);
2448 }
2449 return i;
2450}
2451
2452unsigned ObjectFileELF::ParseSymbolTable(Symtab *symbol_table,
2453 user_id_t start_id,
2454 lldb_private::Section *symtab) {
2455 if (symtab->GetObjectFile() != this) {
2456 // If the symbol table section is owned by a different object file, have it
2457 // do the
2458 // parsing.
2459 ObjectFileELF *obj_file_elf =
2460 static_cast<ObjectFileELF *>(symtab->GetObjectFile());
2461 return obj_file_elf->ParseSymbolTable(symbol_table, start_id, symtab);
2462 }
2463
2464 // Get section list for this object file.
2465 SectionList *section_list = m_sections_ap.get();
2466 if (!section_list)
2467 return 0;
2468
2469 user_id_t symtab_id = symtab->GetID();
2470 const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
2471 assert(symtab_hdr->sh_type == SHT_SYMTAB ||((symtab_hdr->sh_type == SHT_SYMTAB || symtab_hdr->sh_type
== SHT_DYNSYM) ? static_cast<void> (0) : __assert_fail
("symtab_hdr->sh_type == SHT_SYMTAB || symtab_hdr->sh_type == SHT_DYNSYM"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2472, __PRETTY_FUNCTION__))
2472 symtab_hdr->sh_type == SHT_DYNSYM)((symtab_hdr->sh_type == SHT_SYMTAB || symtab_hdr->sh_type
== SHT_DYNSYM) ? static_cast<void> (0) : __assert_fail
("symtab_hdr->sh_type == SHT_SYMTAB || symtab_hdr->sh_type == SHT_DYNSYM"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2472, __PRETTY_FUNCTION__))
;
2473
2474 // sh_link: section header index of associated string table.
2475 // Section ID's are ones based.
2476 user_id_t strtab_id = symtab_hdr->sh_link + 1;
2477 Section *strtab = section_list->FindSectionByID(strtab_id).get();
2478
2479 if (symtab && strtab) {
2480 assert(symtab->GetObjectFile() == this)((symtab->GetObjectFile() == this) ? static_cast<void>
(0) : __assert_fail ("symtab->GetObjectFile() == this", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2480, __PRETTY_FUNCTION__))
;
2481 assert(strtab->GetObjectFile() == this)((strtab->GetObjectFile() == this) ? static_cast<void>
(0) : __assert_fail ("strtab->GetObjectFile() == this", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2481, __PRETTY_FUNCTION__))
;
2482
2483 DataExtractor symtab_data;
2484 DataExtractor strtab_data;
2485 if (ReadSectionData(symtab, symtab_data) &&
2486 ReadSectionData(strtab, strtab_data)) {
2487 size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize;
2488
2489 return ParseSymbols(symbol_table, start_id, section_list, num_symbols,
2490 symtab_data, strtab_data);
2491 }
2492 }
2493
2494 return 0;
2495}
2496
2497size_t ObjectFileELF::ParseDynamicSymbols() {
2498 if (m_dynamic_symbols.size())
2499 return m_dynamic_symbols.size();
2500
2501 SectionList *section_list = GetSectionList();
2502 if (!section_list)
2503 return 0;
2504
2505 // Find the SHT_DYNAMIC section.
2506 Section *dynsym =
2507 section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
2508 .get();
2509 if (!dynsym)
2510 return 0;
2511 assert(dynsym->GetObjectFile() == this)((dynsym->GetObjectFile() == this) ? static_cast<void>
(0) : __assert_fail ("dynsym->GetObjectFile() == this", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2511, __PRETTY_FUNCTION__))
;
2512
2513 ELFDynamic symbol;
2514 DataExtractor dynsym_data;
2515 if (ReadSectionData(dynsym, dynsym_data)) {
2516 const lldb::offset_t section_size = dynsym_data.GetByteSize();
2517 lldb::offset_t cursor = 0;
2518
2519 while (cursor < section_size) {
2520 if (!symbol.Parse(dynsym_data, &cursor))
2521 break;
2522
2523 m_dynamic_symbols.push_back(symbol);
2524 }
2525 }
2526
2527 return m_dynamic_symbols.size();
2528}
2529
2530const ELFDynamic *ObjectFileELF::FindDynamicSymbol(unsigned tag) {
2531 if (!ParseDynamicSymbols())
2532 return NULL__null;
2533
2534 DynamicSymbolCollIter I = m_dynamic_symbols.begin();
2535 DynamicSymbolCollIter E = m_dynamic_symbols.end();
2536 for (; I != E; ++I) {
2537 ELFDynamic *symbol = &*I;
2538
2539 if (symbol->d_tag == tag)
2540 return symbol;
2541 }
2542
2543 return NULL__null;
2544}
2545
2546unsigned ObjectFileELF::PLTRelocationType() {
2547 // DT_PLTREL
2548 // This member specifies the type of relocation entry to which the
2549 // procedure linkage table refers. The d_val member holds DT_REL or
2550 // DT_RELA, as appropriate. All relocations in a procedure linkage table
2551 // must use the same relocation.
2552 const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL);
2553
2554 if (symbol)
2555 return symbol->d_val;
2556
2557 return 0;
2558}
2559
2560// Returns the size of the normal plt entries and the offset of the first normal
2561// plt entry. The
2562// 0th entry in the plt table is usually a resolution entry which have different
2563// size in some
2564// architectures then the rest of the plt entries.
2565static std::pair<uint64_t, uint64_t>
2566GetPltEntrySizeAndOffset(const ELFSectionHeader *rel_hdr,
2567 const ELFSectionHeader *plt_hdr) {
2568 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2569
2570 // Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are 16
2571 // bytes.
2572 // So round the entsize up by the alignment if addralign is set.
2573 elf_xword plt_entsize =
2574 plt_hdr->sh_addralign
2575 ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign)
2576 : plt_hdr->sh_entsize;
2577
2578 // Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field incorrectly.
2579 // PLT entries relocation code in general requires multiple instruction and
2580 // should be greater than 4 bytes in most cases. Try to guess correct size
2581 // just in case.
2582 if (plt_entsize <= 4) {
2583 // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the
2584 // size of the plt
2585 // entries based on the number of entries and the size of the plt section
2586 // with the
2587 // assumption that the size of the 0th entry is at least as big as the size
2588 // of the normal
2589 // entries and it isn't much bigger then that.
2590 if (plt_hdr->sh_addralign)
2591 plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign /
2592 (num_relocations + 1) * plt_hdr->sh_addralign;
2593 else
2594 plt_entsize = plt_hdr->sh_size / (num_relocations + 1);
2595 }
2596
2597 elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize;
2598
2599 return std::make_pair(plt_entsize, plt_offset);
2600}
2601
2602static unsigned ParsePLTRelocations(
2603 Symtab *symbol_table, user_id_t start_id, unsigned rel_type,
2604 const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
2605 const ELFSectionHeader *plt_hdr, const ELFSectionHeader *sym_hdr,
2606 const lldb::SectionSP &plt_section_sp, DataExtractor &rel_data,
2607 DataExtractor &symtab_data, DataExtractor &strtab_data) {
2608 ELFRelocation rel(rel_type);
2609 ELFSymbol symbol;
2610 lldb::offset_t offset = 0;
2611
2612 uint64_t plt_offset, plt_entsize;
2613 std::tie(plt_entsize, plt_offset) =
2614 GetPltEntrySizeAndOffset(rel_hdr, plt_hdr);
2615 const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2616
2617 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
2618 reloc_info_fn reloc_type;
2619 reloc_info_fn reloc_symbol;
2620
2621 if (hdr->Is32Bit()) {
2622 reloc_type = ELFRelocation::RelocType32;
2623 reloc_symbol = ELFRelocation::RelocSymbol32;
2624 } else {
2625 reloc_type = ELFRelocation::RelocType64;
2626 reloc_symbol = ELFRelocation::RelocSymbol64;
2627 }
2628
2629 unsigned slot_type = hdr->GetRelocationJumpSlotType();
2630 unsigned i;
2631 for (i = 0; i < num_relocations; ++i) {
2632 if (rel.Parse(rel_data, &offset) == false)
2633 break;
2634
2635 if (reloc_type(rel) != slot_type)
2636 continue;
2637
2638 lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize;
2639 if (!symbol.Parse(symtab_data, &symbol_offset))
2640 break;
2641
2642 const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
2643 bool is_mangled =
2644 symbol_name ? (symbol_name[0] == '_' && symbol_name[1] == 'Z') : false;
2645 uint64_t plt_index = plt_offset + i * plt_entsize;
2646
2647 Symbol jump_symbol(
2648 i + start_id, // Symbol table index
2649 symbol_name, // symbol name.
2650 is_mangled, // is the symbol name mangled?
2651 eSymbolTypeTrampoline, // Type of this symbol
2652 false, // Is this globally visible?
2653 false, // Is this symbol debug info?
2654 true, // Is this symbol a trampoline?
2655 true, // Is this symbol artificial?
2656 plt_section_sp, // Section in which this symbol is defined or null.
2657 plt_index, // Offset in section or symbol value.
2658 plt_entsize, // Size in bytes of this symbol.
2659 true, // Size is valid
2660 false, // Contains linker annotations?
2661 0); // Symbol flags.
2662
2663 symbol_table->AddSymbol(jump_symbol);
2664 }
2665
2666 return i;
2667}
2668
2669unsigned
2670ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, user_id_t start_id,
2671 const ELFSectionHeaderInfo *rel_hdr,
2672 user_id_t rel_id) {
2673 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL)((rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL
) ? static_cast<void> (0) : __assert_fail ("rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2673, __PRETTY_FUNCTION__))
;
2674
2675 // The link field points to the associated symbol table.
2676 user_id_t symtab_id = rel_hdr->sh_link;
2677
2678 // If the link field doesn't point to the appropriate symbol name table then
2679 // try to find it by name as some compiler don't fill in the link fields.
2680 if (!symtab_id)
2681 symtab_id = GetSectionIndexByName(".dynsym");
2682
2683 // Get PLT section. We cannot use rel_hdr->sh_info, since current linkers
2684 // point that to the .got.plt or .got section instead of .plt.
2685 user_id_t plt_id = GetSectionIndexByName(".plt");
2686
2687 if (!symtab_id || !plt_id)
2688 return 0;
2689
2690 // Section ID's are ones based;
2691 symtab_id++;
2692 plt_id++;
2693
2694 const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id);
2695 if (!plt_hdr)
2696 return 0;
2697
2698 const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id);
2699 if (!sym_hdr)
2700 return 0;
2701
2702 SectionList *section_list = m_sections_ap.get();
2703 if (!section_list)
2704 return 0;
2705
2706 Section *rel_section = section_list->FindSectionByID(rel_id).get();
2707 if (!rel_section)
2708 return 0;
2709
2710 SectionSP plt_section_sp(section_list->FindSectionByID(plt_id));
2711 if (!plt_section_sp)
2712 return 0;
2713
2714 Section *symtab = section_list->FindSectionByID(symtab_id).get();
2715 if (!symtab)
2716 return 0;
2717
2718 // sh_link points to associated string table.
2719 Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link + 1).get();
2720 if (!strtab)
2721 return 0;
2722
2723 DataExtractor rel_data;
2724 if (!ReadSectionData(rel_section, rel_data))
2725 return 0;
2726
2727 DataExtractor symtab_data;
2728 if (!ReadSectionData(symtab, symtab_data))
2729 return 0;
2730
2731 DataExtractor strtab_data;
2732 if (!ReadSectionData(strtab, strtab_data))
2733 return 0;
2734
2735 unsigned rel_type = PLTRelocationType();
2736 if (!rel_type)
2737 return 0;
2738
2739 return ParsePLTRelocations(symbol_table, start_id, rel_type, &m_header,
2740 rel_hdr, plt_hdr, sym_hdr, plt_section_sp,
2741 rel_data, symtab_data, strtab_data);
2742}
2743
2744unsigned ObjectFileELF::RelocateSection(
2745 Symtab *symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
2746 const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr,
2747 DataExtractor &rel_data, DataExtractor &symtab_data,
2748 DataExtractor &debug_data, Section *rel_section) {
2749 ELFRelocation rel(rel_hdr->sh_type);
1
Calling constructor for 'ELFRelocation'
2750 lldb::addr_t offset = 0;
2751 const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
2752 typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
2753 reloc_info_fn reloc_type;
2754 reloc_info_fn reloc_symbol;
2755
2756 if (hdr->Is32Bit()) {
2757 reloc_type = ELFRelocation::RelocType32;
2758 reloc_symbol = ELFRelocation::RelocSymbol32;
2759 } else {
2760 reloc_type = ELFRelocation::RelocType64;
2761 reloc_symbol = ELFRelocation::RelocSymbol64;
2762 }
2763
2764 for (unsigned i = 0; i < num_relocations; ++i) {
2765 if (rel.Parse(rel_data, &offset) == false)
2766 break;
2767
2768 Symbol *symbol = NULL__null;
2769
2770 if (hdr->Is32Bit()) {
2771 switch (reloc_type(rel)) {
2772 case R_386_32:
2773 case R_386_PC32:
2774 default:
2775 assert(false && "unexpected relocation type")((false && "unexpected relocation type") ? static_cast
<void> (0) : __assert_fail ("false && \"unexpected relocation type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2775, __PRETTY_FUNCTION__))
;
2776 }
2777 } else {
2778 switch (reloc_type(rel)) {
2779 case R_X86_64_64: {
2780 symbol = symtab->FindSymbolByID(reloc_symbol(rel));
2781 if (symbol) {
2782 addr_t value = symbol->GetAddressRef().GetFileAddress();
2783 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2784 uint64_t *dst = reinterpret_cast<uint64_t *>(
2785 data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
2786 ELFRelocation::RelocOffset64(rel));
2787 *dst = value + ELFRelocation::RelocAddend64(rel);
2788 }
2789 break;
2790 }
2791 case R_X86_64_32:
2792 case R_X86_64_32S: {
2793 symbol = symtab->FindSymbolByID(reloc_symbol(rel));
2794 if (symbol) {
2795 addr_t value = symbol->GetAddressRef().GetFileAddress();
2796 value += ELFRelocation::RelocAddend32(rel);
2797 assert((((reloc_type(rel) == R_X86_64_32 && (value <= (4294967295U
))) || (reloc_type(rel) == R_X86_64_32S && ((int64_t)
value <= (2147483647) && (int64_t)value >= (-2147483647
-1)))) ? static_cast<void> (0) : __assert_fail ("(reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || (reloc_type(rel) == R_X86_64_32S && ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2800, __PRETTY_FUNCTION__))
2798 (reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) ||(((reloc_type(rel) == R_X86_64_32 && (value <= (4294967295U
))) || (reloc_type(rel) == R_X86_64_32S && ((int64_t)
value <= (2147483647) && (int64_t)value >= (-2147483647
-1)))) ? static_cast<void> (0) : __assert_fail ("(reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || (reloc_type(rel) == R_X86_64_32S && ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2800, __PRETTY_FUNCTION__))
2799 (reloc_type(rel) == R_X86_64_32S &&(((reloc_type(rel) == R_X86_64_32 && (value <= (4294967295U
))) || (reloc_type(rel) == R_X86_64_32S && ((int64_t)
value <= (2147483647) && (int64_t)value >= (-2147483647
-1)))) ? static_cast<void> (0) : __assert_fail ("(reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || (reloc_type(rel) == R_X86_64_32S && ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2800, __PRETTY_FUNCTION__))
2800 ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN)))(((reloc_type(rel) == R_X86_64_32 && (value <= (4294967295U
))) || (reloc_type(rel) == R_X86_64_32S && ((int64_t)
value <= (2147483647) && (int64_t)value >= (-2147483647
-1)))) ? static_cast<void> (0) : __assert_fail ("(reloc_type(rel) == R_X86_64_32 && (value <= UINT32_MAX)) || (reloc_type(rel) == R_X86_64_32S && ((int64_t)value <= INT32_MAX && (int64_t)value >= INT32_MIN))"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2800, __PRETTY_FUNCTION__))
;
2801 uint32_t truncated_addr = (value & 0xFFFFFFFF);
2802 DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
2803 uint32_t *dst = reinterpret_cast<uint32_t *>(
2804 data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
2805 ELFRelocation::RelocOffset32(rel));
2806 *dst = truncated_addr;
2807 }
2808 break;
2809 }
2810 case R_X86_64_PC32:
2811 default:
2812 assert(false && "unexpected relocation type")((false && "unexpected relocation type") ? static_cast
<void> (0) : __assert_fail ("false && \"unexpected relocation type\""
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2812, __PRETTY_FUNCTION__))
;
2813 }
2814 }
2815 }
2816
2817 return 0;
2818}
2819
2820unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr,
2821 user_id_t rel_id) {
2822 assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL)((rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL
) ? static_cast<void> (0) : __assert_fail ("rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL"
, "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2822, __PRETTY_FUNCTION__))
;
2823
2824 // Parse in the section list if needed.
2825 SectionList *section_list = GetSectionList();
2826 if (!section_list)
2827 return 0;
2828
2829 // Section ID's are ones based.
2830 user_id_t symtab_id = rel_hdr->sh_link + 1;
2831 user_id_t debug_id = rel_hdr->sh_info + 1;
2832
2833 const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
2834 if (!symtab_hdr)
2835 return 0;
2836
2837 const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id);
2838 if (!debug_hdr)
2839 return 0;
2840
2841 Section *rel = section_list->FindSectionByID(rel_id).get();
2842 if (!rel)
2843 return 0;
2844
2845 Section *symtab = section_list->FindSectionByID(symtab_id).get();
2846 if (!symtab)
2847 return 0;
2848
2849 Section *debug = section_list->FindSectionByID(debug_id).get();
2850 if (!debug)
2851 return 0;
2852
2853 DataExtractor rel_data;
2854 DataExtractor symtab_data;
2855 DataExtractor debug_data;
2856
2857 if (ReadSectionData(rel, rel_data) && ReadSectionData(symtab, symtab_data) &&
2858 ReadSectionData(debug, debug_data)) {
2859 RelocateSection(m_symtab_ap.get(), &m_header, rel_hdr, symtab_hdr,
2860 debug_hdr, rel_data, symtab_data, debug_data, debug);
2861 }
2862
2863 return 0;
2864}
2865
2866Symtab *ObjectFileELF::GetSymtab() {
2867 ModuleSP module_sp(GetModule());
2868 if (!module_sp)
2869 return NULL__null;
2870
2871 // We always want to use the main object file so we (hopefully) only have one
2872 // cached copy
2873 // of our symtab, dynamic sections, etc.
2874 ObjectFile *module_obj_file = module_sp->GetObjectFile();
2875 if (module_obj_file && module_obj_file != this)
2876 return module_obj_file->GetSymtab();
2877
2878 if (m_symtab_ap.get() == NULL__null) {
2879 SectionList *section_list = module_sp->GetSectionList();
2880 if (!section_list)
2881 return NULL__null;
2882
2883 uint64_t symbol_id = 0;
2884 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
2885
2886 // Sharable objects and dynamic executables usually have 2 distinct symbol
2887 // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
2888 // smaller
2889 // version of the symtab that only contains global symbols. The information
2890 // found
2891 // in the dynsym is therefore also found in the symtab, while the reverse is
2892 // not
2893 // necessarily true.
2894 Section *symtab =
2895 section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get();
2896 if (!symtab) {
2897 // The symtab section is non-allocable and can be stripped, so if it
2898 // doesn't exist
2899 // then use the dynsym section which should always be there.
2900 symtab =
2901 section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true)
2902 .get();
2903 }
2904 if (symtab) {
2905 m_symtab_ap.reset(new Symtab(symtab->GetObjectFile()));
2906 symbol_id += ParseSymbolTable(m_symtab_ap.get(), symbol_id, symtab);
2907 }
2908
2909 // DT_JMPREL
2910 // If present, this entry's d_ptr member holds the address of
2911 // relocation
2912 // entries associated solely with the procedure linkage table.
2913 // Separating
2914 // these relocation entries lets the dynamic linker ignore them during
2915 // process initialization, if lazy binding is enabled. If this entry is
2916 // present, the related entries of types DT_PLTRELSZ and DT_PLTREL must
2917 // also be present.
2918 const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL);
2919 if (symbol) {
2920 // Synthesize trampoline symbols to help navigate the PLT.
2921 addr_t addr = symbol->d_ptr;
2922 Section *reloc_section =
2923 section_list->FindSectionContainingFileAddress(addr).get();
2924 if (reloc_section) {
2925 user_id_t reloc_id = reloc_section->GetID();
2926 const ELFSectionHeaderInfo *reloc_header =
2927 GetSectionHeaderByIndex(reloc_id);
2928 assert(reloc_header)((reloc_header) ? static_cast<void> (0) : __assert_fail
("reloc_header", "/tmp/buildd/llvm-toolchain-snapshot-5.0~svn298304/tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, 2928, __PRETTY_FUNCTION__))
;
2929
2930 if (m_symtab_ap == nullptr)
2931 m_symtab_ap.reset(new Symtab(reloc_section->GetObjectFile()));
2932
2933 ParseTrampolineSymbols(m_symtab_ap.get(), symbol_id, reloc_header,
2934 reloc_id);
2935 }
2936 }
2937
2938 DWARFCallFrameInfo *eh_frame = GetUnwindTable().GetEHFrameInfo();
2939 if (eh_frame) {
2940 if (m_symtab_ap == nullptr)
2941 m_symtab_ap.reset(new Symtab(this));
2942 ParseUnwindSymbols(m_symtab_ap.get(), eh_frame);
2943 }
2944
2945 // If we still don't have any symtab then create an empty instance to avoid
2946 // do the section
2947 // lookup next time.
2948 if (m_symtab_ap == nullptr)
2949 m_symtab_ap.reset(new Symtab(this));
2950
2951 m_symtab_ap->CalculateSymbolSizes();
2952 }
2953
2954 for (SectionHeaderCollIter I = m_section_headers.begin();
2955 I != m_section_headers.end(); ++I) {
2956 if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) {
2957 if (CalculateType() == eTypeObjectFile) {
2958 const char *section_name = I->section_name.AsCString("");
2959 if (strstr(section_name, ".rela.debug") ||
2960 strstr(section_name, ".rel.debug")) {
2961 const ELFSectionHeader &reloc_header = *I;
2962 user_id_t reloc_id = SectionIndex(I);
2963 RelocateDebugSections(&reloc_header, reloc_id);
2964 }
2965 }
2966 }
2967 }
2968 return m_symtab_ap.get();
2969}
2970
2971void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table,
2972 DWARFCallFrameInfo *eh_frame) {
2973 SectionList *section_list = GetSectionList();
2974 if (!section_list)
2975 return;
2976
2977 // First we save the new symbols into a separate list and add them to the
2978 // symbol table after
2979 // we colleced all symbols we want to add. This is neccessary because adding a
2980 // new symbol
2981 // invalidates the internal index of the symtab what causing the next lookup
2982 // to be slow because
2983 // it have to recalculate the index first.
2984 std::vector<Symbol> new_symbols;
2985
2986 eh_frame->ForEachFDEEntries([this, symbol_table, section_list, &new_symbols](
2987 lldb::addr_t file_addr, uint32_t size, dw_offset_t) {
2988 Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr);
2989 if (symbol) {
2990 if (!symbol->GetByteSizeIsValid()) {
2991 symbol->SetByteSize(size);
2992 symbol->SetSizeIsSynthesized(true);
2993 }
2994 } else {
2995 SectionSP section_sp =
2996 section_list->FindSectionContainingFileAddress(file_addr);
2997 if (section_sp) {
2998 addr_t offset = file_addr - section_sp->GetFileAddress();
2999 const char *symbol_name = GetNextSyntheticSymbolName().GetCString();
3000 uint64_t symbol_id = symbol_table->GetNumSymbols();
3001 Symbol eh_symbol(
3002 symbol_id, // Symbol table index.
3003 symbol_name, // Symbol name.
3004 false, // Is the symbol name mangled?
3005 eSymbolTypeCode, // Type of this symbol.
3006 true, // Is this globally visible?
3007 false, // Is this symbol debug info?
3008 false, // Is this symbol a trampoline?
3009 true, // Is this symbol artificial?
3010 section_sp, // Section in which this symbol is defined or null.
3011 offset, // Offset in section or symbol value.
3012 0, // Size: Don't specify the size as an FDE can
3013 false, // Size is valid: cover multiple symbols.
3014 false, // Contains linker annotations?
3015 0); // Symbol flags.
3016 new_symbols.push_back(eh_symbol);
3017 }
3018 }
3019 return true;
3020 });
3021
3022 for (const Symbol &s : new_symbols)
3023 symbol_table->AddSymbol(s);
3024}
3025
3026bool ObjectFileELF::IsStripped() {
3027 // TODO: determine this for ELF
3028 return false;
3029}
3030
3031//===----------------------------------------------------------------------===//
3032// Dump
3033//
3034// Dump the specifics of the runtime file container (such as any headers
3035// segments, sections, etc).
3036//----------------------------------------------------------------------
3037void ObjectFileELF::Dump(Stream *s) {
3038 ModuleSP module_sp(GetModule());
3039 if (!module_sp) {
3040 return;
3041 }
3042
3043 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
3044 s->Printf("%p: ", static_cast<void *>(this));
3045 s->Indent();
3046 s->PutCString("ObjectFileELF");
3047
3048 ArchSpec header_arch;
3049 GetArchitecture(header_arch);
3050
3051 *s << ", file = '" << m_file
3052 << "', arch = " << header_arch.GetArchitectureName() << "\n";
3053
3054 DumpELFHeader(s, m_header);
3055 s->EOL();
3056 DumpELFProgramHeaders(s);
3057 s->EOL();
3058 DumpELFSectionHeaders(s);
3059 s->EOL();
3060 SectionList *section_list = GetSectionList();
3061 if (section_list)
3062 section_list->Dump(s, NULL__null, true, UINT32_MAX(4294967295U));
3063 Symtab *symtab = GetSymtab();
3064 if (symtab)
3065 symtab->Dump(s, NULL__null, eSortOrderNone);
3066 s->EOL();
3067 DumpDependentModules(s);
3068 s->EOL();
3069}
3070
3071//----------------------------------------------------------------------
3072// DumpELFHeader
3073//
3074// Dump the ELF header to the specified output stream
3075//----------------------------------------------------------------------
3076void ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) {
3077 s->PutCString("ELF Header\n");
3078 s->Printf("e_ident[EI_MAG0 ] = 0x%2.2x\n", header.e_ident[EI_MAG0]);
3079 s->Printf("e_ident[EI_MAG1 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG1],
3080 header.e_ident[EI_MAG1]);
3081 s->Printf("e_ident[EI_MAG2 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG2],
3082 header.e_ident[EI_MAG2]);
3083 s->Printf("e_ident[EI_MAG3 ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG3],
3084 header.e_ident[EI_MAG3]);
3085
3086 s->Printf("e_ident[EI_CLASS ] = 0x%2.2x\n", header.e_ident[EI_CLASS]);
3087 s->Printf("e_ident[EI_DATA ] = 0x%2.2x ", header.e_ident[EI_DATA]);
3088 DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]);
3089 s->Printf("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]);
3090 s->Printf("e_ident[EI_PAD ] = 0x%2.2x\n", header.e_ident[EI_PAD]);
3091
3092 s->Printf("e_type = 0x%4.4x ", header.e_type);
3093 DumpELFHeader_e_type(s, header.e_type);
3094 s->Printf("\ne_machine = 0x%4.4x\n", header.e_machine);
3095 s->Printf("e_version = 0x%8.8x\n", header.e_version);
3096 s->Printf("e_entry = 0x%8.8" PRIx64"l" "x" "\n", header.e_entry);
3097 s->Printf("e_phoff = 0x%8.8" PRIx64"l" "x" "\n", header.e_phoff);
3098 s->Printf("e_shoff = 0x%8.8" PRIx64"l" "x" "\n", header.e_shoff);
3099 s->Printf("e_flags = 0x%8.8x\n", header.e_flags);
3100 s->Printf("e_ehsize = 0x%4.4x\n", header.e_ehsize);
3101 s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize);
3102 s->Printf("e_phnum = 0x%8.8x\n", header.e_phnum);
3103 s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize);
3104 s->Printf("e_shnum = 0x%8.8x\n", header.e_shnum);
3105 s->Printf("e_shstrndx = 0x%8.8x\n", header.e_shstrndx);
3106}
3107
3108//----------------------------------------------------------------------
3109// DumpELFHeader_e_type
3110//
3111// Dump an token value for the ELF header member e_type
3112//----------------------------------------------------------------------
3113void ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) {
3114 switch (e_type) {
3115 case ET_NONE:
3116 *s << "ET_NONE";
3117 break;
3118 case ET_REL:
3119 *s << "ET_REL";
3120 break;
3121 case ET_EXEC:
3122 *s << "ET_EXEC";
3123 break;
3124 case ET_DYN:
3125 *s << "ET_DYN";
3126 break;
3127 case ET_CORE:
3128 *s << "ET_CORE";
3129 break;
3130 default:
3131 break;
3132 }
3133}
3134
3135//----------------------------------------------------------------------
3136// DumpELFHeader_e_ident_EI_DATA
3137//
3138// Dump an token value for the ELF header member e_ident[EI_DATA]
3139//----------------------------------------------------------------------
3140void ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s,
3141 unsigned char ei_data) {
3142 switch (ei_data) {
3143 case ELFDATANONE:
3144 *s << "ELFDATANONE";
3145 break;
3146 case ELFDATA2LSB:
3147 *s << "ELFDATA2LSB - Little Endian";
3148 break;
3149 case ELFDATA2MSB:
3150 *s << "ELFDATA2MSB - Big Endian";
3151 break;
3152 default:
3153 break;
3154 }
3155}
3156
3157//----------------------------------------------------------------------
3158// DumpELFProgramHeader
3159//
3160// Dump a single ELF program header to the specified output stream
3161//----------------------------------------------------------------------
3162void ObjectFileELF::DumpELFProgramHeader(Stream *s,
3163 const ELFProgramHeader &ph) {
3164 DumpELFProgramHeader_p_type(s, ph.p_type);
3165 s->Printf(" %8.8" PRIx64"l" "x" " %8.8" PRIx64"l" "x" " %8.8" PRIx64"l" "x", ph.p_offset,
3166 ph.p_vaddr, ph.p_paddr);
3167 s->Printf(" %8.8" PRIx64"l" "x" " %8.8" PRIx64"l" "x" " %8.8x (", ph.p_filesz, ph.p_memsz,
3168 ph.p_flags);
3169
3170 DumpELFProgramHeader_p_flags(s, ph.p_flags);
3171 s->Printf(") %8.8" PRIx64"l" "x", ph.p_align);
3172}
3173
3174//----------------------------------------------------------------------
3175// DumpELFProgramHeader_p_type
3176//
3177// Dump an token value for the ELF program header member p_type which
3178// describes the type of the program header
3179// ----------------------------------------------------------------------
3180void ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) {
3181 const int kStrWidth = 15;
3182 switch (p_type) {
3183 CASE_AND_STREAM(s, PT_NULL, kStrWidth)case PT_NULL: s->Printf("%-*s", kStrWidth, "PT_NULL"); break
;
;
3184 CASE_AND_STREAM(s, PT_LOAD, kStrWidth)case PT_LOAD: s->Printf("%-*s", kStrWidth, "PT_LOAD"); break
;
;
3185 CASE_AND_STREAM(s, PT_DYNAMIC, kStrWidth)case PT_DYNAMIC: s->Printf("%-*s", kStrWidth, "PT_DYNAMIC"
); break;
;
3186 CASE_AND_STREAM(s, PT_INTERP, kStrWidth)case PT_INTERP: s->Printf("%-*s", kStrWidth, "PT_INTERP");
break;
;
3187 CASE_AND_STREAM(s, PT_NOTE, kStrWidth)case PT_NOTE: s->Printf("%-*s", kStrWidth, "PT_NOTE"); break
;
;
3188 CASE_AND_STREAM(s, PT_SHLIB, kStrWidth)case PT_SHLIB: s->Printf("%-*s", kStrWidth, "PT_SHLIB"); break
;
;
3189 CASE_AND_STREAM(s, PT_PHDR, kStrWidth)case PT_PHDR: s->Printf("%-*s", kStrWidth, "PT_PHDR"); break
;
;
3190 CASE_AND_STREAM(s, PT_TLS, kStrWidth)case PT_TLS: s->Printf("%-*s", kStrWidth, "PT_TLS"); break
;
;
3191 CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth)case PT_GNU_EH_FRAME: s->Printf("%-*s", kStrWidth, "PT_GNU_EH_FRAME"
); break;
;
3192 default:
3193 s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, "");
3194 break;
3195 }
3196}
3197
3198//----------------------------------------------------------------------
3199// DumpELFProgramHeader_p_flags
3200//
3201// Dump an token value for the ELF program header member p_flags
3202//----------------------------------------------------------------------
3203void ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) {
3204 *s << ((p_flags & PF_X) ? "PF_X" : " ")
3205 << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ')
3206 << ((p_flags & PF_W) ? "PF_W" : " ")
3207 << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ')
3208 << ((p_flags & PF_R) ? "PF_R" : " ");
3209}
3210
3211//----------------------------------------------------------------------
3212// DumpELFProgramHeaders
3213//
3214// Dump all of the ELF program header to the specified output stream
3215//----------------------------------------------------------------------
3216void ObjectFileELF::DumpELFProgramHeaders(Stream *s) {
3217 if (!ParseProgramHeaders())
3218 return;
3219
3220 s->PutCString("Program Headers\n");
3221 s->PutCString("IDX p_type p_offset p_vaddr p_paddr "
3222 "p_filesz p_memsz p_flags p_align\n");
3223 s->PutCString("==== --------------- -------- -------- -------- "
3224 "-------- -------- ------------------------- --------\n");
3225
3226 uint32_t idx = 0;
3227 for (ProgramHeaderCollConstIter I = m_program_headers.begin();
3228 I != m_program_headers.end(); ++I, ++idx) {
3229 s->Printf("[%2u] ", idx);
3230 ObjectFileELF::DumpELFProgramHeader(s, *I);
3231 s->EOL();
3232 }
3233}
3234
3235//----------------------------------------------------------------------
3236// DumpELFSectionHeader
3237//
3238// Dump a single ELF section header to the specified output stream
3239//----------------------------------------------------------------------
3240void ObjectFileELF::DumpELFSectionHeader(Stream *s,
3241 const ELFSectionHeaderInfo &sh) {
3242 s->Printf("%8.8x ", sh.sh_name);
3243 DumpELFSectionHeader_sh_type(s, sh.sh_type);
3244 s->Printf(" %8.8" PRIx64"l" "x" " (", sh.sh_flags);
3245 DumpELFSectionHeader_sh_flags(s, sh.sh_flags);
3246 s->Printf(") %8.8" PRIx64"l" "x" " %8.8" PRIx64"l" "x" " %8.8" PRIx64"l" "x", sh.sh_addr,
3247 sh.sh_offset, sh.sh_size);
3248 s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info);
3249 s->Printf(" %8.8" PRIx64"l" "x" " %8.8" PRIx64"l" "x", sh.sh_addralign, sh.sh_entsize);
3250}
3251
3252//----------------------------------------------------------------------
3253// DumpELFSectionHeader_sh_type
3254//
3255// Dump an token value for the ELF section header member sh_type which
3256// describes the type of the section
3257//----------------------------------------------------------------------
3258void ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) {
3259 const int kStrWidth = 12;
3260 switch (sh_type) {
3261 CASE_AND_STREAM(s, SHT_NULL, kStrWidth)case SHT_NULL: s->Printf("%-*s", kStrWidth, "SHT_NULL"); break
;
;
3262 CASE_AND_STREAM(s, SHT_PROGBITS, kStrWidth)case SHT_PROGBITS: s->Printf("%-*s", kStrWidth, "SHT_PROGBITS"
); break;
;
3263 CASE_AND_STREAM(s, SHT_SYMTAB, kStrWidth)case SHT_SYMTAB: s->Printf("%-*s", kStrWidth, "SHT_SYMTAB"
); break;
;
3264 CASE_AND_STREAM(s, SHT_STRTAB, kStrWidth)case SHT_STRTAB: s->Printf("%-*s", kStrWidth, "SHT_STRTAB"
); break;
;
3265 CASE_AND_STREAM(s, SHT_RELA, kStrWidth)case SHT_RELA: s->Printf("%-*s", kStrWidth, "SHT_RELA"); break
;
;
3266 CASE_AND_STREAM(s, SHT_HASH, kStrWidth)case SHT_HASH: s->Printf("%-*s", kStrWidth, "SHT_HASH"); break
;
;
3267 CASE_AND_STREAM(s, SHT_DYNAMIC, kStrWidth)case SHT_DYNAMIC: s->Printf("%-*s", kStrWidth, "SHT_DYNAMIC"
); break;
;
3268 CASE_AND_STREAM(s, SHT_NOTE, kStrWidth)case SHT_NOTE: s->Printf("%-*s", kStrWidth, "SHT_NOTE"); break
;
;
3269 CASE_AND_STREAM(s, SHT_NOBITS, kStrWidth)case SHT_NOBITS: s->Printf("%-*s", kStrWidth, "SHT_NOBITS"
); break;
;
3270 CASE_AND_STREAM(s, SHT_REL, kStrWidth)case SHT_REL: s->Printf("%-*s", kStrWidth, "SHT_REL"); break
;
;
3271 CASE_AND_STREAM(s, SHT_SHLIB, kStrWidth)case SHT_SHLIB: s->Printf("%-*s", kStrWidth, "SHT_SHLIB");
break;
;
3272 CASE_AND_STREAM(s, SHT_DYNSYM, kStrWidth)case SHT_DYNSYM: s->Printf("%-*s", kStrWidth, "SHT_DYNSYM"
); break;
;
3273 CASE_AND_STREAM(s, SHT_LOPROC, kStrWidth)case SHT_LOPROC: s->Printf("%-*s", kStrWidth, "SHT_LOPROC"
); break;
;
3274 CASE_AND_STREAM(s, SHT_HIPROC, kStrWidth)case SHT_HIPROC: s->Printf("%-*s", kStrWidth, "SHT_HIPROC"
); break;
;
3275 CASE_AND_STREAM(s, SHT_LOUSER, kStrWidth)case SHT_LOUSER: s->Printf("%-*s", kStrWidth, "SHT_LOUSER"
); break;
;
3276 CASE_AND_STREAM(s, SHT_HIUSER, kStrWidth)case SHT_HIUSER: s->Printf("%-*s", kStrWidth, "SHT_HIUSER"
); break;
;
3277 default:
3278 s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, "");
3279 break;
3280 }
3281}
3282
3283//----------------------------------------------------------------------
3284// DumpELFSectionHeader_sh_flags
3285//
3286// Dump an token value for the ELF section header member sh_flags
3287//----------------------------------------------------------------------
3288void ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s,
3289 elf_xword sh_flags) {
3290 *s << ((sh_flags & SHF_WRITE) ? "WRITE" : " ")
3291 << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ')
3292 << ((sh_flags & SHF_ALLOC) ? "ALLOC" : " ")
3293 << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ')
3294 << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : " ");
3295}
3296
3297//----------------------------------------------------------------------
3298// DumpELFSectionHeaders
3299//
3300// Dump all of the ELF section header to the specified output stream
3301//----------------------------------------------------------------------
3302void ObjectFileELF::DumpELFSectionHeaders(Stream *s) {
3303 if (!ParseSectionHeaders())
3304 return;
3305
3306 s->PutCString("Section Headers\n");
3307 s->PutCString("IDX name type flags "
3308 "addr offset size link info addralgn "
3309 "entsize Name\n");
3310 s->PutCString("==== -------- ------------ -------------------------------- "
3311 "-------- -------- -------- -------- -------- -------- "
3312 "-------- ====================\n");
3313
3314 uint32_t idx = 0;
3315 for (SectionHeaderCollConstIter I = m_section_headers.begin();
3316 I != m_section_headers.end(); ++I, ++idx) {
3317 s->Printf("[%2u] ", idx);
3318 ObjectFileELF::DumpELFSectionHeader(s, *I);
3319 const char *section_name = I->section_name.AsCString("");
3320 if (section_name)
3321 *s << ' ' << section_name << "\n";
3322 }
3323}
3324
3325void ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) {
3326 size_t num_modules = ParseDependentModules();
3327
3328 if (num_modules > 0) {
3329 s->PutCString("Dependent Modules:\n");
3330 for (unsigned i = 0; i < num_modules; ++i) {
3331 const FileSpec &spec = m_filespec_ap->GetFileSpecAtIndex(i);
3332 s->Printf(" %s\n", spec.GetFilename().GetCString());
3333 }
3334 }
3335}
3336
3337bool ObjectFileELF::GetArchitecture(ArchSpec &arch) {
3338 if (!ParseHeader())
3339 return false;
3340
3341 if (m_section_headers.empty()) {
3342 // Allow elf notes to be parsed which may affect the detected architecture.
3343 ParseSectionHeaders();
3344 }
3345
3346 if (CalculateType() == eTypeCoreFile &&
3347 m_arch_spec.TripleOSIsUnspecifiedUnknown()) {
3348 // Core files don't have section headers yet they have PT_NOTE program
3349 // headers
3350 // that might shed more light on the architecture
3351 if (ParseProgramHeaders()) {
3352 for (size_t i = 0, count = GetProgramHeaderCount(); i < count; ++i) {
3353 const elf::ELFProgramHeader *header = GetProgramHeaderByIndex(i);
3354 if (header && header->p_type == PT_NOTE && header->p_offset != 0 &&
3355 header->p_filesz > 0) {
3356 DataExtractor data;
3357 if (data.SetData(m_data, header->p_offset, header->p_filesz) ==
3358 header->p_filesz) {
3359 lldb_private::UUID uuid;
3360 RefineModuleDetailsFromNote(data, m_arch_spec, uuid);
3361 }
3362 }
3363 }
3364 }
3365 }
3366 arch = m_arch_spec;
3367 return true;
3368}
3369
3370ObjectFile::Type ObjectFileELF::CalculateType() {
3371 switch (m_header.e_type) {
3372 case llvm::ELF::ET_NONE:
3373 // 0 - No file type
3374 return eTypeUnknown;
3375
3376 case llvm::ELF::ET_REL:
3377 // 1 - Relocatable file
3378 return eTypeObjectFile;
3379
3380 case llvm::ELF::ET_EXEC:
3381 // 2 - Executable file
3382 return eTypeExecutable;
3383
3384 case llvm::ELF::ET_DYN:
3385 // 3 - Shared object file
3386 return eTypeSharedLibrary;
3387
3388 case ET_CORE:
3389 // 4 - Core file
3390 return eTypeCoreFile;
3391
3392 default:
3393 break;
3394 }
3395 return eTypeUnknown;
3396}
3397
3398ObjectFile::Strata ObjectFileELF::CalculateStrata() {
3399 switch (m_header.e_type) {
3400 case llvm::ELF::ET_NONE:
3401 // 0 - No file type
3402 return eStrataUnknown;
3403
3404 case llvm::ELF::ET_REL:
3405 // 1 - Relocatable file
3406 return eStrataUnknown;
3407
3408 case llvm::ELF::ET_EXEC:
3409 // 2 - Executable file
3410 // TODO: is there any way to detect that an executable is a kernel
3411 // related executable by inspecting the program headers, section
3412 // headers, symbols, or any other flag bits???
3413 return eStrataUser;
3414
3415 case llvm::ELF::ET_DYN:
3416 // 3 - Shared object file
3417 // TODO: is there any way to detect that an shared library is a kernel
3418 // related executable by inspecting the program headers, section
3419 // headers, symbols, or any other flag bits???
3420 return eStrataUnknown;
3421
3422 case ET_CORE:
3423 // 4 - Core file
3424 // TODO: is there any way to detect that an core file is a kernel
3425 // related executable by inspecting the program headers, section
3426 // headers, symbols, or any other flag bits???
3427 return eStrataUnknown;
3428
3429 default:
3430 break;
3431 }
3432 return eStrataUnknown;
3433}