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"
11 #include "llvm/Support/DataExtractor.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
getELFRelocationTypeName(uint32_t Machine,uint32_t Type)22 StringRef llvm::object::getELFRelocationTypeName(uint32_t Machine,
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;
68 case ELF::EM_ARC_COMPACT:
69 case ELF::EM_ARC_COMPACT2:
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 case ELF::EM_LOONGARCH:
170 switch (Type) {
171 #include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
172 default:
173 break;
174 }
175 break;
176 default:
177 break;
178 }
179 return "Unknown";
180 }
181
182 #undef ELF_RELOC
183
getELFRelativeRelocationType(uint32_t Machine)184 uint32_t llvm::object::getELFRelativeRelocationType(uint32_t Machine) {
185 switch (Machine) {
186 case ELF::EM_X86_64:
187 return ELF::R_X86_64_RELATIVE;
188 case ELF::EM_386:
189 case ELF::EM_IAMCU:
190 return ELF::R_386_RELATIVE;
191 case ELF::EM_MIPS:
192 break;
193 case ELF::EM_AARCH64:
194 return ELF::R_AARCH64_RELATIVE;
195 case ELF::EM_ARM:
196 return ELF::R_ARM_RELATIVE;
197 case ELF::EM_ARC_COMPACT:
198 case ELF::EM_ARC_COMPACT2:
199 return ELF::R_ARC_RELATIVE;
200 case ELF::EM_AVR:
201 break;
202 case ELF::EM_HEXAGON:
203 return ELF::R_HEX_RELATIVE;
204 case ELF::EM_LANAI:
205 break;
206 case ELF::EM_PPC:
207 break;
208 case ELF::EM_PPC64:
209 return ELF::R_PPC64_RELATIVE;
210 case ELF::EM_RISCV:
211 return ELF::R_RISCV_RELATIVE;
212 case ELF::EM_S390:
213 return ELF::R_390_RELATIVE;
214 case ELF::EM_SPARC:
215 case ELF::EM_SPARC32PLUS:
216 case ELF::EM_SPARCV9:
217 return ELF::R_SPARC_RELATIVE;
218 case ELF::EM_CSKY:
219 return ELF::R_CKCORE_RELATIVE;
220 case ELF::EM_VE:
221 return ELF::R_VE_RELATIVE;
222 case ELF::EM_AMDGPU:
223 break;
224 case ELF::EM_BPF:
225 break;
226 default:
227 break;
228 }
229 return 0;
230 }
231
getELFSectionTypeName(uint32_t Machine,unsigned Type)232 StringRef llvm::object::getELFSectionTypeName(uint32_t Machine, unsigned Type) {
233 switch (Machine) {
234 case ELF::EM_ARM:
235 switch (Type) {
236 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_EXIDX);
237 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
238 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
239 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
240 STRINGIFY_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
241 }
242 break;
243 case ELF::EM_HEXAGON:
244 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
245 break;
246 case ELF::EM_X86_64:
247 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
248 break;
249 case ELF::EM_MIPS:
250 case ELF::EM_MIPS_RS3_LE:
251 switch (Type) {
252 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
253 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
254 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_DWARF);
255 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
256 }
257 break;
258 case ELF::EM_MSP430:
259 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_MSP430_ATTRIBUTES); }
260 break;
261 case ELF::EM_RISCV:
262 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_RISCV_ATTRIBUTES); }
263 break;
264 default:
265 break;
266 }
267
268 switch (Type) {
269 STRINGIFY_ENUM_CASE(ELF, SHT_NULL);
270 STRINGIFY_ENUM_CASE(ELF, SHT_PROGBITS);
271 STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB);
272 STRINGIFY_ENUM_CASE(ELF, SHT_STRTAB);
273 STRINGIFY_ENUM_CASE(ELF, SHT_RELA);
274 STRINGIFY_ENUM_CASE(ELF, SHT_HASH);
275 STRINGIFY_ENUM_CASE(ELF, SHT_DYNAMIC);
276 STRINGIFY_ENUM_CASE(ELF, SHT_NOTE);
277 STRINGIFY_ENUM_CASE(ELF, SHT_NOBITS);
278 STRINGIFY_ENUM_CASE(ELF, SHT_REL);
279 STRINGIFY_ENUM_CASE(ELF, SHT_SHLIB);
280 STRINGIFY_ENUM_CASE(ELF, SHT_DYNSYM);
281 STRINGIFY_ENUM_CASE(ELF, SHT_INIT_ARRAY);
282 STRINGIFY_ENUM_CASE(ELF, SHT_FINI_ARRAY);
283 STRINGIFY_ENUM_CASE(ELF, SHT_PREINIT_ARRAY);
284 STRINGIFY_ENUM_CASE(ELF, SHT_GROUP);
285 STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX);
286 STRINGIFY_ENUM_CASE(ELF, SHT_RELR);
287 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_REL);
288 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELA);
289 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELR);
290 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB);
291 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LINKER_OPTIONS);
292 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_CALL_GRAPH_PROFILE);
293 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ADDRSIG);
294 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_DEPENDENT_LIBRARIES);
295 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_SYMPART);
296 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_EHDR);
297 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_PHDR);
298 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP_V0);
299 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP);
300 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_OFFLOADING);
301 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);
302 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);
303 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef);
304 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed);
305 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym);
306 default:
307 return "Unknown";
308 }
309 }
310
311 template <class ELFT>
312 std::vector<typename ELFT::Rel>
decode_relrs(Elf_Relr_Range relrs) const313 ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const {
314 // This function decodes the contents of an SHT_RELR packed relocation
315 // section.
316 //
317 // Proposal for adding SHT_RELR sections to generic-abi is here:
318 // https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
319 //
320 // The encoded sequence of Elf64_Relr entries in a SHT_RELR section looks
321 // like [ AAAAAAAA BBBBBBB1 BBBBBBB1 ... AAAAAAAA BBBBBB1 ... ]
322 //
323 // i.e. start with an address, followed by any number of bitmaps. The address
324 // entry encodes 1 relocation. The subsequent bitmap entries encode up to 63
325 // relocations each, at subsequent offsets following the last address entry.
326 //
327 // The bitmap entries must have 1 in the least significant bit. The assumption
328 // here is that an address cannot have 1 in lsb. Odd addresses are not
329 // supported.
330 //
331 // Excluding the least significant bit in the bitmap, each non-zero bit in
332 // the bitmap represents a relocation to be applied to a corresponding machine
333 // word that follows the base address word. The second least significant bit
334 // represents the machine word immediately following the initial address, and
335 // each bit that follows represents the next word, in linear order. As such,
336 // a single bitmap can encode up to 31 relocations in a 32-bit object, and
337 // 63 relocations in a 64-bit object.
338 //
339 // This encoding has a couple of interesting properties:
340 // 1. Looking at any entry, it is clear whether it's an address or a bitmap:
341 // even means address, odd means bitmap.
342 // 2. Just a simple list of addresses is a valid encoding.
343
344 Elf_Rel Rel;
345 Rel.r_info = 0;
346 Rel.setType(getRelativeRelocationType(), false);
347 std::vector<Elf_Rel> Relocs;
348
349 // Word type: uint32_t for Elf32, and uint64_t for Elf64.
350 using Addr = typename ELFT::uint;
351
352 Addr Base = 0;
353 for (Elf_Relr R : relrs) {
354 typename ELFT::uint Entry = R;
355 if ((Entry & 1) == 0) {
356 // Even entry: encodes the offset for next relocation.
357 Rel.r_offset = Entry;
358 Relocs.push_back(Rel);
359 // Set base offset for subsequent bitmap entries.
360 Base = Entry + sizeof(Addr);
361 } else {
362 // Odd entry: encodes bitmap for relocations starting at base.
363 for (Addr Offset = Base; (Entry >>= 1) != 0; Offset += sizeof(Addr))
364 if ((Entry & 1) != 0) {
365 Rel.r_offset = Offset;
366 Relocs.push_back(Rel);
367 }
368 Base += (CHAR_BIT * sizeof(Entry) - 1) * sizeof(Addr);
369 }
370 }
371
372 return Relocs;
373 }
374
375 template <class ELFT>
376 Expected<std::vector<typename ELFT::Rela>>
android_relas(const Elf_Shdr & Sec) const377 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>
getDynamicTagAsString(unsigned Arch,uint64_t Type) const445 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_PPC:
478 switch (Type) {
479 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
480 #include "llvm/BinaryFormat/DynamicTags.def"
481 #undef PPC_DYNAMIC_TAG
482 }
483 break;
484
485 case ELF::EM_PPC64:
486 switch (Type) {
487 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
488 #include "llvm/BinaryFormat/DynamicTags.def"
489 #undef PPC64_DYNAMIC_TAG
490 }
491 break;
492
493 case ELF::EM_RISCV:
494 switch (Type) {
495 #define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
496 #include "llvm/BinaryFormat/DynamicTags.def"
497 #undef RISCV_DYNAMIC_TAG
498 }
499 break;
500 }
501 #undef DYNAMIC_TAG
502 switch (Type) {
503 // Now handle all dynamic tags except the architecture specific ones
504 #define AARCH64_DYNAMIC_TAG(name, value)
505 #define MIPS_DYNAMIC_TAG(name, value)
506 #define HEXAGON_DYNAMIC_TAG(name, value)
507 #define PPC_DYNAMIC_TAG(name, value)
508 #define PPC64_DYNAMIC_TAG(name, value)
509 #define RISCV_DYNAMIC_TAG(name, value)
510 // Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
511 #define DYNAMIC_TAG_MARKER(name, value)
512 #define DYNAMIC_TAG(name, value) case value: return #name;
513 #include "llvm/BinaryFormat/DynamicTags.def"
514 #undef DYNAMIC_TAG
515 #undef AARCH64_DYNAMIC_TAG
516 #undef MIPS_DYNAMIC_TAG
517 #undef HEXAGON_DYNAMIC_TAG
518 #undef PPC_DYNAMIC_TAG
519 #undef PPC64_DYNAMIC_TAG
520 #undef RISCV_DYNAMIC_TAG
521 #undef DYNAMIC_TAG_MARKER
522 #undef DYNAMIC_STRINGIFY_ENUM
523 default:
524 return "<unknown:>0x" + utohexstr(Type, true);
525 }
526 }
527
528 template <class ELFT>
getDynamicTagAsString(uint64_t Type) const529 std::string ELFFile<ELFT>::getDynamicTagAsString(uint64_t Type) const {
530 return getDynamicTagAsString(getHeader().e_machine, Type);
531 }
532
533 template <class ELFT>
dynamicEntries() const534 Expected<typename ELFT::DynRange> ELFFile<ELFT>::dynamicEntries() const {
535 ArrayRef<Elf_Dyn> Dyn;
536
537 auto ProgramHeadersOrError = program_headers();
538 if (!ProgramHeadersOrError)
539 return ProgramHeadersOrError.takeError();
540
541 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
542 if (Phdr.p_type == ELF::PT_DYNAMIC) {
543 Dyn = makeArrayRef(
544 reinterpret_cast<const Elf_Dyn *>(base() + Phdr.p_offset),
545 Phdr.p_filesz / sizeof(Elf_Dyn));
546 break;
547 }
548 }
549
550 // If we can't find the dynamic section in the program headers, we just fall
551 // back on the sections.
552 if (Dyn.empty()) {
553 auto SectionsOrError = sections();
554 if (!SectionsOrError)
555 return SectionsOrError.takeError();
556
557 for (const Elf_Shdr &Sec : *SectionsOrError) {
558 if (Sec.sh_type == ELF::SHT_DYNAMIC) {
559 Expected<ArrayRef<Elf_Dyn>> DynOrError =
560 getSectionContentsAsArray<Elf_Dyn>(Sec);
561 if (!DynOrError)
562 return DynOrError.takeError();
563 Dyn = *DynOrError;
564 break;
565 }
566 }
567
568 if (!Dyn.data())
569 return ArrayRef<Elf_Dyn>();
570 }
571
572 if (Dyn.empty())
573 return createError("invalid empty dynamic section");
574
575 if (Dyn.back().d_tag != ELF::DT_NULL)
576 return createError("dynamic sections must be DT_NULL terminated");
577
578 return Dyn;
579 }
580
581 template <class ELFT>
582 Expected<const uint8_t *>
toMappedAddr(uint64_t VAddr,WarningHandler WarnHandler) const583 ELFFile<ELFT>::toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler) const {
584 auto ProgramHeadersOrError = program_headers();
585 if (!ProgramHeadersOrError)
586 return ProgramHeadersOrError.takeError();
587
588 llvm::SmallVector<Elf_Phdr *, 4> LoadSegments;
589
590 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)
591 if (Phdr.p_type == ELF::PT_LOAD)
592 LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr));
593
594 auto SortPred = [](const Elf_Phdr_Impl<ELFT> *A,
595 const Elf_Phdr_Impl<ELFT> *B) {
596 return A->p_vaddr < B->p_vaddr;
597 };
598 if (!llvm::is_sorted(LoadSegments, SortPred)) {
599 if (Error E =
600 WarnHandler("loadable segments are unsorted by virtual address"))
601 return std::move(E);
602 llvm::stable_sort(LoadSegments, SortPred);
603 }
604
605 const Elf_Phdr *const *I = llvm::upper_bound(
606 LoadSegments, VAddr, [](uint64_t VAddr, const Elf_Phdr_Impl<ELFT> *Phdr) {
607 return VAddr < Phdr->p_vaddr;
608 });
609
610 if (I == LoadSegments.begin())
611 return createError("virtual address is not in any segment: 0x" +
612 Twine::utohexstr(VAddr));
613 --I;
614 const Elf_Phdr &Phdr = **I;
615 uint64_t Delta = VAddr - Phdr.p_vaddr;
616 if (Delta >= Phdr.p_filesz)
617 return createError("virtual address is not in any segment: 0x" +
618 Twine::utohexstr(VAddr));
619
620 uint64_t Offset = Phdr.p_offset + Delta;
621 if (Offset >= getBufSize())
622 return createError("can't map virtual address 0x" +
623 Twine::utohexstr(VAddr) + " to the segment with index " +
624 Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +
625 ": the segment ends at 0x" +
626 Twine::utohexstr(Phdr.p_offset + Phdr.p_filesz) +
627 ", which is greater than the file size (0x" +
628 Twine::utohexstr(getBufSize()) + ")");
629
630 return base() + Offset;
631 }
632
633 template <class ELFT>
634 Expected<std::vector<BBAddrMap>>
decodeBBAddrMap(const Elf_Shdr & Sec) const635 ELFFile<ELFT>::decodeBBAddrMap(const Elf_Shdr &Sec) const {
636 Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
637 if (!ContentsOrErr)
638 return ContentsOrErr.takeError();
639 ArrayRef<uint8_t> Content = *ContentsOrErr;
640 DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
641 std::vector<BBAddrMap> FunctionEntries;
642
643 DataExtractor::Cursor Cur(0);
644 Error ULEBSizeErr = Error::success();
645 // Helper to extract and decode the next ULEB128 value as uint32_t.
646 // Returns zero and sets ULEBSizeErr if the ULEB128 value exceeds the uint32_t
647 // limit.
648 // Also returns zero if ULEBSizeErr is already in an error state.
649 auto ReadULEB128AsUInt32 = [&Data, &Cur, &ULEBSizeErr]() -> uint32_t {
650 // Bail out and do not extract data if ULEBSizeErr is already set.
651 if (ULEBSizeErr)
652 return 0;
653 uint64_t Offset = Cur.tell();
654 uint64_t Value = Data.getULEB128(Cur);
655 if (Value > UINT32_MAX) {
656 ULEBSizeErr = createError(
657 "ULEB128 value at offset 0x" + Twine::utohexstr(Offset) +
658 " exceeds UINT32_MAX (0x" + Twine::utohexstr(Value) + ")");
659 return 0;
660 }
661 return static_cast<uint32_t>(Value);
662 };
663
664 uint8_t Version = 0;
665 while (!ULEBSizeErr && Cur && Cur.tell() < Content.size()) {
666 if (Sec.sh_type == ELF::SHT_LLVM_BB_ADDR_MAP) {
667 Version = Data.getU8(Cur);
668 if (!Cur)
669 break;
670 if (Version > 1)
671 return createError("unsupported SHT_LLVM_BB_ADDR_MAP version: " +
672 Twine(static_cast<int>(Version)));
673 Data.getU8(Cur); // Feature byte
674 }
675 uintX_t Address = static_cast<uintX_t>(Data.getAddress(Cur));
676 uint32_t NumBlocks = ReadULEB128AsUInt32();
677 std::vector<BBAddrMap::BBEntry> BBEntries;
678 uint32_t PrevBBEndOffset = 0;
679 for (uint32_t BlockID = 0; !ULEBSizeErr && Cur && (BlockID < NumBlocks);
680 ++BlockID) {
681 uint32_t Offset = ReadULEB128AsUInt32();
682 uint32_t Size = ReadULEB128AsUInt32();
683 uint32_t Metadata = ReadULEB128AsUInt32();
684 if (Version >= 1) {
685 // Offset is calculated relative to the end of the previous BB.
686 Offset += PrevBBEndOffset;
687 PrevBBEndOffset = Offset + Size;
688 }
689 BBEntries.push_back({Offset, Size, Metadata});
690 }
691 FunctionEntries.push_back({Address, std::move(BBEntries)});
692 }
693 // Either Cur is in the error state, or ULEBSizeError is set (not both), but
694 // we join the two errors here to be safe.
695 if (!Cur || ULEBSizeErr)
696 return joinErrors(Cur.takeError(), std::move(ULEBSizeErr));
697 return FunctionEntries;
698 }
699
700 template class llvm::object::ELFFile<ELF32LE>;
701 template class llvm::object::ELFFile<ELF32BE>;
702 template class llvm::object::ELFFile<ELF64LE>;
703 template class llvm::object::ELFFile<ELF64BE>;
704