LLVM  13.0.0git
ELF.cpp
Go to the documentation of this file.
1 //===- ELF.cpp - ELF object file implementation ---------------------------===//
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 "llvm/Object/ELF.h"
10 #include "llvm/BinaryFormat/ELF.h"
12 
13 using namespace llvm;
14 using namespace object;
15 
16 #define STRINGIFY_ENUM_CASE(ns, name) \
17  case ns::name: \
18  return #name;
19 
20 #define ELF_RELOC(name, value) STRINGIFY_ENUM_CASE(ELF, name)
21 
23  uint32_t Type) {
24  switch (Machine) {
25  case ELF::EM_68K:
26  switch (Type) {
27 #include "llvm/BinaryFormat/ELFRelocs/M68k.def"
28  default:
29  break;
30  }
31  break;
32  case ELF::EM_X86_64:
33  switch (Type) {
34 #include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
35  default:
36  break;
37  }
38  break;
39  case ELF::EM_386:
40  case ELF::EM_IAMCU:
41  switch (Type) {
42 #include "llvm/BinaryFormat/ELFRelocs/i386.def"
43  default:
44  break;
45  }
46  break;
47  case ELF::EM_MIPS:
48  switch (Type) {
49 #include "llvm/BinaryFormat/ELFRelocs/Mips.def"
50  default:
51  break;
52  }
53  break;
54  case ELF::EM_AARCH64:
55  switch (Type) {
56 #include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
57  default:
58  break;
59  }
60  break;
61  case ELF::EM_ARM:
62  switch (Type) {
63 #include "llvm/BinaryFormat/ELFRelocs/ARM.def"
64  default:
65  break;
66  }
67  break;
70  switch (Type) {
71 #include "llvm/BinaryFormat/ELFRelocs/ARC.def"
72  default:
73  break;
74  }
75  break;
76  case ELF::EM_AVR:
77  switch (Type) {
78 #include "llvm/BinaryFormat/ELFRelocs/AVR.def"
79  default:
80  break;
81  }
82  break;
83  case ELF::EM_HEXAGON:
84  switch (Type) {
85 #include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
86  default:
87  break;
88  }
89  break;
90  case ELF::EM_LANAI:
91  switch (Type) {
92 #include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
93  default:
94  break;
95  }
96  break;
97  case ELF::EM_PPC:
98  switch (Type) {
99 #include "llvm/BinaryFormat/ELFRelocs/PowerPC.def"
100  default:
101  break;
102  }
103  break;
104  case ELF::EM_PPC64:
105  switch (Type) {
106 #include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
107  default:
108  break;
109  }
110  break;
111  case ELF::EM_RISCV:
112  switch (Type) {
113 #include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
114  default:
115  break;
116  }
117  break;
118  case ELF::EM_S390:
119  switch (Type) {
120 #include "llvm/BinaryFormat/ELFRelocs/SystemZ.def"
121  default:
122  break;
123  }
124  break;
125  case ELF::EM_SPARC:
126  case ELF::EM_SPARC32PLUS:
127  case ELF::EM_SPARCV9:
128  switch (Type) {
129 #include "llvm/BinaryFormat/ELFRelocs/Sparc.def"
130  default:
131  break;
132  }
133  break;
134  case ELF::EM_AMDGPU:
135  switch (Type) {
136 #include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
137  default:
138  break;
139  }
140  break;
141  case ELF::EM_BPF:
142  switch (Type) {
143 #include "llvm/BinaryFormat/ELFRelocs/BPF.def"
144  default:
145  break;
146  }
147  break;
148  case ELF::EM_MSP430:
149  switch (Type) {
150 #include "llvm/BinaryFormat/ELFRelocs/MSP430.def"
151  default:
152  break;
153  }
154  break;
155  case ELF::EM_VE:
156  switch (Type) {
157 #include "llvm/BinaryFormat/ELFRelocs/VE.def"
158  default:
159  break;
160  }
161  break;
162  case ELF::EM_CSKY:
163  switch (Type) {
164 #include "llvm/BinaryFormat/ELFRelocs/CSKY.def"
165  default:
166  break;
167  }
168  break;
169  default:
170  break;
171  }
172  return "Unknown";
173 }
174 
175 #undef ELF_RELOC
176 
178  switch (Machine) {
179  case ELF::EM_X86_64:
180  return ELF::R_X86_64_RELATIVE;
181  case ELF::EM_386:
182  case ELF::EM_IAMCU:
183  return ELF::R_386_RELATIVE;
184  case ELF::EM_MIPS:
185  break;
186  case ELF::EM_AARCH64:
187  return ELF::R_AARCH64_RELATIVE;
188  case ELF::EM_ARM:
189  return ELF::R_ARM_RELATIVE;
190  case ELF::EM_ARC_COMPACT:
192  return ELF::R_ARC_RELATIVE;
193  case ELF::EM_AVR:
194  break;
195  case ELF::EM_HEXAGON:
196  return ELF::R_HEX_RELATIVE;
197  case ELF::EM_LANAI:
198  break;
199  case ELF::EM_PPC:
200  break;
201  case ELF::EM_PPC64:
202  return ELF::R_PPC64_RELATIVE;
203  case ELF::EM_RISCV:
204  return ELF::R_RISCV_RELATIVE;
205  case ELF::EM_S390:
206  return ELF::R_390_RELATIVE;
207  case ELF::EM_SPARC:
208  case ELF::EM_SPARC32PLUS:
209  case ELF::EM_SPARCV9:
210  return ELF::R_SPARC_RELATIVE;
211  case ELF::EM_CSKY:
212  return ELF::R_CKCORE_RELATIVE;
213  case ELF::EM_AMDGPU:
214  break;
215  case ELF::EM_BPF:
216  break;
217  default:
218  break;
219  }
220  return 0;
221 }
222 
224  switch (Machine) {
225  case ELF::EM_ARM:
226  switch (Type) {
232  }
233  break;
234  case ELF::EM_HEXAGON:
235  switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
236  break;
237  case ELF::EM_X86_64:
238  switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
239  break;
240  case ELF::EM_MIPS:
241  case ELF::EM_MIPS_RS3_LE:
242  switch (Type) {
247  }
248  break;
249  case ELF::EM_RISCV:
250  switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_RISCV_ATTRIBUTES); }
251  break;
252  default:
253  break;
254  }
255 
256  switch (Type) {
292  default:
293  return "Unknown";
294  }
295 }
296 
297 template <class ELFT>
298 std::vector<typename ELFT::Rel>
299 ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const {
300  // This function decodes the contents of an SHT_RELR packed relocation
301  // section.
302  //
303  // Proposal for adding SHT_RELR sections to generic-abi is here:
304  // https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
305  //
306  // The encoded sequence of Elf64_Relr entries in a SHT_RELR section looks
307  // like [ AAAAAAAA BBBBBBB1 BBBBBBB1 ... AAAAAAAA BBBBBB1 ... ]
308  //
309  // i.e. start with an address, followed by any number of bitmaps. The address
310  // entry encodes 1 relocation. The subsequent bitmap entries encode up to 63
311  // relocations each, at subsequent offsets following the last address entry.
312  //
313  // The bitmap entries must have 1 in the least significant bit. The assumption
314  // here is that an address cannot have 1 in lsb. Odd addresses are not
315  // supported.
316  //
317  // Excluding the least significant bit in the bitmap, each non-zero bit in
318  // the bitmap represents a relocation to be applied to a corresponding machine
319  // word that follows the base address word. The second least significant bit
320  // represents the machine word immediately following the initial address, and
321  // each bit that follows represents the next word, in linear order. As such,
322  // a single bitmap can encode up to 31 relocations in a 32-bit object, and
323  // 63 relocations in a 64-bit object.
324  //
325  // This encoding has a couple of interesting properties:
326  // 1. Looking at any entry, it is clear whether it's an address or a bitmap:
327  // even means address, odd means bitmap.
328  // 2. Just a simple list of addresses is a valid encoding.
329 
330  Elf_Rel Rel;
331  Rel.r_info = 0;
332  Rel.setType(getRelativeRelocationType(), false);
333  std::vector<Elf_Rel> Relocs;
334 
335  // Word type: uint32_t for Elf32, and uint64_t for Elf64.
336  typedef typename ELFT::uint Word;
337 
338  // Word size in number of bytes.
339  const size_t WordSize = sizeof(Word);
340 
341  // Number of bits used for the relocation offsets bitmap.
342  // These many relative relocations can be encoded in a single entry.
343  const size_t NBits = 8*WordSize - 1;
344 
345  Word Base = 0;
346  for (const Elf_Relr &R : relrs) {
347  Word Entry = R;
348  if ((Entry&1) == 0) {
349  // Even entry: encodes the offset for next relocation.
350  Rel.r_offset = Entry;
351  Relocs.push_back(Rel);
352  // Set base offset for subsequent bitmap entries.
353  Base = Entry + WordSize;
354  continue;
355  }
356 
357  // Odd entry: encodes bitmap for relocations starting at base.
358  Word Offset = Base;
359  while (Entry != 0) {
360  Entry >>= 1;
361  if ((Entry&1) != 0) {
362  Rel.r_offset = Offset;
363  Relocs.push_back(Rel);
364  }
365  Offset += WordSize;
366  }
367 
368  // Advance base offset by NBits words.
369  Base += NBits * WordSize;
370  }
371 
372  return Relocs;
373 }
374 
375 template <class ELFT>
377 ELFFile<ELFT>::android_relas(const Elf_Shdr &Sec) const {
378  // This function reads relocations in Android's packed relocation format,
379  // which is based on SLEB128 and delta encoding.
380  Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
381  if (!ContentsOrErr)
382  return ContentsOrErr.takeError();
383  ArrayRef<uint8_t> Content = *ContentsOrErr;
384  if (Content.size() < 4 || Content[0] != 'A' || Content[1] != 'P' ||
385  Content[2] != 'S' || Content[3] != '2')
386  return createError("invalid packed relocation header");
387  DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
388  DataExtractor::Cursor Cur(/*Offset=*/4);
389 
390  uint64_t NumRelocs = Data.getSLEB128(Cur);
391  uint64_t Offset = Data.getSLEB128(Cur);
392  uint64_t Addend = 0;
393 
394  if (!Cur)
395  return std::move(Cur.takeError());
396 
397  std::vector<Elf_Rela> Relocs;
398  Relocs.reserve(NumRelocs);
399  while (NumRelocs) {
400  uint64_t NumRelocsInGroup = Data.getSLEB128(Cur);
401  if (!Cur)
402  return std::move(Cur.takeError());
403  if (NumRelocsInGroup > NumRelocs)
404  return createError("relocation group unexpectedly large");
405  NumRelocs -= NumRelocsInGroup;
406 
407  uint64_t GroupFlags = Data.getSLEB128(Cur);
408  bool GroupedByInfo = GroupFlags & ELF::RELOCATION_GROUPED_BY_INFO_FLAG;
409  bool GroupedByOffsetDelta = GroupFlags & ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG;
410  bool GroupedByAddend = GroupFlags & ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG;
411  bool GroupHasAddend = GroupFlags & ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG;
412 
413  uint64_t GroupOffsetDelta;
414  if (GroupedByOffsetDelta)
415  GroupOffsetDelta = Data.getSLEB128(Cur);
416 
417  uint64_t GroupRInfo;
418  if (GroupedByInfo)
419  GroupRInfo = Data.getSLEB128(Cur);
420 
421  if (GroupedByAddend && GroupHasAddend)
422  Addend += Data.getSLEB128(Cur);
423 
424  if (!GroupHasAddend)
425  Addend = 0;
426 
427  for (uint64_t I = 0; Cur && I != NumRelocsInGroup; ++I) {
428  Elf_Rela R;
429  Offset += GroupedByOffsetDelta ? GroupOffsetDelta : Data.getSLEB128(Cur);
430  R.r_offset = Offset;
431  R.r_info = GroupedByInfo ? GroupRInfo : Data.getSLEB128(Cur);
432  if (GroupHasAddend && !GroupedByAddend)
433  Addend += Data.getSLEB128(Cur);
434  R.r_addend = Addend;
435  Relocs.push_back(R);
436  }
437  if (!Cur)
438  return std::move(Cur.takeError());
439  }
440 
441  return Relocs;
442 }
443 
444 template <class ELFT>
445 std::string ELFFile<ELFT>::getDynamicTagAsString(unsigned Arch,
446  uint64_t Type) const {
447 #define DYNAMIC_STRINGIFY_ENUM(tag, value) \
448  case value: \
449  return #tag;
450 
451 #define DYNAMIC_TAG(n, v)
452  switch (Arch) {
453  case ELF::EM_AARCH64:
454  switch (Type) {
455 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
456 #include "llvm/BinaryFormat/DynamicTags.def"
457 #undef AARCH64_DYNAMIC_TAG
458  }
459  break;
460 
461  case ELF::EM_HEXAGON:
462  switch (Type) {
463 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
464 #include "llvm/BinaryFormat/DynamicTags.def"
465 #undef HEXAGON_DYNAMIC_TAG
466  }
467  break;
468 
469  case ELF::EM_MIPS:
470  switch (Type) {
471 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
472 #include "llvm/BinaryFormat/DynamicTags.def"
473 #undef MIPS_DYNAMIC_TAG
474  }
475  break;
476 
477  case ELF::EM_PPC64:
478  switch (Type) {
479 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
480 #include "llvm/BinaryFormat/DynamicTags.def"
481 #undef PPC64_DYNAMIC_TAG
482  }
483  break;
484  }
485 #undef DYNAMIC_TAG
486  switch (Type) {
487 // Now handle all dynamic tags except the architecture specific ones
488 #define AARCH64_DYNAMIC_TAG(name, value)
489 #define MIPS_DYNAMIC_TAG(name, value)
490 #define HEXAGON_DYNAMIC_TAG(name, value)
491 #define PPC64_DYNAMIC_TAG(name, value)
492 // Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
493 #define DYNAMIC_TAG_MARKER(name, value)
494 #define DYNAMIC_TAG(name, value) case value: return #name;
495 #include "llvm/BinaryFormat/DynamicTags.def"
496 #undef DYNAMIC_TAG
497 #undef AARCH64_DYNAMIC_TAG
498 #undef MIPS_DYNAMIC_TAG
499 #undef HEXAGON_DYNAMIC_TAG
500 #undef PPC64_DYNAMIC_TAG
501 #undef DYNAMIC_TAG_MARKER
502 #undef DYNAMIC_STRINGIFY_ENUM
503  default:
504  return "<unknown:>0x" + utohexstr(Type, true);
505  }
506 }
507 
508 template <class ELFT>
509 std::string ELFFile<ELFT>::getDynamicTagAsString(uint64_t Type) const {
510  return getDynamicTagAsString(getHeader().e_machine, Type);
511 }
512 
513 template <class ELFT>
515  ArrayRef<Elf_Dyn> Dyn;
516 
517  auto ProgramHeadersOrError = program_headers();
518  if (!ProgramHeadersOrError)
519  return ProgramHeadersOrError.takeError();
520 
521  for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
522  if (Phdr.p_type == ELF::PT_DYNAMIC) {
523  Dyn = makeArrayRef(
524  reinterpret_cast<const Elf_Dyn *>(base() + Phdr.p_offset),
525  Phdr.p_filesz / sizeof(Elf_Dyn));
526  break;
527  }
528  }
529 
530  // If we can't find the dynamic section in the program headers, we just fall
531  // back on the sections.
532  if (Dyn.empty()) {
533  auto SectionsOrError = sections();
534  if (!SectionsOrError)
535  return SectionsOrError.takeError();
536 
537  for (const Elf_Shdr &Sec : *SectionsOrError) {
538  if (Sec.sh_type == ELF::SHT_DYNAMIC) {
539  Expected<ArrayRef<Elf_Dyn>> DynOrError =
540  getSectionContentsAsArray<Elf_Dyn>(Sec);
541  if (!DynOrError)
542  return DynOrError.takeError();
543  Dyn = *DynOrError;
544  break;
545  }
546  }
547 
548  if (!Dyn.data())
549  return ArrayRef<Elf_Dyn>();
550  }
551 
552  if (Dyn.empty())
553  // TODO: this error is untested.
554  return createError("invalid empty dynamic section");
555 
556  if (Dyn.back().d_tag != ELF::DT_NULL)
557  // TODO: this error is untested.
558  return createError("dynamic sections must be DT_NULL terminated");
559 
560  return Dyn;
561 }
562 
563 template <class ELFT>
565 ELFFile<ELFT>::toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler) const {
566  auto ProgramHeadersOrError = program_headers();
567  if (!ProgramHeadersOrError)
568  return ProgramHeadersOrError.takeError();
569 
571 
572  for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)
573  if (Phdr.p_type == ELF::PT_LOAD)
574  LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr));
575 
576  auto SortPred = [](const Elf_Phdr_Impl<ELFT> *A,
577  const Elf_Phdr_Impl<ELFT> *B) {
578  return A->p_vaddr < B->p_vaddr;
579  };
580  if (!llvm::is_sorted(LoadSegments, SortPred)) {
581  if (Error E =
582  WarnHandler("loadable segments are unsorted by virtual address"))
583  return std::move(E);
584  llvm::stable_sort(LoadSegments, SortPred);
585  }
586 
587  const Elf_Phdr *const *I = llvm::upper_bound(
588  LoadSegments, VAddr, [](uint64_t VAddr, const Elf_Phdr_Impl<ELFT> *Phdr) {
589  return VAddr < Phdr->p_vaddr;
590  });
591 
592  if (I == LoadSegments.begin())
593  return createError("virtual address is not in any segment: 0x" +
594  Twine::utohexstr(VAddr));
595  --I;
596  const Elf_Phdr &Phdr = **I;
597  uint64_t Delta = VAddr - Phdr.p_vaddr;
598  if (Delta >= Phdr.p_filesz)
599  return createError("virtual address is not in any segment: 0x" +
600  Twine::utohexstr(VAddr));
601 
602  uint64_t Offset = Phdr.p_offset + Delta;
603  if (Offset >= getBufSize())
604  return createError("can't map virtual address 0x" +
605  Twine::utohexstr(VAddr) + " to the segment with index " +
606  Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +
607  ": the segment ends at 0x" +
608  Twine::utohexstr(Phdr.p_offset + Phdr.p_filesz) +
609  ", which is greater than the file size (0x" +
610  Twine::utohexstr(getBufSize()) + ")");
611 
612  return base() + Offset;
613 }
614 
615 template <class ELFT>
617 ELFFile<ELFT>::decodeBBAddrMap(const Elf_Shdr &Sec) const {
618  Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
619  if (!ContentsOrErr)
620  return ContentsOrErr.takeError();
621  ArrayRef<uint8_t> Content = *ContentsOrErr;
622  DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
623  std::vector<Elf_BBAddrMap> FunctionEntries;
624 
625  DataExtractor::Cursor Cur(0);
626  Error ULEBSizeErr = Error::success();
627 
628  // Helper to extract and decode the next ULEB128 value as uint32_t.
629  // Returns zero and sets ULEBSizeErr if the ULEB128 value exceeds the uint32_t
630  // limit.
631  // Also returns zero if ULEBSizeErr is already in an error state.
632  auto ReadULEB128AsUInt32 = [&Data, &Cur, &ULEBSizeErr]() -> uint32_t {
633  // Bail out and do not extract data if ULEBSizeErr is already set.
634  if (ULEBSizeErr)
635  return 0;
636  uint64_t Offset = Cur.tell();
637  uint64_t Value = Data.getULEB128(Cur);
638  if (Value > UINT32_MAX) {
639  ULEBSizeErr = createError(
640  "ULEB128 value at offset 0x" + Twine::utohexstr(Offset) +
641  " exceeds UINT32_MAX (0x" + Twine::utohexstr(Value) + ")");
642  return 0;
643  }
644  return static_cast<uint32_t>(Value);
645  };
646 
647  while (!ULEBSizeErr && Cur && Cur.tell() < Content.size()) {
648  uintX_t Address = static_cast<uintX_t>(Data.getAddress(Cur));
649  uint32_t NumBlocks = ReadULEB128AsUInt32();
650  std::vector<typename Elf_BBAddrMap::BBEntry> BBEntries;
651  for (uint32_t BlockID = 0; !ULEBSizeErr && Cur && (BlockID < NumBlocks);
652  ++BlockID) {
653  uint32_t Offset = ReadULEB128AsUInt32();
654  uint32_t Size = ReadULEB128AsUInt32();
655  uint32_t Metadata = ReadULEB128AsUInt32();
656  BBEntries.push_back({Offset, Size, Metadata});
657  }
658  FunctionEntries.push_back({Address, BBEntries});
659  }
660  // Either Cur is in the error state, or ULEBSizeError is set (not both), but
661  // we join the two errors here to be safe.
662  if (!Cur || ULEBSizeErr)
663  return joinErrors(Cur.takeError(), std::move(ULEBSizeErr));
664  return FunctionEntries;
665 }
666 
667 template class llvm::object::ELFFile<ELF32LE>;
668 template class llvm::object::ELFFile<ELF32BE>;
669 template class llvm::object::ELFFile<ELF64LE>;
670 template class llvm::object::ELFFile<ELF64BE>;
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::ELF::EM_HEXAGON
@ EM_HEXAGON
Definition: ELF.h:256
llvm::ELF::SHT_ARM_EXIDX
@ SHT_ARM_EXIDX
Definition: ELF.h:951
llvm
Definition: AllocatorList.h:23
llvm::upper_bound
auto upper_bound(R &&Range, T &&Value)
Provide wrappers to std::upper_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1605
llvm::ELF::SHT_REL
@ SHT_REL
Definition: ELF.h:912
llvm::ELF::SHT_ANDROID_RELA
@ SHT_ANDROID_RELA
Definition: ELF.h:927
llvm::object::ELFFile::android_relas
Expected< std::vector< Elf_Rela > > android_relas(const Elf_Shdr &Sec) const
Definition: ELF.cpp:377
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1167
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:332
llvm::object::createError
static Error createError(const Twine &Err)
Definition: ELF.h:84
Content
T Content
Definition: ELFObjHandler.cpp:90
llvm::ELF::SHT_NULL
@ SHT_NULL
Definition: ELF.h:903
llvm::ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG
@ RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG
Definition: ELF.h:1630
llvm::ELF::SHT_SYMTAB
@ SHT_SYMTAB
Definition: ELF.h:905
llvm::ELF::EM_MSP430
@ EM_MSP430
Definition: ELF.h:221
llvm::ELF::PT_LOAD
@ PT_LOAD
Definition: ELF.h:1278
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
llvm::ELF::EM_ARC_COMPACT
@ EM_ARC_COMPACT
Definition: ELF.h:208
llvm::ELF::SHT_PREINIT_ARRAY
@ SHT_PREINIT_ARRAY
Definition: ELF.h:917
llvm::ELF::RELOCATION_GROUPED_BY_INFO_FLAG
@ RELOCATION_GROUPED_BY_INFO_FLAG
Definition: ELF.h:1629
llvm::ELF::EM_VE
@ EM_VE
Definition: ELF.h:319
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::ELF::EM_68K
@ EM_68K
Definition: ELF.h:136
STRINGIFY_ENUM_CASE
#define STRINGIFY_ENUM_CASE(ns, name)
Definition: ELF.cpp:16
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG
@ RELOCATION_GROUP_HAS_ADDEND_FLAG
Definition: ELF.h:1632
llvm::ELF::EM_CSKY
@ EM_CSKY
Definition: ELF.h:320
llvm::ELF::EM_ARM
@ EM_ARM
Definition: ELF.h:155
llvm::ELF::SHT_ARM_ATTRIBUTES
@ SHT_ARM_ATTRIBUTES
Definition: ELF.h:955
llvm::ELF::EM_AVR
@ EM_AVR
Definition: ELF.h:198
llvm::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition: ELF.h:911
llvm::Data
@ Data
Definition: SIMachineScheduler.h:56
llvm::object::ELFFile::decodeBBAddrMap
Expected< std::vector< Elf_BBAddrMap > > decodeBBAddrMap(const Elf_Shdr &Sec) const
Definition: ELF.cpp:617
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:162
uint
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint
Definition: README.txt:239
llvm::ELF::SHT_X86_64_UNWIND
@ SHT_X86_64_UNWIND
Definition: ELF.h:960
llvm::ELF::SHT_GNU_ATTRIBUTES
@ SHT_GNU_ATTRIBUTES
Definition: ELF.h:942
llvm::DataExtractor::Cursor::takeError
Error takeError()
Return error contained inside this Cursor, if any.
Definition: DataExtractor.h:75
llvm::ELF::SHT_STRTAB
@ SHT_STRTAB
Definition: ELF.h:906
llvm::ArrayRef::back
const T & back() const
back - Get the last element.
Definition: ArrayRef.h:174
llvm::ELF::SHT_LLVM_SYMPART
@ SHT_LLVM_SYMPART
Definition: ELF.h:935
llvm::ELF::EM_SPARC32PLUS
@ EM_SPARC32PLUS
Definition: ELF.h:145
ELF.h
llvm::ELF::SHT_MIPS_REGINFO
@ SHT_MIPS_REGINFO
Definition: ELF.h:962
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::ELF::EM_SPARC
@ EM_SPARC
Definition: ELF.h:134
llvm::ELF::SHT_DYNSYM
@ SHT_DYNSYM
Definition: ELF.h:914
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::ELF::EM_AMDGPU
@ EM_AMDGPU
Definition: ELF.h:315
llvm::ELF::SHT_SYMTAB_SHNDX
@ SHT_SYMTAB_SHNDX
Definition: ELF.h:919
llvm::ELF::SHT_GNU_verdef
@ SHT_GNU_verdef
Definition: ELF.h:944
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::ELF::SHT_LLVM_LINKER_OPTIONS
@ SHT_LLVM_LINKER_OPTIONS
Definition: ELF.h:929
llvm::ELF::EM_AARCH64
@ EM_AARCH64
Definition: ELF.h:279
llvm::ELF::SHT_ARM_PREEMPTMAP
@ SHT_ARM_PREEMPTMAP
Definition: ELF.h:953
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:168
llvm::ELF::SHT_NOTE
@ SHT_NOTE
Definition: ELF.h:910
llvm::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition: ELF.h:904
llvm::object::getELFRelocationTypeName
StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type)
Definition: ELF.cpp:22
object
bar al al movzbl eax ret Missed when stored in a memory object
Definition: README.txt:1411
llvm::object::Elf_Phdr_Impl
Definition: ELFTypes.h:33
llvm::Twine::utohexstr
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:387
llvm::ELF::SHT_LLVM_PART_EHDR
@ SHT_LLVM_PART_EHDR
Definition: ELF.h:936
llvm::ELF::SHT_GNU_versym
@ SHT_GNU_versym
Definition: ELF.h:946
llvm::ELF::SHT_ANDROID_REL
@ SHT_ANDROID_REL
Definition: ELF.h:926
ELF.h
llvm::ELF::EM_PPC
@ EM_PPC
Definition: ELF.h:147
llvm::ELF::SHT_RELR
@ SHT_RELR
Definition: ELF.h:922
llvm::ELF::SHT_RELA
@ SHT_RELA
Definition: ELF.h:907
llvm::ELF::SHT_RISCV_ATTRIBUTES
@ SHT_RISCV_ATTRIBUTES
Definition: ELF.h:969
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::ELF::EM_MIPS_RS3_LE
@ EM_MIPS_RS3_LE
Definition: ELF.h:142
llvm::object::ELFFile::toMappedAddr
Expected< const uint8_t * > toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler=&defaultWarningHandler) const
Definition: ELF.cpp:565
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::ELF::SHT_HASH
@ SHT_HASH
Definition: ELF.h:908
llvm::ELF::SHT_FINI_ARRAY
@ SHT_FINI_ARRAY
Definition: ELF.h:916
llvm::ELF::EM_386
@ EM_386
Definition: ELF.h:135
llvm::joinErrors
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:429
llvm::HighlightColor::Address
@ Address
llvm::object::getELFSectionTypeName
StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type)
llvm::ELF::EM_X86_64
@ EM_X86_64
Definition: ELF.h:177
llvm::ELF::EM_MIPS
@ EM_MIPS
Definition: ELF.h:140
llvm::object::ELFFile::dynamicEntries
Expected< Elf_Dyn_Range > dynamicEntries() const
Definition: ELF.cpp:514
base
therefore end up llgh r3 lr r0 br r14 but truncating the load would lh r3 br r14 Functions ret i64 and ought to be implemented ngr r0 br r14 but two address optimizations reverse the order of the AND and ngr r2 lgr r0 br r14 CodeGen SystemZ and ll has several examples of this Out of range displacements are usually handled by loading the full address into a register In many cases it would be better to create an anchor point instead E g i64 base
Definition: README.txt:125
llvm::ELF::SHT_MIPS_DWARF
@ SHT_MIPS_DWARF
Definition: ELF.h:964
llvm::DataExtractor::Cursor
A class representing a position in a DataExtractor, as well as any error encountered during extractio...
Definition: DataExtractor.h:54
llvm::irsymtab::storage::Word
support::ulittle32_t Word
Definition: IRSymtab.h:51
llvm::ELF::EM_LANAI
@ EM_LANAI
Definition: ELF.h:317
llvm::ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG
@ RELOCATION_GROUPED_BY_ADDEND_FLAG
Definition: ELF.h:1631
llvm::ELF::EM_S390
@ EM_S390
Definition: ELF.h:149
llvm::ArrayRef< uint8_t >
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::ELF::SHT_LLVM_ODRTAB
@ SHT_LLVM_ODRTAB
Definition: ELF.h:928
llvm::ELF::SHT_LLVM_PART_PHDR
@ SHT_LLVM_PART_PHDR
Definition: ELF.h:937
uint32_t
llvm::object::ELFFile::getDynamicTagAsString
std::string getDynamicTagAsString(unsigned Arch, uint64_t Type) const
Definition: ELF.cpp:445
llvm::ELF::SHT_MIPS_ABIFLAGS
@ SHT_MIPS_ABIFLAGS
Definition: ELF.h:965
llvm::ELF::SHT_ANDROID_RELR
@ SHT_ANDROID_RELR
Definition: ELF.h:941
llvm::ELF::EM_ARC_COMPACT2
@ EM_ARC_COMPACT2
Definition: ELF.h:290
llvm::ELF::SHT_ARM_OVERLAYSECTION
@ SHT_ARM_OVERLAYSECTION
Definition: ELF.h:957
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
llvm::stable_sort
void stable_sort(R &&Range)
Definition: STLExtras.h:1617
llvm::ELF::SHT_MIPS_OPTIONS
@ SHT_MIPS_OPTIONS
Definition: ELF.h:963
llvm::ELF::SHT_ARM_DEBUGOVERLAY
@ SHT_ARM_DEBUGOVERLAY
Definition: ELF.h:956
llvm::ELF::SHT_LLVM_DEPENDENT_LIBRARIES
@ SHT_LLVM_DEPENDENT_LIBRARIES
Definition: ELF.h:933
llvm::ELF::SHT_GROUP
@ SHT_GROUP
Definition: ELF.h:918
llvm::ELF::EM_RISCV
@ EM_RISCV
Definition: ELF.h:316
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
DataExtractor.h
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::is_sorted
bool is_sorted(R &&Range, Compare C)
Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...
Definition: STLExtras.h:1553
llvm::ELF::EM_IAMCU
@ EM_IAMCU
Definition: ELF.h:138
llvm::ELF::SHT_HEX_ORDERED
@ SHT_HEX_ORDERED
Definition: ELF.h:958
llvm::ELF::SHT_GNU_HASH
@ SHT_GNU_HASH
Definition: ELF.h:943
llvm::object::getELFRelativeRelocationType
uint32_t getELFRelativeRelocationType(uint32_t Machine)
Definition: ELF.cpp:177
llvm::ELF::SHT_LLVM_BB_ADDR_MAP
@ SHT_LLVM_BB_ADDR_MAP
Definition: ELF.h:938
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:557
llvm::DataExtractor
Definition: DataExtractor.h:41
Machine
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:365
llvm::ELF::SHT_DYNAMIC
@ SHT_DYNAMIC
Definition: ELF.h:909
llvm::object::ELFFile::decode_relrs
std::vector< Elf_Rel > decode_relrs(Elf_Relr_Range relrs) const
Definition: ELF.cpp:299
llvm::ELF::PT_DYNAMIC
@ PT_DYNAMIC
Definition: ELF.h:1279
llvm::ELF::EM_SPARCV9
@ EM_SPARCV9
Definition: ELF.h:158
llvm::ELF::SHT_LLVM_ADDRSIG
@ SHT_LLVM_ADDRSIG
Definition: ELF.h:931
llvm::ELF::EM_BPF
@ EM_BPF
Definition: ELF.h:318
llvm::ELF::SHT_SHLIB
@ SHT_SHLIB
Definition: ELF.h:913
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::object::ELFFile
Definition: ELF.h:98
llvm::ELF::SHT_GNU_verneed
@ SHT_GNU_verneed
Definition: ELF.h:945
llvm::ELF::SHT_INIT_ARRAY
@ SHT_INIT_ARRAY
Definition: ELF.h:915
llvm::ELF::EM_PPC64
@ EM_PPC64
Definition: ELF.h:148
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::ELF::SHT_LLVM_CALL_GRAPH_PROFILE
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:930