LLVM  14.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_MSP430:
251  break;
252  case ELF::EM_RISCV:
253  switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_RISCV_ATTRIBUTES); }
254  break;
255  default:
256  break;
257  }
258 
259  switch (Type) {
295  default:
296  return "Unknown";
297  }
298 }
299 
300 template <class ELFT>
301 std::vector<typename ELFT::Rel>
302 ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const {
303  // This function decodes the contents of an SHT_RELR packed relocation
304  // section.
305  //
306  // Proposal for adding SHT_RELR sections to generic-abi is here:
307  // https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
308  //
309  // The encoded sequence of Elf64_Relr entries in a SHT_RELR section looks
310  // like [ AAAAAAAA BBBBBBB1 BBBBBBB1 ... AAAAAAAA BBBBBB1 ... ]
311  //
312  // i.e. start with an address, followed by any number of bitmaps. The address
313  // entry encodes 1 relocation. The subsequent bitmap entries encode up to 63
314  // relocations each, at subsequent offsets following the last address entry.
315  //
316  // The bitmap entries must have 1 in the least significant bit. The assumption
317  // here is that an address cannot have 1 in lsb. Odd addresses are not
318  // supported.
319  //
320  // Excluding the least significant bit in the bitmap, each non-zero bit in
321  // the bitmap represents a relocation to be applied to a corresponding machine
322  // word that follows the base address word. The second least significant bit
323  // represents the machine word immediately following the initial address, and
324  // each bit that follows represents the next word, in linear order. As such,
325  // a single bitmap can encode up to 31 relocations in a 32-bit object, and
326  // 63 relocations in a 64-bit object.
327  //
328  // This encoding has a couple of interesting properties:
329  // 1. Looking at any entry, it is clear whether it's an address or a bitmap:
330  // even means address, odd means bitmap.
331  // 2. Just a simple list of addresses is a valid encoding.
332 
333  Elf_Rel Rel;
334  Rel.r_info = 0;
335  Rel.setType(getRelativeRelocationType(), false);
336  std::vector<Elf_Rel> Relocs;
337 
338  // Word type: uint32_t for Elf32, and uint64_t for Elf64.
339  using Addr = typename ELFT::uint;
340 
341  Addr Base = 0;
342  for (Elf_Relr R : relrs) {
343  typename ELFT::uint Entry = R;
344  if ((Entry & 1) == 0) {
345  // Even entry: encodes the offset for next relocation.
346  Rel.r_offset = Entry;
347  Relocs.push_back(Rel);
348  // Set base offset for subsequent bitmap entries.
349  Base = Entry + sizeof(Addr);
350  } else {
351  // Odd entry: encodes bitmap for relocations starting at base.
352  for (Addr Offset = Base; (Entry >>= 1) != 0; Offset += sizeof(Addr))
353  if ((Entry & 1) != 0) {
354  Rel.r_offset = Offset;
355  Relocs.push_back(Rel);
356  }
357  Base += (CHAR_BIT * sizeof(Entry) - 1) * sizeof(Addr);
358  }
359  }
360 
361  return Relocs;
362 }
363 
364 template <class ELFT>
366 ELFFile<ELFT>::android_relas(const Elf_Shdr &Sec) const {
367  // This function reads relocations in Android's packed relocation format,
368  // which is based on SLEB128 and delta encoding.
369  Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
370  if (!ContentsOrErr)
371  return ContentsOrErr.takeError();
372  ArrayRef<uint8_t> Content = *ContentsOrErr;
373  if (Content.size() < 4 || Content[0] != 'A' || Content[1] != 'P' ||
374  Content[2] != 'S' || Content[3] != '2')
375  return createError("invalid packed relocation header");
376  DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
377  DataExtractor::Cursor Cur(/*Offset=*/4);
378 
379  uint64_t NumRelocs = Data.getSLEB128(Cur);
380  uint64_t Offset = Data.getSLEB128(Cur);
381  uint64_t Addend = 0;
382 
383  if (!Cur)
384  return std::move(Cur.takeError());
385 
386  std::vector<Elf_Rela> Relocs;
387  Relocs.reserve(NumRelocs);
388  while (NumRelocs) {
389  uint64_t NumRelocsInGroup = Data.getSLEB128(Cur);
390  if (!Cur)
391  return std::move(Cur.takeError());
392  if (NumRelocsInGroup > NumRelocs)
393  return createError("relocation group unexpectedly large");
394  NumRelocs -= NumRelocsInGroup;
395 
396  uint64_t GroupFlags = Data.getSLEB128(Cur);
397  bool GroupedByInfo = GroupFlags & ELF::RELOCATION_GROUPED_BY_INFO_FLAG;
398  bool GroupedByOffsetDelta = GroupFlags & ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG;
399  bool GroupedByAddend = GroupFlags & ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG;
400  bool GroupHasAddend = GroupFlags & ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG;
401 
402  uint64_t GroupOffsetDelta;
403  if (GroupedByOffsetDelta)
404  GroupOffsetDelta = Data.getSLEB128(Cur);
405 
406  uint64_t GroupRInfo;
407  if (GroupedByInfo)
408  GroupRInfo = Data.getSLEB128(Cur);
409 
410  if (GroupedByAddend && GroupHasAddend)
411  Addend += Data.getSLEB128(Cur);
412 
413  if (!GroupHasAddend)
414  Addend = 0;
415 
416  for (uint64_t I = 0; Cur && I != NumRelocsInGroup; ++I) {
417  Elf_Rela R;
418  Offset += GroupedByOffsetDelta ? GroupOffsetDelta : Data.getSLEB128(Cur);
419  R.r_offset = Offset;
420  R.r_info = GroupedByInfo ? GroupRInfo : Data.getSLEB128(Cur);
421  if (GroupHasAddend && !GroupedByAddend)
422  Addend += Data.getSLEB128(Cur);
423  R.r_addend = Addend;
424  Relocs.push_back(R);
425  }
426  if (!Cur)
427  return std::move(Cur.takeError());
428  }
429 
430  return Relocs;
431 }
432 
433 template <class ELFT>
434 std::string ELFFile<ELFT>::getDynamicTagAsString(unsigned Arch,
435  uint64_t Type) const {
436 #define DYNAMIC_STRINGIFY_ENUM(tag, value) \
437  case value: \
438  return #tag;
439 
440 #define DYNAMIC_TAG(n, v)
441  switch (Arch) {
442  case ELF::EM_AARCH64:
443  switch (Type) {
444 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
445 #include "llvm/BinaryFormat/DynamicTags.def"
446 #undef AARCH64_DYNAMIC_TAG
447  }
448  break;
449 
450  case ELF::EM_HEXAGON:
451  switch (Type) {
452 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
453 #include "llvm/BinaryFormat/DynamicTags.def"
454 #undef HEXAGON_DYNAMIC_TAG
455  }
456  break;
457 
458  case ELF::EM_MIPS:
459  switch (Type) {
460 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
461 #include "llvm/BinaryFormat/DynamicTags.def"
462 #undef MIPS_DYNAMIC_TAG
463  }
464  break;
465 
466  case ELF::EM_PPC:
467  switch (Type) {
468 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
469 #include "llvm/BinaryFormat/DynamicTags.def"
470 #undef PPC_DYNAMIC_TAG
471  }
472  break;
473 
474  case ELF::EM_PPC64:
475  switch (Type) {
476 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
477 #include "llvm/BinaryFormat/DynamicTags.def"
478 #undef PPC64_DYNAMIC_TAG
479  }
480  break;
481 
482  case ELF::EM_RISCV:
483  switch (Type) {
484 #define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
485 #include "llvm/BinaryFormat/DynamicTags.def"
486 #undef RISCV_DYNAMIC_TAG
487  }
488  break;
489  }
490 #undef DYNAMIC_TAG
491  switch (Type) {
492 // Now handle all dynamic tags except the architecture specific ones
493 #define AARCH64_DYNAMIC_TAG(name, value)
494 #define MIPS_DYNAMIC_TAG(name, value)
495 #define HEXAGON_DYNAMIC_TAG(name, value)
496 #define PPC_DYNAMIC_TAG(name, value)
497 #define PPC64_DYNAMIC_TAG(name, value)
498 #define RISCV_DYNAMIC_TAG(name, value)
499 // Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
500 #define DYNAMIC_TAG_MARKER(name, value)
501 #define DYNAMIC_TAG(name, value) case value: return #name;
502 #include "llvm/BinaryFormat/DynamicTags.def"
503 #undef DYNAMIC_TAG
504 #undef AARCH64_DYNAMIC_TAG
505 #undef MIPS_DYNAMIC_TAG
506 #undef HEXAGON_DYNAMIC_TAG
507 #undef PPC_DYNAMIC_TAG
508 #undef PPC64_DYNAMIC_TAG
509 #undef RISCV_DYNAMIC_TAG
510 #undef DYNAMIC_TAG_MARKER
511 #undef DYNAMIC_STRINGIFY_ENUM
512  default:
513  return "<unknown:>0x" + utohexstr(Type, true);
514  }
515 }
516 
517 template <class ELFT>
519  return getDynamicTagAsString(getHeader().e_machine, Type);
520 }
521 
522 template <class ELFT>
524  ArrayRef<Elf_Dyn> Dyn;
525 
526  auto ProgramHeadersOrError = program_headers();
527  if (!ProgramHeadersOrError)
528  return ProgramHeadersOrError.takeError();
529 
530  for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
531  if (Phdr.p_type == ELF::PT_DYNAMIC) {
532  Dyn = makeArrayRef(
533  reinterpret_cast<const Elf_Dyn *>(base() + Phdr.p_offset),
534  Phdr.p_filesz / sizeof(Elf_Dyn));
535  break;
536  }
537  }
538 
539  // If we can't find the dynamic section in the program headers, we just fall
540  // back on the sections.
541  if (Dyn.empty()) {
542  auto SectionsOrError = sections();
543  if (!SectionsOrError)
544  return SectionsOrError.takeError();
545 
546  for (const Elf_Shdr &Sec : *SectionsOrError) {
547  if (Sec.sh_type == ELF::SHT_DYNAMIC) {
548  Expected<ArrayRef<Elf_Dyn>> DynOrError =
549  getSectionContentsAsArray<Elf_Dyn>(Sec);
550  if (!DynOrError)
551  return DynOrError.takeError();
552  Dyn = *DynOrError;
553  break;
554  }
555  }
556 
557  if (!Dyn.data())
558  return ArrayRef<Elf_Dyn>();
559  }
560 
561  if (Dyn.empty())
562  // TODO: this error is untested.
563  return createError("invalid empty dynamic section");
564 
565  if (Dyn.back().d_tag != ELF::DT_NULL)
566  // TODO: this error is untested.
567  return createError("dynamic sections must be DT_NULL terminated");
568 
569  return Dyn;
570 }
571 
572 template <class ELFT>
575  auto ProgramHeadersOrError = program_headers();
576  if (!ProgramHeadersOrError)
577  return ProgramHeadersOrError.takeError();
578 
580 
581  for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)
582  if (Phdr.p_type == ELF::PT_LOAD)
583  LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr));
584 
585  auto SortPred = [](const Elf_Phdr_Impl<ELFT> *A,
586  const Elf_Phdr_Impl<ELFT> *B) {
587  return A->p_vaddr < B->p_vaddr;
588  };
589  if (!llvm::is_sorted(LoadSegments, SortPred)) {
590  if (Error E =
591  WarnHandler("loadable segments are unsorted by virtual address"))
592  return std::move(E);
593  llvm::stable_sort(LoadSegments, SortPred);
594  }
595 
596  const Elf_Phdr *const *I = llvm::upper_bound(
597  LoadSegments, VAddr, [](uint64_t VAddr, const Elf_Phdr_Impl<ELFT> *Phdr) {
598  return VAddr < Phdr->p_vaddr;
599  });
600 
601  if (I == LoadSegments.begin())
602  return createError("virtual address is not in any segment: 0x" +
603  Twine::utohexstr(VAddr));
604  --I;
605  const Elf_Phdr &Phdr = **I;
606  uint64_t Delta = VAddr - Phdr.p_vaddr;
607  if (Delta >= Phdr.p_filesz)
608  return createError("virtual address is not in any segment: 0x" +
609  Twine::utohexstr(VAddr));
610 
611  uint64_t Offset = Phdr.p_offset + Delta;
612  if (Offset >= getBufSize())
613  return createError("can't map virtual address 0x" +
614  Twine::utohexstr(VAddr) + " to the segment with index " +
615  Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +
616  ": the segment ends at 0x" +
617  Twine::utohexstr(Phdr.p_offset + Phdr.p_filesz) +
618  ", which is greater than the file size (0x" +
619  Twine::utohexstr(getBufSize()) + ")");
620 
621  return base() + Offset;
622 }
623 
624 template <class ELFT>
626 ELFFile<ELFT>::decodeBBAddrMap(const Elf_Shdr &Sec) const {
627  Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
628  if (!ContentsOrErr)
629  return ContentsOrErr.takeError();
630  ArrayRef<uint8_t> Content = *ContentsOrErr;
631  DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
632  std::vector<Elf_BBAddrMap> FunctionEntries;
633 
634  DataExtractor::Cursor Cur(0);
635  Error ULEBSizeErr = Error::success();
636 
637  // Helper to extract and decode the next ULEB128 value as uint32_t.
638  // Returns zero and sets ULEBSizeErr if the ULEB128 value exceeds the uint32_t
639  // limit.
640  // Also returns zero if ULEBSizeErr is already in an error state.
641  auto ReadULEB128AsUInt32 = [&Data, &Cur, &ULEBSizeErr]() -> uint32_t {
642  // Bail out and do not extract data if ULEBSizeErr is already set.
643  if (ULEBSizeErr)
644  return 0;
645  uint64_t Offset = Cur.tell();
646  uint64_t Value = Data.getULEB128(Cur);
647  if (Value > UINT32_MAX) {
648  ULEBSizeErr = createError(
649  "ULEB128 value at offset 0x" + Twine::utohexstr(Offset) +
650  " exceeds UINT32_MAX (0x" + Twine::utohexstr(Value) + ")");
651  return 0;
652  }
653  return static_cast<uint32_t>(Value);
654  };
655 
656  while (!ULEBSizeErr && Cur && Cur.tell() < Content.size()) {
657  uintX_t Address = static_cast<uintX_t>(Data.getAddress(Cur));
658  uint32_t NumBlocks = ReadULEB128AsUInt32();
659  std::vector<typename Elf_BBAddrMap::BBEntry> BBEntries;
660  for (uint32_t BlockID = 0; !ULEBSizeErr && Cur && (BlockID < NumBlocks);
661  ++BlockID) {
662  uint32_t Offset = ReadULEB128AsUInt32();
663  uint32_t Size = ReadULEB128AsUInt32();
664  uint32_t Metadata = ReadULEB128AsUInt32();
665  BBEntries.push_back({Offset, Size, Metadata});
666  }
667  FunctionEntries.push_back({Address, BBEntries});
668  }
669  // Either Cur is in the error state, or ULEBSizeError is set (not both), but
670  // we join the two errors here to be safe.
671  if (!Cur || ULEBSizeErr)
672  return joinErrors(Cur.takeError(), std::move(ULEBSizeErr));
673  return FunctionEntries;
674 }
675 
676 template class llvm::object::ELFFile<ELF32LE>;
677 template class llvm::object::ELFFile<ELF32BE>;
678 template class llvm::object::ELFFile<ELF64LE>;
679 template class llvm::object::ELFFile<ELF64BE>;
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::ELF::EM_S390
@ EM_S390
Definition: ELF.h:151
llvm::ELF::SHT_GNU_HASH
@ SHT_GNU_HASH
Definition: ELF.h:955
llvm::ELF::EM_SPARC
@ EM_SPARC
Definition: ELF.h:136
llvm::ELF::SHT_LLVM_PART_PHDR
@ SHT_LLVM_PART_PHDR
Definition: ELF.h:948
llvm::ELF::SHT_RELA
@ SHT_RELA
Definition: ELF.h:919
llvm
This file implements support for optimizing divisions by a constant.
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:1674
llvm::ELF::SHT_GNU_versym
@ SHT_GNU_versym
Definition: ELF.h:958
llvm::ELF::SHT_MIPS_ABIFLAGS
@ SHT_MIPS_ABIFLAGS
Definition: ELF.h:977
llvm::ELF::EM_ARM
@ EM_ARM
Definition: ELF.h:157
llvm::ELF::SHT_LLVM_LINKER_OPTIONS
@ SHT_LLVM_LINKER_OPTIONS
Definition: ELF.h:941
llvm::ELF::SHT_X86_64_UNWIND
@ SHT_X86_64_UNWIND
Definition: ELF.h:972
llvm::ELF::EM_AARCH64
@ EM_AARCH64
Definition: ELF.h:281
llvm::object::ELFFile::android_relas
Expected< std::vector< Elf_Rela > > android_relas(const Elf_Shdr &Sec) const
Definition: ELF.cpp:366
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::ELF::EM_RISCV
@ EM_RISCV
Definition: ELF.h:318
llvm::ELF::SHT_LLVM_ODRTAB
@ SHT_LLVM_ODRTAB
Definition: ELF.h:940
llvm::ELF::EM_PPC64
@ EM_PPC64
Definition: ELF.h:150
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:331
llvm::ELF::SHT_LLVM_DEPENDENT_LIBRARIES
@ SHT_LLVM_DEPENDENT_LIBRARIES
Definition: ELF.h:944
Content
T Content
Definition: ELFObjHandler.cpp:90
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::ELF::SHT_GNU_verneed
@ SHT_GNU_verneed
Definition: ELF.h:957
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
STRINGIFY_ENUM_CASE
#define STRINGIFY_ENUM_CASE(ns, name)
Definition: ELF.cpp:16
llvm::ELF::SHT_INIT_ARRAY
@ SHT_INIT_ARRAY
Definition: ELF.h:927
llvm::ELF::EM_CSKY
@ EM_CSKY
Definition: ELF.h:322
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::ELF::SHT_GNU_ATTRIBUTES
@ SHT_GNU_ATTRIBUTES
Definition: ELF.h:954
llvm::object::ELFFile::decodeBBAddrMap
Expected< std::vector< Elf_BBAddrMap > > decodeBBAddrMap(const Elf_Shdr &Sec) const
Definition: ELF.cpp:626
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
llvm::ELF::SHT_GNU_verdef
@ SHT_GNU_verdef
Definition: ELF.h:956
uint
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint
Definition: README.txt:239
llvm::ELF::EM_HEXAGON
@ EM_HEXAGON
Definition: ELF.h:258
llvm::ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG
@ RELOCATION_GROUP_HAS_ADDEND_FLAG
Definition: ELF.h:1651
llvm::DataExtractor::Cursor::takeError
Error takeError()
Return error contained inside this Cursor, if any.
Definition: DataExtractor.h:78
llvm::ELF::SHT_SYMTAB
@ SHT_SYMTAB
Definition: ELF.h:917
llvm::ArrayRef::back
const T & back() const
back - Get the last element.
Definition: ArrayRef.h:174
ELF.h
llvm::ELF::SHT_ANDROID_REL
@ SHT_ANDROID_REL
Definition: ELF.h:938
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::ELF::SHT_DYNSYM
@ SHT_DYNSYM
Definition: ELF.h:926
llvm::ELF::SHT_GROUP
@ SHT_GROUP
Definition: ELF.h:930
llvm::ELF::EM_MIPS
@ EM_MIPS
Definition: ELF.h:142
llvm::ELF::SHT_ARM_DEBUGOVERLAY
@ SHT_ARM_DEBUGOVERLAY
Definition: ELF.h:968
llvm::ELF::SHT_RELR
@ SHT_RELR
Definition: ELF.h:934
llvm::ELF::SHT_SYMTAB_SHNDX
@ SHT_SYMTAB_SHNDX
Definition: ELF.h:931
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::ELF::EM_VE
@ EM_VE
Definition: ELF.h:321
llvm::ELF::EM_68K
@ EM_68K
Definition: ELF.h:138
llvm::ELF::SHT_ANDROID_RELR
@ SHT_ANDROID_RELR
Definition: ELF.h:953
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::ELF::SHT_DYNAMIC
@ SHT_DYNAMIC
Definition: ELF.h:921
llvm::ELF::SHT_HEX_ORDERED
@ SHT_HEX_ORDERED
Definition: ELF.h:970
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:168
llvm::ELF::EM_MIPS_RS3_LE
@ EM_MIPS_RS3_LE
Definition: ELF.h:144
llvm::ELF::EM_PPC
@ EM_PPC
Definition: ELF.h:149
llvm::ELF::EM_SPARC32PLUS
@ EM_SPARC32PLUS
Definition: ELF.h:147
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:408
uint64_t
llvm::ELF::SHT_ARM_ATTRIBUTES
@ SHT_ARM_ATTRIBUTES
Definition: ELF.h:967
llvm::ELF::SHT_NOTE
@ SHT_NOTE
Definition: ELF.h:922
ELF.h
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:80
llvm::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition: ELF.h:916
llvm::ELF::SHT_STRTAB
@ SHT_STRTAB
Definition: ELF.h:918
llvm::ELF::SHT_REL
@ SHT_REL
Definition: ELF.h:924
llvm::ELF::SHT_RISCV_ATTRIBUTES
@ SHT_RISCV_ATTRIBUTES
Definition: ELF.h:981
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::SHT_ARM_EXIDX
@ SHT_ARM_EXIDX
Definition: ELF.h:963
llvm::object::ELFFile::toMappedAddr
Expected< const uint8_t * > toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler=&defaultWarningHandler) const
Definition: ELF.cpp:574
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::joinErrors
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:428
llvm::HighlightColor::Address
@ Address
llvm::object::getELFSectionTypeName
StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type)
llvm::ELF::SHT_LLVM_ADDRSIG
@ SHT_LLVM_ADDRSIG
Definition: ELF.h:942
llvm::ELF::EM_LANAI
@ EM_LANAI
Definition: ELF.h:319
llvm::ELF::SHT_ARM_PREEMPTMAP
@ SHT_ARM_PREEMPTMAP
Definition: ELF.h:965
llvm::object::ELFFile::dynamicEntries
Expected< Elf_Dyn_Range > dynamicEntries() const
Definition: ELF.cpp:523
llvm::ELF::EM_BPF
@ EM_BPF
Definition: ELF.h:320
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::DataExtractor::Cursor
A class representing a position in a DataExtractor, as well as any error encountered during extractio...
Definition: DataExtractor.h:54
llvm::ELF::EM_AMDGPU
@ EM_AMDGPU
Definition: ELF.h:317
llvm::ELF::SHT_HASH
@ SHT_HASH
Definition: ELF.h:920
llvm::ELF::EM_MSP430
@ EM_MSP430
Definition: ELF.h:223
llvm::ELF::SHT_MIPS_DWARF
@ SHT_MIPS_DWARF
Definition: ELF.h:976
llvm::ELF::EM_ARC_COMPACT2
@ EM_ARC_COMPACT2
Definition: ELF.h:292
llvm::ArrayRef< uint8_t >
llvm::ELF::SHT_NULL
@ SHT_NULL
Definition: ELF.h:915
llvm::ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG
@ RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG
Definition: ELF.h:1649
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
uint32_t
llvm::object::ELFFile::getDynamicTagAsString
std::string getDynamicTagAsString(unsigned Arch, uint64_t Type) const
Definition: ELF.cpp:434
llvm::ELF::SHT_LLVM_BB_ADDR_MAP
@ SHT_LLVM_BB_ADDR_MAP
Definition: ELF.h:949
llvm::ELF::PT_LOAD
@ PT_LOAD
Definition: ELF.h:1290
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::stable_sort
void stable_sort(R &&Range)
Definition: STLExtras.h:1686
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::ELF::EM_ARC_COMPACT
@ EM_ARC_COMPACT
Definition: ELF.h:210
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:1622
llvm::ELF::SHT_ARM_OVERLAYSECTION
@ SHT_ARM_OVERLAYSECTION
Definition: ELF.h:969
llvm::object::getELFRelativeRelocationType
uint32_t getELFRelativeRelocationType(uint32_t Machine)
Definition: ELF.cpp:177
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
llvm::ELF::SHT_LLVM_CALL_GRAPH_PROFILE
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:950
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:599
llvm::DataExtractor
Definition: DataExtractor.h:41
llvm::ELF::SHT_LLVM_PART_EHDR
@ SHT_LLVM_PART_EHDR
Definition: ELF.h:947
Machine
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:366
llvm::ELF::SHT_MIPS_REGINFO
@ SHT_MIPS_REGINFO
Definition: ELF.h:974
llvm::ELF::RELOCATION_GROUPED_BY_INFO_FLAG
@ RELOCATION_GROUPED_BY_INFO_FLAG
Definition: ELF.h:1648
llvm::object::ELFFile::decode_relrs
std::vector< Elf_Rel > decode_relrs(Elf_Relr_Range relrs) const
Definition: ELF.cpp:302
llvm::ELF::PT_DYNAMIC
@ PT_DYNAMIC
Definition: ELF.h:1291
llvm::ELF::SHT_ANDROID_RELA
@ SHT_ANDROID_RELA
Definition: ELF.h:939
llvm::ELF::EM_X86_64
@ EM_X86_64
Definition: ELF.h:179
llvm::ELF::SHT_SHLIB
@ SHT_SHLIB
Definition: ELF.h:925
llvm::ELF::EM_AVR
@ EM_AVR
Definition: ELF.h:200
llvm::ELF::SHT_FINI_ARRAY
@ SHT_FINI_ARRAY
Definition: ELF.h:928
llvm::object::createError
Error createError(const Twine &Err)
Definition: Error.h:85
llvm::ELF::SHT_MSP430_ATTRIBUTES
@ SHT_MSP430_ATTRIBUTES
Definition: ELF.h:979
llvm::ELF::EM_IAMCU
@ EM_IAMCU
Definition: ELF.h:140
llvm::ELF::SHT_LLVM_SYMPART
@ SHT_LLVM_SYMPART
Definition: ELF.h:946
llvm::ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG
@ RELOCATION_GROUPED_BY_ADDEND_FLAG
Definition: ELF.h:1650
llvm::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition: ELF.h:923
llvm::ELF::EM_386
@ EM_386
Definition: ELF.h:137
llvm::ELF::EM_SPARCV9
@ EM_SPARCV9
Definition: ELF.h:160
llvm::ELF::SHT_MIPS_OPTIONS
@ SHT_MIPS_OPTIONS
Definition: ELF.h:975
llvm::ELF::SHT_PREINIT_ARRAY
@ SHT_PREINIT_ARRAY
Definition: ELF.h:929
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::object::ELFFile
Definition: ELF.h:94
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58