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