LLVM 18.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"
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
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;
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:
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;
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
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;
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:
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;
235 return ELF::R_LARCH_RELATIVE;
236 default:
237 break;
238 }
239 return 0;
240}
241
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:
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_MEMTAG_GLOBALS_DYNAMIC);
277 STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_MEMTAG_GLOBALS_STATIC);
278 }
279 default:
280 break;
281 }
282
283 switch (Type) {
284 STRINGIFY_ENUM_CASE(ELF, SHT_NULL);
285 STRINGIFY_ENUM_CASE(ELF, SHT_PROGBITS);
286 STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB);
287 STRINGIFY_ENUM_CASE(ELF, SHT_STRTAB);
288 STRINGIFY_ENUM_CASE(ELF, SHT_RELA);
289 STRINGIFY_ENUM_CASE(ELF, SHT_HASH);
290 STRINGIFY_ENUM_CASE(ELF, SHT_DYNAMIC);
291 STRINGIFY_ENUM_CASE(ELF, SHT_NOTE);
292 STRINGIFY_ENUM_CASE(ELF, SHT_NOBITS);
293 STRINGIFY_ENUM_CASE(ELF, SHT_REL);
294 STRINGIFY_ENUM_CASE(ELF, SHT_SHLIB);
295 STRINGIFY_ENUM_CASE(ELF, SHT_DYNSYM);
296 STRINGIFY_ENUM_CASE(ELF, SHT_INIT_ARRAY);
297 STRINGIFY_ENUM_CASE(ELF, SHT_FINI_ARRAY);
298 STRINGIFY_ENUM_CASE(ELF, SHT_PREINIT_ARRAY);
299 STRINGIFY_ENUM_CASE(ELF, SHT_GROUP);
300 STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX);
301 STRINGIFY_ENUM_CASE(ELF, SHT_RELR);
302 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_REL);
303 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELA);
304 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELR);
305 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB);
306 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LINKER_OPTIONS);
307 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_CALL_GRAPH_PROFILE);
308 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ADDRSIG);
309 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_DEPENDENT_LIBRARIES);
310 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_SYMPART);
311 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_EHDR);
312 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_PHDR);
313 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP_V0);
314 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP);
315 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_OFFLOADING);
316 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LTO);
317 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);
318 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);
319 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef);
320 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed);
321 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym);
322 default:
323 return "Unknown";
324 }
325}
326
327template <class ELFT>
328std::vector<typename ELFT::Rel>
329ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const {
330 // This function decodes the contents of an SHT_RELR packed relocation
331 // section.
332 //
333 // Proposal for adding SHT_RELR sections to generic-abi is here:
334 // https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
335 //
336 // The encoded sequence of Elf64_Relr entries in a SHT_RELR section looks
337 // like [ AAAAAAAA BBBBBBB1 BBBBBBB1 ... AAAAAAAA BBBBBB1 ... ]
338 //
339 // i.e. start with an address, followed by any number of bitmaps. The address
340 // entry encodes 1 relocation. The subsequent bitmap entries encode up to 63
341 // relocations each, at subsequent offsets following the last address entry.
342 //
343 // The bitmap entries must have 1 in the least significant bit. The assumption
344 // here is that an address cannot have 1 in lsb. Odd addresses are not
345 // supported.
346 //
347 // Excluding the least significant bit in the bitmap, each non-zero bit in
348 // the bitmap represents a relocation to be applied to a corresponding machine
349 // word that follows the base address word. The second least significant bit
350 // represents the machine word immediately following the initial address, and
351 // each bit that follows represents the next word, in linear order. As such,
352 // a single bitmap can encode up to 31 relocations in a 32-bit object, and
353 // 63 relocations in a 64-bit object.
354 //
355 // This encoding has a couple of interesting properties:
356 // 1. Looking at any entry, it is clear whether it's an address or a bitmap:
357 // even means address, odd means bitmap.
358 // 2. Just a simple list of addresses is a valid encoding.
359
360 Elf_Rel Rel;
361 Rel.r_info = 0;
362 Rel.setType(getRelativeRelocationType(), false);
363 std::vector<Elf_Rel> Relocs;
364
365 // Word type: uint32_t for Elf32, and uint64_t for Elf64.
366 using Addr = typename ELFT::uint;
367
368 Addr Base = 0;
369 for (Elf_Relr R : relrs) {
370 typename ELFT::uint Entry = R;
371 if ((Entry & 1) == 0) {
372 // Even entry: encodes the offset for next relocation.
373 Rel.r_offset = Entry;
374 Relocs.push_back(Rel);
375 // Set base offset for subsequent bitmap entries.
376 Base = Entry + sizeof(Addr);
377 } else {
378 // Odd entry: encodes bitmap for relocations starting at base.
379 for (Addr Offset = Base; (Entry >>= 1) != 0; Offset += sizeof(Addr))
380 if ((Entry & 1) != 0) {
381 Rel.r_offset = Offset;
382 Relocs.push_back(Rel);
383 }
384 Base += (CHAR_BIT * sizeof(Entry) - 1) * sizeof(Addr);
385 }
386 }
387
388 return Relocs;
389}
390
391template <class ELFT>
393ELFFile<ELFT>::android_relas(const Elf_Shdr &Sec) const {
394 // This function reads relocations in Android's packed relocation format,
395 // which is based on SLEB128 and delta encoding.
396 Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
397 if (!ContentsOrErr)
398 return ContentsOrErr.takeError();
399 ArrayRef<uint8_t> Content = *ContentsOrErr;
400 if (Content.size() < 4 || Content[0] != 'A' || Content[1] != 'P' ||
401 Content[2] != 'S' || Content[3] != '2')
402 return createError("invalid packed relocation header");
403 DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
404 DataExtractor::Cursor Cur(/*Offset=*/4);
405
406 uint64_t NumRelocs = Data.getSLEB128(Cur);
407 uint64_t Offset = Data.getSLEB128(Cur);
408 uint64_t Addend = 0;
409
410 if (!Cur)
411 return std::move(Cur.takeError());
412
413 std::vector<Elf_Rela> Relocs;
414 Relocs.reserve(NumRelocs);
415 while (NumRelocs) {
416 uint64_t NumRelocsInGroup = Data.getSLEB128(Cur);
417 if (!Cur)
418 return std::move(Cur.takeError());
419 if (NumRelocsInGroup > NumRelocs)
420 return createError("relocation group unexpectedly large");
421 NumRelocs -= NumRelocsInGroup;
422
423 uint64_t GroupFlags = Data.getSLEB128(Cur);
424 bool GroupedByInfo = GroupFlags & ELF::RELOCATION_GROUPED_BY_INFO_FLAG;
425 bool GroupedByOffsetDelta = GroupFlags & ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG;
426 bool GroupedByAddend = GroupFlags & ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG;
427 bool GroupHasAddend = GroupFlags & ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG;
428
429 uint64_t GroupOffsetDelta;
430 if (GroupedByOffsetDelta)
431 GroupOffsetDelta = Data.getSLEB128(Cur);
432
433 uint64_t GroupRInfo;
434 if (GroupedByInfo)
435 GroupRInfo = Data.getSLEB128(Cur);
436
437 if (GroupedByAddend && GroupHasAddend)
438 Addend += Data.getSLEB128(Cur);
439
440 if (!GroupHasAddend)
441 Addend = 0;
442
443 for (uint64_t I = 0; Cur && I != NumRelocsInGroup; ++I) {
444 Elf_Rela R;
445 Offset += GroupedByOffsetDelta ? GroupOffsetDelta : Data.getSLEB128(Cur);
446 R.r_offset = Offset;
447 R.r_info = GroupedByInfo ? GroupRInfo : Data.getSLEB128(Cur);
448 if (GroupHasAddend && !GroupedByAddend)
449 Addend += Data.getSLEB128(Cur);
450 R.r_addend = Addend;
451 Relocs.push_back(R);
452 }
453 if (!Cur)
454 return std::move(Cur.takeError());
455 }
456
457 return Relocs;
458}
459
460template <class ELFT>
461std::string ELFFile<ELFT>::getDynamicTagAsString(unsigned Arch,
462 uint64_t Type) const {
463#define DYNAMIC_STRINGIFY_ENUM(tag, value) \
464 case value: \
465 return #tag;
466
467#define DYNAMIC_TAG(n, v)
468 switch (Arch) {
469 case ELF::EM_AARCH64:
470 switch (Type) {
471#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
472#include "llvm/BinaryFormat/DynamicTags.def"
473#undef AARCH64_DYNAMIC_TAG
474 }
475 break;
476
477 case ELF::EM_HEXAGON:
478 switch (Type) {
479#define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
480#include "llvm/BinaryFormat/DynamicTags.def"
481#undef HEXAGON_DYNAMIC_TAG
482 }
483 break;
484
485 case ELF::EM_MIPS:
486 switch (Type) {
487#define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
488#include "llvm/BinaryFormat/DynamicTags.def"
489#undef MIPS_DYNAMIC_TAG
490 }
491 break;
492
493 case ELF::EM_PPC:
494 switch (Type) {
495#define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
496#include "llvm/BinaryFormat/DynamicTags.def"
497#undef PPC_DYNAMIC_TAG
498 }
499 break;
500
501 case ELF::EM_PPC64:
502 switch (Type) {
503#define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
504#include "llvm/BinaryFormat/DynamicTags.def"
505#undef PPC64_DYNAMIC_TAG
506 }
507 break;
508
509 case ELF::EM_RISCV:
510 switch (Type) {
511#define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
512#include "llvm/BinaryFormat/DynamicTags.def"
513#undef RISCV_DYNAMIC_TAG
514 }
515 break;
516 }
517#undef DYNAMIC_TAG
518 switch (Type) {
519// Now handle all dynamic tags except the architecture specific ones
520#define AARCH64_DYNAMIC_TAG(name, value)
521#define MIPS_DYNAMIC_TAG(name, value)
522#define HEXAGON_DYNAMIC_TAG(name, value)
523#define PPC_DYNAMIC_TAG(name, value)
524#define PPC64_DYNAMIC_TAG(name, value)
525#define RISCV_DYNAMIC_TAG(name, value)
526// Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
527#define DYNAMIC_TAG_MARKER(name, value)
528#define DYNAMIC_TAG(name, value) case value: return #name;
529#include "llvm/BinaryFormat/DynamicTags.def"
530#undef DYNAMIC_TAG
531#undef AARCH64_DYNAMIC_TAG
532#undef MIPS_DYNAMIC_TAG
533#undef HEXAGON_DYNAMIC_TAG
534#undef PPC_DYNAMIC_TAG
535#undef PPC64_DYNAMIC_TAG
536#undef RISCV_DYNAMIC_TAG
537#undef DYNAMIC_TAG_MARKER
538#undef DYNAMIC_STRINGIFY_ENUM
539 default:
540 return "<unknown:>0x" + utohexstr(Type, true);
541 }
542}
543
544template <class ELFT>
546 return getDynamicTagAsString(getHeader().e_machine, Type);
547}
548
549template <class ELFT>
552
553 auto ProgramHeadersOrError = program_headers();
554 if (!ProgramHeadersOrError)
555 return ProgramHeadersOrError.takeError();
556
557 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
558 if (Phdr.p_type == ELF::PT_DYNAMIC) {
559 Dyn = ArrayRef(reinterpret_cast<const Elf_Dyn *>(base() + Phdr.p_offset),
560 Phdr.p_filesz / sizeof(Elf_Dyn));
561 break;
562 }
563 }
564
565 // If we can't find the dynamic section in the program headers, we just fall
566 // back on the sections.
567 if (Dyn.empty()) {
568 auto SectionsOrError = sections();
569 if (!SectionsOrError)
570 return SectionsOrError.takeError();
571
572 for (const Elf_Shdr &Sec : *SectionsOrError) {
573 if (Sec.sh_type == ELF::SHT_DYNAMIC) {
574 Expected<ArrayRef<Elf_Dyn>> DynOrError =
575 getSectionContentsAsArray<Elf_Dyn>(Sec);
576 if (!DynOrError)
577 return DynOrError.takeError();
578 Dyn = *DynOrError;
579 break;
580 }
581 }
582
583 if (!Dyn.data())
584 return ArrayRef<Elf_Dyn>();
585 }
586
587 if (Dyn.empty())
588 return createError("invalid empty dynamic section");
589
590 if (Dyn.back().d_tag != ELF::DT_NULL)
591 return createError("dynamic sections must be DT_NULL terminated");
592
593 return Dyn;
594}
595
596template <class ELFT>
599 auto ProgramHeadersOrError = program_headers();
600 if (!ProgramHeadersOrError)
601 return ProgramHeadersOrError.takeError();
602
604
605 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)
606 if (Phdr.p_type == ELF::PT_LOAD)
607 LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr));
608
609 auto SortPred = [](const Elf_Phdr_Impl<ELFT> *A,
610 const Elf_Phdr_Impl<ELFT> *B) {
611 return A->p_vaddr < B->p_vaddr;
612 };
613 if (!llvm::is_sorted(LoadSegments, SortPred)) {
614 if (Error E =
615 WarnHandler("loadable segments are unsorted by virtual address"))
616 return std::move(E);
617 llvm::stable_sort(LoadSegments, SortPred);
618 }
619
620 const Elf_Phdr *const *I = llvm::upper_bound(
621 LoadSegments, VAddr, [](uint64_t VAddr, const Elf_Phdr_Impl<ELFT> *Phdr) {
622 return VAddr < Phdr->p_vaddr;
623 });
624
625 if (I == LoadSegments.begin())
626 return createError("virtual address is not in any segment: 0x" +
627 Twine::utohexstr(VAddr));
628 --I;
629 const Elf_Phdr &Phdr = **I;
630 uint64_t Delta = VAddr - Phdr.p_vaddr;
631 if (Delta >= Phdr.p_filesz)
632 return createError("virtual address is not in any segment: 0x" +
633 Twine::utohexstr(VAddr));
634
635 uint64_t Offset = Phdr.p_offset + Delta;
636 if (Offset >= getBufSize())
637 return createError("can't map virtual address 0x" +
638 Twine::utohexstr(VAddr) + " to the segment with index " +
639 Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +
640 ": the segment ends at 0x" +
641 Twine::utohexstr(Phdr.p_offset + Phdr.p_filesz) +
642 ", which is greater than the file size (0x" +
643 Twine::utohexstr(getBufSize()) + ")");
644
645 return base() + Offset;
646}
647
648template <class ELFT>
651 const Elf_Shdr *RelaSec) const {
652 bool IsRelocatable = getHeader().e_type == ELF::ET_REL;
653
654 // This DenseMap maps the offset of each function (the location of the
655 // reference to the function in the SHT_LLVM_BB_ADDR_MAP section) to the
656 // addend (the location of the function in the text section).
657 llvm::DenseMap<uint64_t, uint64_t> FunctionOffsetTranslations;
658 if (IsRelocatable && RelaSec) {
659 assert(RelaSec &&
660 "Can't read a SHT_LLVM_BB_ADDR_MAP section in a relocatable "
661 "object file without providing a relocation section.");
662 Expected<Elf_Rela_Range> Relas = this->relas(*RelaSec);
663 if (!Relas)
664 return createError("unable to read relocations for section " +
665 describe(*this, Sec) + ": " +
666 toString(Relas.takeError()));
667 for (Elf_Rela Rela : *Relas)
668 FunctionOffsetTranslations[Rela.r_offset] = Rela.r_addend;
669 }
670 Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
671 if (!ContentsOrErr)
672 return ContentsOrErr.takeError();
673 ArrayRef<uint8_t> Content = *ContentsOrErr;
674 DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
675 std::vector<BBAddrMap> FunctionEntries;
676
678 Error ULEBSizeErr = Error::success();
679 Error MetadataDecodeErr = Error::success();
680 // Helper to extract and decode the next ULEB128 value as uint32_t.
681 // Returns zero and sets ULEBSizeErr if the ULEB128 value exceeds the uint32_t
682 // limit.
683 // Also returns zero if ULEBSizeErr is already in an error state.
684 auto ReadULEB128AsUInt32 = [&Data, &Cur, &ULEBSizeErr]() -> uint32_t {
685 // Bail out and do not extract data if ULEBSizeErr is already set.
686 if (ULEBSizeErr)
687 return 0;
688 uint64_t Offset = Cur.tell();
689 uint64_t Value = Data.getULEB128(Cur);
690 if (Value > UINT32_MAX) {
691 ULEBSizeErr = createError(
692 "ULEB128 value at offset 0x" + Twine::utohexstr(Offset) +
693 " exceeds UINT32_MAX (0x" + Twine::utohexstr(Value) + ")");
694 return 0;
695 }
696 return static_cast<uint32_t>(Value);
697 };
698
699 uint8_t Version = 0;
700 while (!ULEBSizeErr && !MetadataDecodeErr && Cur &&
701 Cur.tell() < Content.size()) {
702 if (Sec.sh_type == ELF::SHT_LLVM_BB_ADDR_MAP) {
703 Version = Data.getU8(Cur);
704 if (!Cur)
705 break;
706 if (Version > 2)
707 return createError("unsupported SHT_LLVM_BB_ADDR_MAP version: " +
708 Twine(static_cast<int>(Version)));
709 Data.getU8(Cur); // Feature byte
710 }
711 uint64_t SectionOffset = Cur.tell();
712 uintX_t Address = static_cast<uintX_t>(Data.getAddress(Cur));
713 if (!Cur)
714 return Cur.takeError();
715 if (IsRelocatable) {
716 assert(Address == 0);
717 auto FOTIterator = FunctionOffsetTranslations.find(SectionOffset);
718 if (FOTIterator == FunctionOffsetTranslations.end()) {
719 return createError("failed to get relocation data for offset: " +
720 Twine::utohexstr(SectionOffset) + " in section " +
721 describe(*this, Sec));
722 }
723 Address = FOTIterator->second;
724 }
725 uint32_t NumBlocks = ReadULEB128AsUInt32();
726 std::vector<BBAddrMap::BBEntry> BBEntries;
727 uint32_t PrevBBEndOffset = 0;
728 for (uint32_t BlockIndex = 0;
729 !MetadataDecodeErr && !ULEBSizeErr && Cur && (BlockIndex < NumBlocks);
730 ++BlockIndex) {
731 uint32_t ID = Version >= 2 ? ReadULEB128AsUInt32() : BlockIndex;
732 uint32_t Offset = ReadULEB128AsUInt32();
733 uint32_t Size = ReadULEB128AsUInt32();
734 uint32_t MD = ReadULEB128AsUInt32();
735 if (Version >= 1) {
736 // Offset is calculated relative to the end of the previous BB.
737 Offset += PrevBBEndOffset;
738 PrevBBEndOffset = Offset + Size;
739 }
742 if (!MetadataOrErr) {
743 MetadataDecodeErr = MetadataOrErr.takeError();
744 break;
745 }
746 BBEntries.push_back({ID, Offset, Size, *MetadataOrErr});
747 }
748 FunctionEntries.emplace_back(Address, std::move(BBEntries));
749 }
750 // Either Cur is in the error state, or we have an error in ULEBSizeErr or
751 // MetadataDecodeErr (but not both), but we join all errors here to be safe.
752 if (!Cur || ULEBSizeErr || MetadataDecodeErr)
753 return joinErrors(joinErrors(Cur.takeError(), std::move(ULEBSizeErr)),
754 std::move(MetadataDecodeErr));
755 return FunctionEntries;
756}
757
758template <class ELFT>
762 std::function<Expected<bool>(const Elf_Shdr &)> IsMatch) const {
764 Error Errors = Error::success();
765 for (const Elf_Shdr &Sec : cantFail(this->sections())) {
766 Expected<bool> DoesSectionMatch = IsMatch(Sec);
767 if (!DoesSectionMatch) {
768 Errors = joinErrors(std::move(Errors), DoesSectionMatch.takeError());
769 continue;
770 }
771 if (*DoesSectionMatch) {
772 if (SecToRelocMap.insert(std::make_pair(&Sec, (const Elf_Shdr *)nullptr))
773 .second)
774 continue;
775 }
776
777 if (Sec.sh_type != ELF::SHT_RELA && Sec.sh_type != ELF::SHT_REL)
778 continue;
779
780 Expected<const Elf_Shdr *> RelSecOrErr = this->getSection(Sec.sh_info);
781 if (!RelSecOrErr) {
782 Errors = joinErrors(std::move(Errors),
783 createError(describe(*this, Sec) +
784 ": failed to get a relocated section: " +
785 toString(RelSecOrErr.takeError())));
786 continue;
787 }
788 const Elf_Shdr *ContentsSec = *RelSecOrErr;
789 Expected<bool> DoesRelTargetMatch = IsMatch(*ContentsSec);
790 if (!DoesRelTargetMatch) {
791 Errors = joinErrors(std::move(Errors), DoesRelTargetMatch.takeError());
792 continue;
793 }
794 if (*DoesRelTargetMatch)
795 SecToRelocMap[ContentsSec] = &Sec;
796 }
797 if(Errors)
798 return std::move(Errors);
799 return SecToRelocMap;
800}
801
802template class llvm::object::ELFFile<ELF32LE>;
803template class llvm::object::ELFFile<ELF32BE>;
804template class llvm::object::ELFFile<ELF64LE>;
805template class llvm::object::ELFFile<ELF64BE>;
bbsections Prepares for basic block sections
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
T Content
uint64_t Addr
uint64_t Size
#define I(x, y, z)
Definition: MD5.cpp:58
#define STRINGIFY_ENUM_CASE(ns, name)
Definition: ELF.cpp:17
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some functions that are useful when dealing with strings.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
const T & back() const
back - Get the last element.
Definition: ArrayRef.h:174
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
const T * data() const
Definition: ArrayRef.h:162
A class representing a position in a DataExtractor, as well as any error encountered during extractio...
Definition: DataExtractor.h:54
uint64_t tell() const
Return the current position of this Cursor.
Definition: DataExtractor.h:71
Error takeError()
Return error contained inside this Cursor, if any.
Definition: DataExtractor.h:78
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
iterator end()
Definition: DenseMap.h:84
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
Error takeError()
Take ownership of the stored error.
Definition: Error.h:601
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:36
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: MapVector.h:141
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:416
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
An efficient, type-erasing, non-owning reference to a callable.
Expected< std::vector< Elf_Rela > > android_relas(const Elf_Shdr &Sec) const
Definition: ELF.cpp:393
std::string getDynamicTagAsString(unsigned Arch, uint64_t Type) const
Definition: ELF.cpp:461
Expected< std::vector< BBAddrMap > > decodeBBAddrMap(const Elf_Shdr &Sec, const Elf_Shdr *RelaSec=nullptr) const
Returns a vector of BBAddrMap structs corresponding to each function within the text section that the...
Definition: ELF.cpp:650
Expected< Elf_Dyn_Range > dynamicEntries() const
Definition: ELF.cpp:550
Expected< const uint8_t * > toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler=&defaultWarningHandler) const
Definition: ELF.cpp:598
Expected< MapVector< const Elf_Shdr *, const Elf_Shdr * > > getSectionAndRelocations(std::function< Expected< bool >(const Elf_Shdr &)> IsMatch) const
Returns a map from every section matching IsMatch to its relocation section, or nullptr if it has no ...
Definition: ELF.cpp:761
std::vector< Elf_Rel > decode_relrs(Elf_Relr_Range relrs) const
Definition: ELF.cpp:329
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ ET_REL
Definition: ELF.h:116
@ EM_MSP430
Definition: ELF.h:222
@ EM_S390
Definition: ELF.h:150
@ EM_PPC64
Definition: ELF.h:149
@ EM_SPARC
Definition: ELF.h:135
@ EM_CSKY
Definition: ELF.h:321
@ EM_SPARC32PLUS
Definition: ELF.h:146
@ EM_MIPS_RS3_LE
Definition: ELF.h:143
@ EM_68K
Definition: ELF.h:137
@ EM_386
Definition: ELF.h:136
@ EM_LOONGARCH
Definition: ELF.h:322
@ EM_BPF
Definition: ELF.h:319
@ EM_PPC
Definition: ELF.h:148
@ EM_X86_64
Definition: ELF.h:178
@ EM_HEXAGON
Definition: ELF.h:257
@ EM_LANAI
Definition: ELF.h:318
@ EM_MIPS
Definition: ELF.h:141
@ EM_SPARCV9
Definition: ELF.h:159
@ EM_AARCH64
Definition: ELF.h:280
@ EM_XTENSA
Definition: ELF.h:211
@ EM_ARC_COMPACT2
Definition: ELF.h:291
@ EM_RISCV
Definition: ELF.h:317
@ EM_ARC_COMPACT
Definition: ELF.h:209
@ EM_ARM
Definition: ELF.h:156
@ EM_VE
Definition: ELF.h:320
@ EM_IAMCU
Definition: ELF.h:139
@ EM_AMDGPU
Definition: ELF.h:316
@ EM_AVR
Definition: ELF.h:199
@ SHT_REL
Definition: ELF.h:1012
@ SHT_DYNAMIC
Definition: ELF.h:1009
@ SHT_LLVM_BB_ADDR_MAP
Definition: ELF.h:1041
@ SHT_RELA
Definition: ELF.h:1007
@ RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG
Definition: ELF.h:1805
@ RELOCATION_GROUPED_BY_INFO_FLAG
Definition: ELF.h:1804
@ RELOCATION_GROUPED_BY_ADDEND_FLAG
Definition: ELF.h:1806
@ RELOCATION_GROUP_HAS_ADDEND_FLAG
Definition: ELF.h:1807
@ PT_LOAD
Definition: ELF.h:1392
@ PT_DYNAMIC
Definition: ELF.h:1393
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
Expected< const typename ELFT::Shdr * > getSection(typename ELFT::ShdrRange Sections, uint32_t Index)
Definition: ELF.h:481
Error createError(const Twine &Err)
Definition: Error.h:84
StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type)
Definition: ELF.cpp:23
uint32_t getELFRelativeRelocationType(uint32_t Machine)
Definition: ELF.cpp:192
static std::string describe(const ELFFile< ELFT > &Obj, const typename ELFT::Shdr &Sec)
Definition: ELF.h:142
StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type)
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:440
void stable_sort(R &&Range)
Definition: STLExtras.h:1970
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:1958
Error joinErrors(Error E1, Error E2)
Concatenate errors.
Definition: Error.h:431
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:1906
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:749
static Expected< Metadata > decode(uint32_t V)
Definition: ELFTypes.h:825