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/ADT/StringExtras.h"
11#include "llvm/BinaryFormat/ELF.h"
12#include "llvm/Support/DataExtractor.h"
13
14using namespace llvm;
15using namespace object;
16
17#define STRINGIFY_ENUM_CASE(ns, name)                                          \
18  case ns::name:                                                               \
19    return #name;
20
21#define ELF_RELOC(name, value) STRINGIFY_ENUM_CASE(ELF, name)
22
23StringRef llvm::object::getELFRelocationTypeName(uint32_t Machine,
24                                                 uint32_t Type) {
25  switch (Machine) {
26  case ELF::EM_68K:
27    switch (Type) {
28#include "llvm/BinaryFormat/ELFRelocs/M68k.def"
29    default:
30      break;
31    }
32    break;
33  case ELF::EM_X86_64:
34    switch (Type) {
35#include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
36    default:
37      break;
38    }
39    break;
40  case ELF::EM_386:
41  case ELF::EM_IAMCU:
42    switch (Type) {
43#include "llvm/BinaryFormat/ELFRelocs/i386.def"
44    default:
45      break;
46    }
47    break;
48  case ELF::EM_MIPS:
49    switch (Type) {
50#include "llvm/BinaryFormat/ELFRelocs/Mips.def"
51    default:
52      break;
53    }
54    break;
55  case ELF::EM_AARCH64:
56    switch (Type) {
57#include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
58    default:
59      break;
60    }
61    break;
62  case ELF::EM_ARM:
63    switch (Type) {
64#include "llvm/BinaryFormat/ELFRelocs/ARM.def"
65    default:
66      break;
67    }
68    break;
69  case ELF::EM_ARC_COMPACT:
70  case ELF::EM_ARC_COMPACT2:
71    switch (Type) {
72#include "llvm/BinaryFormat/ELFRelocs/ARC.def"
73    default:
74      break;
75    }
76    break;
77  case ELF::EM_AVR:
78    switch (Type) {
79#include "llvm/BinaryFormat/ELFRelocs/AVR.def"
80    default:
81      break;
82    }
83    break;
84  case ELF::EM_HEXAGON:
85    switch (Type) {
86#include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
87    default:
88      break;
89    }
90    break;
91  case ELF::EM_LANAI:
92    switch (Type) {
93#include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
94    default:
95      break;
96    }
97    break;
98  case ELF::EM_PPC:
99    switch (Type) {
100#include "llvm/BinaryFormat/ELFRelocs/PowerPC.def"
101    default:
102      break;
103    }
104    break;
105  case ELF::EM_PPC64:
106    switch (Type) {
107#include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
108    default:
109      break;
110    }
111    break;
112  case ELF::EM_RISCV:
113    switch (Type) {
114#include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
115    default:
116      break;
117    }
118    break;
119  case ELF::EM_S390:
120    switch (Type) {
121#include "llvm/BinaryFormat/ELFRelocs/SystemZ.def"
122    default:
123      break;
124    }
125    break;
126  case ELF::EM_SPARC:
127  case ELF::EM_SPARC32PLUS:
128  case ELF::EM_SPARCV9:
129    switch (Type) {
130#include "llvm/BinaryFormat/ELFRelocs/Sparc.def"
131    default:
132      break;
133    }
134    break;
135  case ELF::EM_AMDGPU:
136    switch (Type) {
137#include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
138    default:
139      break;
140    }
141    break;
142  case ELF::EM_BPF:
143    switch (Type) {
144#include "llvm/BinaryFormat/ELFRelocs/BPF.def"
145    default:
146      break;
147    }
148    break;
149  case ELF::EM_MSP430:
150    switch (Type) {
151#include "llvm/BinaryFormat/ELFRelocs/MSP430.def"
152    default:
153      break;
154    }
155    break;
156  case ELF::EM_VE:
157    switch (Type) {
158#include "llvm/BinaryFormat/ELFRelocs/VE.def"
159    default:
160      break;
161    }
162    break;
163  case ELF::EM_CSKY:
164    switch (Type) {
165#include "llvm/BinaryFormat/ELFRelocs/CSKY.def"
166    default:
167      break;
168    }
169    break;
170  case ELF::EM_LOONGARCH:
171    switch (Type) {
172#include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
173    default:
174      break;
175    }
176    break;
177  case ELF::EM_XTENSA:
178    switch (Type) {
179#include "llvm/BinaryFormat/ELFRelocs/Xtensa.def"
180    default:
181      break;
182    }
183    break;
184  default:
185    break;
186  }
187  return "Unknown";
188}
189
190#undef ELF_RELOC
191
192uint32_t llvm::object::getELFRelativeRelocationType(uint32_t Machine) {
193  switch (Machine) {
194  case ELF::EM_X86_64:
195    return ELF::R_X86_64_RELATIVE;
196  case ELF::EM_386:
197  case ELF::EM_IAMCU:
198    return ELF::R_386_RELATIVE;
199  case ELF::EM_MIPS:
200    break;
201  case ELF::EM_AARCH64:
202    return ELF::R_AARCH64_RELATIVE;
203  case ELF::EM_ARM:
204    return ELF::R_ARM_RELATIVE;
205  case ELF::EM_ARC_COMPACT:
206  case ELF::EM_ARC_COMPACT2:
207    return ELF::R_ARC_RELATIVE;
208  case ELF::EM_AVR:
209    break;
210  case ELF::EM_HEXAGON:
211    return ELF::R_HEX_RELATIVE;
212  case ELF::EM_LANAI:
213    break;
214  case ELF::EM_PPC:
215    break;
216  case ELF::EM_PPC64:
217    return ELF::R_PPC64_RELATIVE;
218  case ELF::EM_RISCV:
219    return ELF::R_RISCV_RELATIVE;
220  case ELF::EM_S390:
221    return ELF::R_390_RELATIVE;
222  case ELF::EM_SPARC:
223  case ELF::EM_SPARC32PLUS:
224  case ELF::EM_SPARCV9:
225    return ELF::R_SPARC_RELATIVE;
226  case ELF::EM_CSKY:
227    return ELF::R_CKCORE_RELATIVE;
228  case ELF::EM_VE:
229    return ELF::R_VE_RELATIVE;
230  case ELF::EM_AMDGPU:
231    break;
232  case ELF::EM_BPF:
233    break;
234  case ELF::EM_LOONGARCH:
235    return ELF::R_LARCH_RELATIVE;
236  default:
237    break;
238  }
239  return 0;
240}
241
242StringRef llvm::object::getELFSectionTypeName(uint32_t Machine, unsigned Type) {
243  switch (Machine) {
244  case ELF::EM_ARM:
245    switch (Type) {
246      STRINGIFY_ENUM_CASE(ELF, SHT_ARM_EXIDX);
247      STRINGIFY_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
248      STRINGIFY_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
249      STRINGIFY_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
250      STRINGIFY_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
251    }
252    break;
253  case ELF::EM_HEXAGON:
254    switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
255    break;
256  case ELF::EM_X86_64:
257    switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
258    break;
259  case ELF::EM_MIPS:
260  case ELF::EM_MIPS_RS3_LE:
261    switch (Type) {
262      STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
263      STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
264      STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_DWARF);
265      STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
266    }
267    break;
268  case ELF::EM_MSP430:
269    switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_MSP430_ATTRIBUTES); }
270    break;
271  case ELF::EM_RISCV:
272    switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_RISCV_ATTRIBUTES); }
273    break;
274  case ELF::EM_AARCH64:
275    switch (Type) {
276      STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_AUTH_RELR);
277      STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC);
278      STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_MEMTAG_GLOBALS_STATIC);
279    }
280  default:
281    break;
282  }
283
284  switch (Type) {
285    STRINGIFY_ENUM_CASE(ELF, SHT_NULL);
286    STRINGIFY_ENUM_CASE(ELF, SHT_PROGBITS);
287    STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB);
288    STRINGIFY_ENUM_CASE(ELF, SHT_STRTAB);
289    STRINGIFY_ENUM_CASE(ELF, SHT_RELA);
290    STRINGIFY_ENUM_CASE(ELF, SHT_HASH);
291    STRINGIFY_ENUM_CASE(ELF, SHT_DYNAMIC);
292    STRINGIFY_ENUM_CASE(ELF, SHT_NOTE);
293    STRINGIFY_ENUM_CASE(ELF, SHT_NOBITS);
294    STRINGIFY_ENUM_CASE(ELF, SHT_REL);
295    STRINGIFY_ENUM_CASE(ELF, SHT_SHLIB);
296    STRINGIFY_ENUM_CASE(ELF, SHT_DYNSYM);
297    STRINGIFY_ENUM_CASE(ELF, SHT_INIT_ARRAY);
298    STRINGIFY_ENUM_CASE(ELF, SHT_FINI_ARRAY);
299    STRINGIFY_ENUM_CASE(ELF, SHT_PREINIT_ARRAY);
300    STRINGIFY_ENUM_CASE(ELF, SHT_GROUP);
301    STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX);
302    STRINGIFY_ENUM_CASE(ELF, SHT_RELR);
303    STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_REL);
304    STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELA);
305    STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELR);
306    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB);
307    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LINKER_OPTIONS);
308    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_CALL_GRAPH_PROFILE);
309    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ADDRSIG);
310    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_DEPENDENT_LIBRARIES);
311    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_SYMPART);
312    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_EHDR);
313    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_PHDR);
314    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP_V0);
315    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP);
316    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_OFFLOADING);
317    STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LTO);
318    STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);
319    STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);
320    STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef);
321    STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed);
322    STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym);
323  default:
324    return "Unknown";
325  }
326}
327
328template <class ELFT>
329std::vector<typename ELFT::Rel>
330ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const {
331  // This function decodes the contents of an SHT_RELR packed relocation
332  // section.
333  //
334  // Proposal for adding SHT_RELR sections to generic-abi is here:
335  //   https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
336  //
337  // The encoded sequence of Elf64_Relr entries in a SHT_RELR section looks
338  // like [ AAAAAAAA BBBBBBB1 BBBBBBB1 ... AAAAAAAA BBBBBB1 ... ]
339  //
340  // i.e. start with an address, followed by any number of bitmaps. The address
341  // entry encodes 1 relocation. The subsequent bitmap entries encode up to 63
342  // relocations each, at subsequent offsets following the last address entry.
343  //
344  // The bitmap entries must have 1 in the least significant bit. The assumption
345  // here is that an address cannot have 1 in lsb. Odd addresses are not
346  // supported.
347  //
348  // Excluding the least significant bit in the bitmap, each non-zero bit in
349  // the bitmap represents a relocation to be applied to a corresponding machine
350  // word that follows the base address word. The second least significant bit
351  // represents the machine word immediately following the initial address, and
352  // each bit that follows represents the next word, in linear order. As such,
353  // a single bitmap can encode up to 31 relocations in a 32-bit object, and
354  // 63 relocations in a 64-bit object.
355  //
356  // This encoding has a couple of interesting properties:
357  // 1. Looking at any entry, it is clear whether it's an address or a bitmap:
358  //    even means address, odd means bitmap.
359  // 2. Just a simple list of addresses is a valid encoding.
360
361  Elf_Rel Rel;
362  Rel.r_info = 0;
363  Rel.setType(getRelativeRelocationType(), false);
364  std::vector<Elf_Rel> Relocs;
365
366  // Word type: uint32_t for Elf32, and uint64_t for Elf64.
367  using Addr = typename ELFT::uint;
368
369  Addr Base = 0;
370  for (Elf_Relr R : relrs) {
371    typename ELFT::uint Entry = R;
372    if ((Entry & 1) == 0) {
373      // Even entry: encodes the offset for next relocation.
374      Rel.r_offset = Entry;
375      Relocs.push_back(Rel);
376      // Set base offset for subsequent bitmap entries.
377      Base = Entry + sizeof(Addr);
378    } else {
379      // Odd entry: encodes bitmap for relocations starting at base.
380      for (Addr Offset = Base; (Entry >>= 1) != 0; Offset += sizeof(Addr))
381        if ((Entry & 1) != 0) {
382          Rel.r_offset = Offset;
383          Relocs.push_back(Rel);
384        }
385      Base += (CHAR_BIT * sizeof(Entry) - 1) * sizeof(Addr);
386    }
387  }
388
389  return Relocs;
390}
391
392template <class ELFT>
393Expected<std::vector<typename ELFT::Rela>>
394ELFFile<ELFT>::android_relas(const Elf_Shdr &Sec) const {
395  // This function reads relocations in Android's packed relocation format,
396  // which is based on SLEB128 and delta encoding.
397  Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
398  if (!ContentsOrErr)
399    return ContentsOrErr.takeError();
400  ArrayRef<uint8_t> Content = *ContentsOrErr;
401  if (Content.size() < 4 || Content[0] != 'A' || Content[1] != 'P' ||
402      Content[2] != 'S' || Content[3] != '2')
403    return createError("invalid packed relocation header");
404  DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
405  DataExtractor::Cursor Cur(/*Offset=*/4);
406
407  uint64_t NumRelocs = Data.getSLEB128(Cur);
408  uint64_t Offset = Data.getSLEB128(Cur);
409  uint64_t Addend = 0;
410
411  if (!Cur)
412    return std::move(Cur.takeError());
413
414  std::vector<Elf_Rela> Relocs;
415  Relocs.reserve(NumRelocs);
416  while (NumRelocs) {
417    uint64_t NumRelocsInGroup = Data.getSLEB128(Cur);
418    if (!Cur)
419      return std::move(Cur.takeError());
420    if (NumRelocsInGroup > NumRelocs)
421      return createError("relocation group unexpectedly large");
422    NumRelocs -= NumRelocsInGroup;
423
424    uint64_t GroupFlags = Data.getSLEB128(Cur);
425    bool GroupedByInfo = GroupFlags & ELF::RELOCATION_GROUPED_BY_INFO_FLAG;
426    bool GroupedByOffsetDelta = GroupFlags & ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG;
427    bool GroupedByAddend = GroupFlags & ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG;
428    bool GroupHasAddend = GroupFlags & ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG;
429
430    uint64_t GroupOffsetDelta;
431    if (GroupedByOffsetDelta)
432      GroupOffsetDelta = Data.getSLEB128(Cur);
433
434    uint64_t GroupRInfo;
435    if (GroupedByInfo)
436      GroupRInfo = Data.getSLEB128(Cur);
437
438    if (GroupedByAddend && GroupHasAddend)
439      Addend += Data.getSLEB128(Cur);
440
441    if (!GroupHasAddend)
442      Addend = 0;
443
444    for (uint64_t I = 0; Cur && I != NumRelocsInGroup; ++I) {
445      Elf_Rela R;
446      Offset += GroupedByOffsetDelta ? GroupOffsetDelta : Data.getSLEB128(Cur);
447      R.r_offset = Offset;
448      R.r_info = GroupedByInfo ? GroupRInfo : Data.getSLEB128(Cur);
449      if (GroupHasAddend && !GroupedByAddend)
450        Addend += Data.getSLEB128(Cur);
451      R.r_addend = Addend;
452      Relocs.push_back(R);
453    }
454    if (!Cur)
455      return std::move(Cur.takeError());
456  }
457
458  return Relocs;
459}
460
461template <class ELFT>
462std::string ELFFile<ELFT>::getDynamicTagAsString(unsigned Arch,
463                                                 uint64_t Type) const {
464#define DYNAMIC_STRINGIFY_ENUM(tag, value)                                     \
465  case value:                                                                  \
466    return #tag;
467
468#define DYNAMIC_TAG(n, v)
469  switch (Arch) {
470  case ELF::EM_AARCH64:
471    switch (Type) {
472#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
473#include "llvm/BinaryFormat/DynamicTags.def"
474#undef AARCH64_DYNAMIC_TAG
475    }
476    break;
477
478  case ELF::EM_HEXAGON:
479    switch (Type) {
480#define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
481#include "llvm/BinaryFormat/DynamicTags.def"
482#undef HEXAGON_DYNAMIC_TAG
483    }
484    break;
485
486  case ELF::EM_MIPS:
487    switch (Type) {
488#define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
489#include "llvm/BinaryFormat/DynamicTags.def"
490#undef MIPS_DYNAMIC_TAG
491    }
492    break;
493
494  case ELF::EM_PPC:
495    switch (Type) {
496#define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
497#include "llvm/BinaryFormat/DynamicTags.def"
498#undef PPC_DYNAMIC_TAG
499    }
500    break;
501
502  case ELF::EM_PPC64:
503    switch (Type) {
504#define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
505#include "llvm/BinaryFormat/DynamicTags.def"
506#undef PPC64_DYNAMIC_TAG
507    }
508    break;
509
510  case ELF::EM_RISCV:
511    switch (Type) {
512#define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
513#include "llvm/BinaryFormat/DynamicTags.def"
514#undef RISCV_DYNAMIC_TAG
515    }
516    break;
517  }
518#undef DYNAMIC_TAG
519  switch (Type) {
520// Now handle all dynamic tags except the architecture specific ones
521#define AARCH64_DYNAMIC_TAG(name, value)
522#define MIPS_DYNAMIC_TAG(name, value)
523#define HEXAGON_DYNAMIC_TAG(name, value)
524#define PPC_DYNAMIC_TAG(name, value)
525#define PPC64_DYNAMIC_TAG(name, value)
526#define RISCV_DYNAMIC_TAG(name, value)
527// Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
528#define DYNAMIC_TAG_MARKER(name, value)
529#define DYNAMIC_TAG(name, value) case value: return #name;
530#include "llvm/BinaryFormat/DynamicTags.def"
531#undef DYNAMIC_TAG
532#undef AARCH64_DYNAMIC_TAG
533#undef MIPS_DYNAMIC_TAG
534#undef HEXAGON_DYNAMIC_TAG
535#undef PPC_DYNAMIC_TAG
536#undef PPC64_DYNAMIC_TAG
537#undef RISCV_DYNAMIC_TAG
538#undef DYNAMIC_TAG_MARKER
539#undef DYNAMIC_STRINGIFY_ENUM
540  default:
541    return "<unknown:>0x" + utohexstr(Type, true);
542  }
543}
544
545template <class ELFT>
546std::string ELFFile<ELFT>::getDynamicTagAsString(uint64_t Type) const {
547  return getDynamicTagAsString(getHeader().e_machine, Type);
548}
549
550template <class ELFT>
551Expected<typename ELFT::DynRange> ELFFile<ELFT>::dynamicEntries() const {
552  ArrayRef<Elf_Dyn> Dyn;
553
554  auto ProgramHeadersOrError = program_headers();
555  if (!ProgramHeadersOrError)
556    return ProgramHeadersOrError.takeError();
557
558  for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
559    if (Phdr.p_type == ELF::PT_DYNAMIC) {
560      Dyn = ArrayRef(reinterpret_cast<const Elf_Dyn *>(base() + Phdr.p_offset),
561                     Phdr.p_filesz / sizeof(Elf_Dyn));
562      break;
563    }
564  }
565
566  // If we can't find the dynamic section in the program headers, we just fall
567  // back on the sections.
568  if (Dyn.empty()) {
569    auto SectionsOrError = sections();
570    if (!SectionsOrError)
571      return SectionsOrError.takeError();
572
573    for (const Elf_Shdr &Sec : *SectionsOrError) {
574      if (Sec.sh_type == ELF::SHT_DYNAMIC) {
575        Expected<ArrayRef<Elf_Dyn>> DynOrError =
576            getSectionContentsAsArray<Elf_Dyn>(Sec);
577        if (!DynOrError)
578          return DynOrError.takeError();
579        Dyn = *DynOrError;
580        break;
581      }
582    }
583
584    if (!Dyn.data())
585      return ArrayRef<Elf_Dyn>();
586  }
587
588  if (Dyn.empty())
589    return createError("invalid empty dynamic section");
590
591  if (Dyn.back().d_tag != ELF::DT_NULL)
592    return createError("dynamic sections must be DT_NULL terminated");
593
594  return Dyn;
595}
596
597template <class ELFT>
598Expected<const uint8_t *>
599ELFFile<ELFT>::toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler) const {
600  auto ProgramHeadersOrError = program_headers();
601  if (!ProgramHeadersOrError)
602    return ProgramHeadersOrError.takeError();
603
604  llvm::SmallVector<Elf_Phdr *, 4> LoadSegments;
605
606  for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)
607    if (Phdr.p_type == ELF::PT_LOAD)
608      LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr));
609
610  auto SortPred = [](const Elf_Phdr_Impl<ELFT> *A,
611                     const Elf_Phdr_Impl<ELFT> *B) {
612    return A->p_vaddr < B->p_vaddr;
613  };
614  if (!llvm::is_sorted(LoadSegments, SortPred)) {
615    if (Error E =
616            WarnHandler("loadable segments are unsorted by virtual address"))
617      return std::move(E);
618    llvm::stable_sort(LoadSegments, SortPred);
619  }
620
621  const Elf_Phdr *const *I = llvm::upper_bound(
622      LoadSegments, VAddr, [](uint64_t VAddr, const Elf_Phdr_Impl<ELFT> *Phdr) {
623        return VAddr < Phdr->p_vaddr;
624      });
625
626  if (I == LoadSegments.begin())
627    return createError("virtual address is not in any segment: 0x" +
628                       Twine::utohexstr(VAddr));
629  --I;
630  const Elf_Phdr &Phdr = **I;
631  uint64_t Delta = VAddr - Phdr.p_vaddr;
632  if (Delta >= Phdr.p_filesz)
633    return createError("virtual address is not in any segment: 0x" +
634                       Twine::utohexstr(VAddr));
635
636  uint64_t Offset = Phdr.p_offset + Delta;
637  if (Offset >= getBufSize())
638    return createError("can't map virtual address 0x" +
639                       Twine::utohexstr(VAddr) + " to the segment with index " +
640                       Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +
641                       ": the segment ends at 0x" +
642                       Twine::utohexstr(Phdr.p_offset + Phdr.p_filesz) +
643                       ", which is greater than the file size (0x" +
644                       Twine::utohexstr(getBufSize()) + ")");
645
646  return base() + Offset;
647}
648
649// Helper to extract and decode the next ULEB128 value as unsigned int.
650// Returns zero and sets ULEBSizeErr if the ULEB128 value exceeds the unsigned
651// int limit.
652// Also returns zero if ULEBSizeErr is already in an error state.
653// ULEBSizeErr is an out variable if an error occurs.
654template <typename IntTy, std::enable_if_t<std::is_unsigned_v<IntTy>, int> = 0>
655static IntTy readULEB128As(DataExtractor &Data, DataExtractor::Cursor &Cur,
656                           Error &ULEBSizeErr) {
657  // Bail out and do not extract data if ULEBSizeErr is already set.
658  if (ULEBSizeErr)
659    return 0;
660  uint64_t Offset = Cur.tell();
661  uint64_t Value = Data.getULEB128(Cur);
662  if (Value > std::numeric_limits<IntTy>::max()) {
663    ULEBSizeErr = createError("ULEB128 value at offset 0x" +
664                              Twine::utohexstr(Offset) + " exceeds UINT" +
665                              Twine(std::numeric_limits<IntTy>::digits) +
666                              "_MAX (0x" + Twine::utohexstr(Value) + ")");
667    return 0;
668  }
669  return static_cast<IntTy>(Value);
670}
671
672template <typename ELFT>
673static Expected<std::vector<BBAddrMap>>
674decodeBBAddrMapImpl(const ELFFile<ELFT> &EF,
675                    const typename ELFFile<ELFT>::Elf_Shdr &Sec,
676                    const typename ELFFile<ELFT>::Elf_Shdr *RelaSec,
677                    std::vector<PGOAnalysisMap> *PGOAnalyses) {
678  bool IsRelocatable = EF.getHeader().e_type == ELF::ET_REL;
679
680  // This DenseMap maps the offset of each function (the location of the
681  // reference to the function in the SHT_LLVM_BB_ADDR_MAP section) to the
682  // addend (the location of the function in the text section).
683  llvm::DenseMap<uint64_t, uint64_t> FunctionOffsetTranslations;
684  if (IsRelocatable && RelaSec) {
685    assert(RelaSec &&
686           "Can't read a SHT_LLVM_BB_ADDR_MAP section in a relocatable "
687           "object file without providing a relocation section.");
688    Expected<typename ELFFile<ELFT>::Elf_Rela_Range> Relas = EF.relas(*RelaSec);
689    if (!Relas)
690      return createError("unable to read relocations for section " +
691                         describe(EF, Sec) + ": " +
692                         toString(Relas.takeError()));
693    for (typename ELFFile<ELFT>::Elf_Rela Rela : *Relas)
694      FunctionOffsetTranslations[Rela.r_offset] = Rela.r_addend;
695  }
696  Expected<ArrayRef<uint8_t>> ContentsOrErr = EF.getSectionContents(Sec);
697  if (!ContentsOrErr)
698    return ContentsOrErr.takeError();
699  ArrayRef<uint8_t> Content = *ContentsOrErr;
700  DataExtractor Data(Content, EF.isLE(), ELFT::Is64Bits ? 8 : 4);
701  std::vector<BBAddrMap> FunctionEntries;
702
703  DataExtractor::Cursor Cur(0);
704  Error ULEBSizeErr = Error::success();
705  Error MetadataDecodeErr = Error::success();
706
707  uint8_t Version = 0;
708  uint8_t Feature = 0;
709  PGOAnalysisMap::Features FeatEnable{};
710  while (!ULEBSizeErr && !MetadataDecodeErr && Cur &&
711         Cur.tell() < Content.size()) {
712    if (Sec.sh_type == ELF::SHT_LLVM_BB_ADDR_MAP) {
713      Version = Data.getU8(Cur);
714      if (!Cur)
715        break;
716      if (Version > 2)
717        return createError("unsupported SHT_LLVM_BB_ADDR_MAP version: " +
718                           Twine(static_cast<int>(Version)));
719      Feature = Data.getU8(Cur); // Feature byte
720      if (!Cur)
721        break;
722      auto FeatEnableOrErr = PGOAnalysisMap::Features::decode(Feature);
723      if (!FeatEnableOrErr)
724        return FeatEnableOrErr.takeError();
725      FeatEnable =
726          FeatEnableOrErr ? *FeatEnableOrErr : PGOAnalysisMap::Features{};
727      if (Feature != 0 && Version < 2 && Cur)
728        return createError(
729            "version should be >= 2 for SHT_LLVM_BB_ADDR_MAP when "
730            "PGO features are enabled: version = " +
731            Twine(static_cast<int>(Version)) +
732            " feature = " + Twine(static_cast<int>(Feature)));
733    }
734    uint64_t SectionOffset = Cur.tell();
735    auto Address =
736        static_cast<typename ELFFile<ELFT>::uintX_t>(Data.getAddress(Cur));
737    if (!Cur)
738      return Cur.takeError();
739    if (IsRelocatable) {
740      assert(Address == 0);
741      auto FOTIterator = FunctionOffsetTranslations.find(SectionOffset);
742      if (FOTIterator == FunctionOffsetTranslations.end()) {
743        return createError("failed to get relocation data for offset: " +
744                           Twine::utohexstr(SectionOffset) + " in section " +
745                           describe(EF, Sec));
746      }
747      Address = FOTIterator->second;
748    }
749    uint32_t NumBlocks = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
750
751    std::vector<BBAddrMap::BBEntry> BBEntries;
752    uint32_t PrevBBEndOffset = 0;
753    for (uint32_t BlockIndex = 0;
754         !MetadataDecodeErr && !ULEBSizeErr && Cur && (BlockIndex < NumBlocks);
755         ++BlockIndex) {
756      uint32_t ID = Version >= 2
757                        ? readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr)
758                        : BlockIndex;
759      uint32_t Offset = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
760      uint32_t Size = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
761      uint32_t MD = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
762      if (Version >= 1) {
763        // Offset is calculated relative to the end of the previous BB.
764        Offset += PrevBBEndOffset;
765        PrevBBEndOffset = Offset + Size;
766      }
767      Expected<BBAddrMap::BBEntry::Metadata> MetadataOrErr =
768          BBAddrMap::BBEntry::Metadata::decode(MD);
769      if (!MetadataOrErr) {
770        MetadataDecodeErr = MetadataOrErr.takeError();
771        break;
772      }
773      BBEntries.push_back({ID, Offset, Size, *MetadataOrErr});
774    }
775    FunctionEntries.emplace_back(Address, std::move(BBEntries));
776
777    if (PGOAnalyses || FeatEnable.anyEnabled()) {
778      // Function entry count
779      uint64_t FuncEntryCount =
780          FeatEnable.FuncEntryCount
781              ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr)
782              : 0;
783
784      std::vector<PGOAnalysisMap::PGOBBEntry> PGOBBEntries;
785      for (uint32_t BlockIndex = 0;
786           (FeatEnable.BBFreq || FeatEnable.BrProb) && !MetadataDecodeErr &&
787           !ULEBSizeErr && Cur && (BlockIndex < NumBlocks);
788           ++BlockIndex) {
789        // Block frequency
790        uint64_t BBF = FeatEnable.BBFreq
791                           ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr)
792                           : 0;
793
794        // Branch probability
795        llvm::SmallVector<PGOAnalysisMap::PGOBBEntry::SuccessorEntry, 2>
796            Successors;
797        if (FeatEnable.BrProb) {
798          auto SuccCount = readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr);
799          for (uint64_t I = 0; I < SuccCount; ++I) {
800            uint32_t BBID = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
801            uint32_t BrProb = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
802            if (PGOAnalyses)
803              Successors.push_back({BBID, BranchProbability::getRaw(BrProb)});
804          }
805        }
806
807        if (PGOAnalyses)
808          PGOBBEntries.push_back({BlockFrequency(BBF), std::move(Successors)});
809      }
810
811      if (PGOAnalyses)
812        PGOAnalyses->push_back(
813            {FuncEntryCount, std::move(PGOBBEntries), FeatEnable});
814    }
815  }
816  // Either Cur is in the error state, or we have an error in ULEBSizeErr or
817  // MetadataDecodeErr (but not both), but we join all errors here to be safe.
818  if (!Cur || ULEBSizeErr || MetadataDecodeErr)
819    return joinErrors(joinErrors(Cur.takeError(), std::move(ULEBSizeErr)),
820                      std::move(MetadataDecodeErr));
821  return FunctionEntries;
822}
823
824template <class ELFT>
825Expected<std::vector<BBAddrMap>>
826ELFFile<ELFT>::decodeBBAddrMap(const Elf_Shdr &Sec, const Elf_Shdr *RelaSec,
827                               std::vector<PGOAnalysisMap> *PGOAnalyses) const {
828  size_t OriginalPGOSize = PGOAnalyses ? PGOAnalyses->size() : 0;
829  auto AddrMapsOrErr = decodeBBAddrMapImpl(*this, Sec, RelaSec, PGOAnalyses);
830  // remove new analyses when an error occurs
831  if (!AddrMapsOrErr && PGOAnalyses)
832    PGOAnalyses->resize(OriginalPGOSize);
833  return std::move(AddrMapsOrErr);
834}
835
836template <class ELFT>
837Expected<
838    MapVector<const typename ELFT::Shdr *, const typename ELFT::Shdr *>>
839ELFFile<ELFT>::getSectionAndRelocations(
840    std::function<Expected<bool>(const Elf_Shdr &)> IsMatch) const {
841  MapVector<const Elf_Shdr *, const Elf_Shdr *> SecToRelocMap;
842  Error Errors = Error::success();
843  for (const Elf_Shdr &Sec : cantFail(this->sections())) {
844    Expected<bool> DoesSectionMatch = IsMatch(Sec);
845    if (!DoesSectionMatch) {
846      Errors = joinErrors(std::move(Errors), DoesSectionMatch.takeError());
847      continue;
848    }
849    if (*DoesSectionMatch) {
850      if (SecToRelocMap.insert(std::make_pair(&Sec, (const Elf_Shdr *)nullptr))
851              .second)
852        continue;
853    }
854
855    if (Sec.sh_type != ELF::SHT_RELA && Sec.sh_type != ELF::SHT_REL)
856      continue;
857
858    Expected<const Elf_Shdr *> RelSecOrErr = this->getSection(Sec.sh_info);
859    if (!RelSecOrErr) {
860      Errors = joinErrors(std::move(Errors),
861                          createError(describe(*this, Sec) +
862                                      ": failed to get a relocated section: " +
863                                      toString(RelSecOrErr.takeError())));
864      continue;
865    }
866    const Elf_Shdr *ContentsSec = *RelSecOrErr;
867    Expected<bool> DoesRelTargetMatch = IsMatch(*ContentsSec);
868    if (!DoesRelTargetMatch) {
869      Errors = joinErrors(std::move(Errors), DoesRelTargetMatch.takeError());
870      continue;
871    }
872    if (*DoesRelTargetMatch)
873      SecToRelocMap[ContentsSec] = &Sec;
874  }
875  if(Errors)
876    return std::move(Errors);
877  return SecToRelocMap;
878}
879
880template class llvm::object::ELFFile<ELF32LE>;
881template class llvm::object::ELFFile<ELF32BE>;
882template class llvm::object::ELFFile<ELF64LE>;
883template class llvm::object::ELFFile<ELF64BE>;
884