Bug Summary

File:tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
Warning:line 2336, column 7
Called C++ object pointer is null

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