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
14 using namespace llvm;
15 using 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
getELFRelocationTypeName(uint32_t Machine,uint32_t Type)23 StringRef 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
getELFRelativeRelocationType(uint32_t Machine)192 uint32_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
getELFSectionTypeName(uint32_t Machine,unsigned Type)242 StringRef 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) {
255 STRINGIFY_ENUM_CASE(ELF, SHT_HEX_ORDERED);
256 STRINGIFY_ENUM_CASE(ELF, SHT_HEXAGON_ATTRIBUTES);
257 }
258 break;
259 case ELF::EM_X86_64:
260 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
261 break;
262 case ELF::EM_MIPS:
263 case ELF::EM_MIPS_RS3_LE:
264 switch (Type) {
265 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
266 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
267 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_DWARF);
268 STRINGIFY_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
269 }
270 break;
271 case ELF::EM_MSP430:
272 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_MSP430_ATTRIBUTES); }
273 break;
274 case ELF::EM_RISCV:
275 switch (Type) { STRINGIFY_ENUM_CASE(ELF, SHT_RISCV_ATTRIBUTES); }
276 break;
277 case ELF::EM_AARCH64:
278 switch (Type) {
279 STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_AUTH_RELR);
280 STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_MEMTAG_GLOBALS_DYNAMIC);
281 STRINGIFY_ENUM_CASE(ELF, SHT_AARCH64_MEMTAG_GLOBALS_STATIC);
282 }
283 default:
284 break;
285 }
286
287 switch (Type) {
288 STRINGIFY_ENUM_CASE(ELF, SHT_NULL);
289 STRINGIFY_ENUM_CASE(ELF, SHT_PROGBITS);
290 STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB);
291 STRINGIFY_ENUM_CASE(ELF, SHT_STRTAB);
292 STRINGIFY_ENUM_CASE(ELF, SHT_RELA);
293 STRINGIFY_ENUM_CASE(ELF, SHT_HASH);
294 STRINGIFY_ENUM_CASE(ELF, SHT_DYNAMIC);
295 STRINGIFY_ENUM_CASE(ELF, SHT_NOTE);
296 STRINGIFY_ENUM_CASE(ELF, SHT_NOBITS);
297 STRINGIFY_ENUM_CASE(ELF, SHT_REL);
298 STRINGIFY_ENUM_CASE(ELF, SHT_SHLIB);
299 STRINGIFY_ENUM_CASE(ELF, SHT_DYNSYM);
300 STRINGIFY_ENUM_CASE(ELF, SHT_INIT_ARRAY);
301 STRINGIFY_ENUM_CASE(ELF, SHT_FINI_ARRAY);
302 STRINGIFY_ENUM_CASE(ELF, SHT_PREINIT_ARRAY);
303 STRINGIFY_ENUM_CASE(ELF, SHT_GROUP);
304 STRINGIFY_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX);
305 STRINGIFY_ENUM_CASE(ELF, SHT_RELR);
306 STRINGIFY_ENUM_CASE(ELF, SHT_CREL);
307 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_REL);
308 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELA);
309 STRINGIFY_ENUM_CASE(ELF, SHT_ANDROID_RELR);
310 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ODRTAB);
311 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LINKER_OPTIONS);
312 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_CALL_GRAPH_PROFILE);
313 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_ADDRSIG);
314 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_DEPENDENT_LIBRARIES);
315 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_SYMPART);
316 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_EHDR);
317 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_PART_PHDR);
318 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP_V0);
319 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_BB_ADDR_MAP);
320 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_OFFLOADING);
321 STRINGIFY_ENUM_CASE(ELF, SHT_LLVM_LTO);
322 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES);
323 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_HASH);
324 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verdef);
325 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_verneed);
326 STRINGIFY_ENUM_CASE(ELF, SHT_GNU_versym);
327 default:
328 return "Unknown";
329 }
330 }
331
332 template <class ELFT>
333 std::vector<typename ELFT::Rel>
decode_relrs(Elf_Relr_Range relrs) const334 ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const {
335 // This function decodes the contents of an SHT_RELR packed relocation
336 // section.
337 //
338 // Proposal for adding SHT_RELR sections to generic-abi is here:
339 // https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
340 //
341 // The encoded sequence of Elf64_Relr entries in a SHT_RELR section looks
342 // like [ AAAAAAAA BBBBBBB1 BBBBBBB1 ... AAAAAAAA BBBBBB1 ... ]
343 //
344 // i.e. start with an address, followed by any number of bitmaps. The address
345 // entry encodes 1 relocation. The subsequent bitmap entries encode up to 63
346 // relocations each, at subsequent offsets following the last address entry.
347 //
348 // The bitmap entries must have 1 in the least significant bit. The assumption
349 // here is that an address cannot have 1 in lsb. Odd addresses are not
350 // supported.
351 //
352 // Excluding the least significant bit in the bitmap, each non-zero bit in
353 // the bitmap represents a relocation to be applied to a corresponding machine
354 // word that follows the base address word. The second least significant bit
355 // represents the machine word immediately following the initial address, and
356 // each bit that follows represents the next word, in linear order. As such,
357 // a single bitmap can encode up to 31 relocations in a 32-bit object, and
358 // 63 relocations in a 64-bit object.
359 //
360 // This encoding has a couple of interesting properties:
361 // 1. Looking at any entry, it is clear whether it's an address or a bitmap:
362 // even means address, odd means bitmap.
363 // 2. Just a simple list of addresses is a valid encoding.
364
365 Elf_Rel Rel;
366 Rel.r_info = 0;
367 Rel.setType(getRelativeRelocationType(), false);
368 std::vector<Elf_Rel> Relocs;
369
370 // Word type: uint32_t for Elf32, and uint64_t for Elf64.
371 using Addr = typename ELFT::uint;
372
373 Addr Base = 0;
374 for (Elf_Relr R : relrs) {
375 typename ELFT::uint Entry = R;
376 if ((Entry & 1) == 0) {
377 // Even entry: encodes the offset for next relocation.
378 Rel.r_offset = Entry;
379 Relocs.push_back(Rel);
380 // Set base offset for subsequent bitmap entries.
381 Base = Entry + sizeof(Addr);
382 } else {
383 // Odd entry: encodes bitmap for relocations starting at base.
384 for (Addr Offset = Base; (Entry >>= 1) != 0; Offset += sizeof(Addr))
385 if ((Entry & 1) != 0) {
386 Rel.r_offset = Offset;
387 Relocs.push_back(Rel);
388 }
389 Base += (CHAR_BIT * sizeof(Entry) - 1) * sizeof(Addr);
390 }
391 }
392
393 return Relocs;
394 }
395
396 template <class ELFT>
397 Expected<uint64_t>
getCrelHeader(ArrayRef<uint8_t> Content) const398 ELFFile<ELFT>::getCrelHeader(ArrayRef<uint8_t> Content) const {
399 DataExtractor Data(Content, isLE(), sizeof(typename ELFT::Addr));
400 Error Err = Error::success();
401 uint64_t Hdr = 0;
402 Hdr = Data.getULEB128(&Hdr, &Err);
403 if (Err)
404 return Err;
405 return Hdr;
406 }
407
408 template <class ELFT>
409 Expected<typename ELFFile<ELFT>::RelsOrRelas>
decodeCrel(ArrayRef<uint8_t> Content) const410 ELFFile<ELFT>::decodeCrel(ArrayRef<uint8_t> Content) const {
411 std::vector<Elf_Rel> Rels;
412 std::vector<Elf_Rela> Relas;
413 size_t I = 0;
414 bool HasAddend;
415 Error Err = object::decodeCrel<ELFT::Is64Bits>(
416 Content,
417 [&](uint64_t Count, bool HasA) {
418 HasAddend = HasA;
419 if (HasAddend)
420 Relas.resize(Count);
421 else
422 Rels.resize(Count);
423 },
424 [&](Elf_Crel Crel) {
425 if (HasAddend) {
426 Relas[I].r_offset = Crel.r_offset;
427 Relas[I].setSymbolAndType(Crel.r_symidx, Crel.r_type, false);
428 Relas[I++].r_addend = Crel.r_addend;
429 } else {
430 Rels[I].r_offset = Crel.r_offset;
431 Rels[I++].setSymbolAndType(Crel.r_symidx, Crel.r_type, false);
432 }
433 });
434 if (Err)
435 return std::move(Err);
436 return std::make_pair(std::move(Rels), std::move(Relas));
437 }
438
439 template <class ELFT>
440 Expected<typename ELFFile<ELFT>::RelsOrRelas>
crels(const Elf_Shdr & Sec) const441 ELFFile<ELFT>::crels(const Elf_Shdr &Sec) const {
442 Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
443 if (!ContentsOrErr)
444 return ContentsOrErr.takeError();
445 return decodeCrel(*ContentsOrErr);
446 }
447
448 template <class ELFT>
449 Expected<std::vector<typename ELFT::Rela>>
android_relas(const Elf_Shdr & Sec) const450 ELFFile<ELFT>::android_relas(const Elf_Shdr &Sec) const {
451 // This function reads relocations in Android's packed relocation format,
452 // which is based on SLEB128 and delta encoding.
453 Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
454 if (!ContentsOrErr)
455 return ContentsOrErr.takeError();
456 ArrayRef<uint8_t> Content = *ContentsOrErr;
457 if (Content.size() < 4 || Content[0] != 'A' || Content[1] != 'P' ||
458 Content[2] != 'S' || Content[3] != '2')
459 return createError("invalid packed relocation header");
460 DataExtractor Data(Content, isLE(), ELFT::Is64Bits ? 8 : 4);
461 DataExtractor::Cursor Cur(/*Offset=*/4);
462
463 uint64_t NumRelocs = Data.getSLEB128(Cur);
464 uint64_t Offset = Data.getSLEB128(Cur);
465 uint64_t Addend = 0;
466
467 if (!Cur)
468 return std::move(Cur.takeError());
469
470 std::vector<Elf_Rela> Relocs;
471 Relocs.reserve(NumRelocs);
472 while (NumRelocs) {
473 uint64_t NumRelocsInGroup = Data.getSLEB128(Cur);
474 if (!Cur)
475 return std::move(Cur.takeError());
476 if (NumRelocsInGroup > NumRelocs)
477 return createError("relocation group unexpectedly large");
478 NumRelocs -= NumRelocsInGroup;
479
480 uint64_t GroupFlags = Data.getSLEB128(Cur);
481 bool GroupedByInfo = GroupFlags & ELF::RELOCATION_GROUPED_BY_INFO_FLAG;
482 bool GroupedByOffsetDelta = GroupFlags & ELF::RELOCATION_GROUPED_BY_OFFSET_DELTA_FLAG;
483 bool GroupedByAddend = GroupFlags & ELF::RELOCATION_GROUPED_BY_ADDEND_FLAG;
484 bool GroupHasAddend = GroupFlags & ELF::RELOCATION_GROUP_HAS_ADDEND_FLAG;
485
486 uint64_t GroupOffsetDelta;
487 if (GroupedByOffsetDelta)
488 GroupOffsetDelta = Data.getSLEB128(Cur);
489
490 uint64_t GroupRInfo;
491 if (GroupedByInfo)
492 GroupRInfo = Data.getSLEB128(Cur);
493
494 if (GroupedByAddend && GroupHasAddend)
495 Addend += Data.getSLEB128(Cur);
496
497 if (!GroupHasAddend)
498 Addend = 0;
499
500 for (uint64_t I = 0; Cur && I != NumRelocsInGroup; ++I) {
501 Elf_Rela R;
502 Offset += GroupedByOffsetDelta ? GroupOffsetDelta : Data.getSLEB128(Cur);
503 R.r_offset = Offset;
504 R.r_info = GroupedByInfo ? GroupRInfo : Data.getSLEB128(Cur);
505 if (GroupHasAddend && !GroupedByAddend)
506 Addend += Data.getSLEB128(Cur);
507 R.r_addend = Addend;
508 Relocs.push_back(R);
509 }
510 if (!Cur)
511 return std::move(Cur.takeError());
512 }
513
514 return Relocs;
515 }
516
517 template <class ELFT>
getDynamicTagAsString(unsigned Arch,uint64_t Type) const518 std::string ELFFile<ELFT>::getDynamicTagAsString(unsigned Arch,
519 uint64_t Type) const {
520 #define DYNAMIC_STRINGIFY_ENUM(tag, value) \
521 case value: \
522 return #tag;
523
524 #define DYNAMIC_TAG(n, v)
525 switch (Arch) {
526 case ELF::EM_AARCH64:
527 switch (Type) {
528 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
529 #include "llvm/BinaryFormat/DynamicTags.def"
530 #undef AARCH64_DYNAMIC_TAG
531 }
532 break;
533
534 case ELF::EM_HEXAGON:
535 switch (Type) {
536 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
537 #include "llvm/BinaryFormat/DynamicTags.def"
538 #undef HEXAGON_DYNAMIC_TAG
539 }
540 break;
541
542 case ELF::EM_MIPS:
543 switch (Type) {
544 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
545 #include "llvm/BinaryFormat/DynamicTags.def"
546 #undef MIPS_DYNAMIC_TAG
547 }
548 break;
549
550 case ELF::EM_PPC:
551 switch (Type) {
552 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
553 #include "llvm/BinaryFormat/DynamicTags.def"
554 #undef PPC_DYNAMIC_TAG
555 }
556 break;
557
558 case ELF::EM_PPC64:
559 switch (Type) {
560 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
561 #include "llvm/BinaryFormat/DynamicTags.def"
562 #undef PPC64_DYNAMIC_TAG
563 }
564 break;
565
566 case ELF::EM_RISCV:
567 switch (Type) {
568 #define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
569 #include "llvm/BinaryFormat/DynamicTags.def"
570 #undef RISCV_DYNAMIC_TAG
571 }
572 break;
573 }
574 #undef DYNAMIC_TAG
575 switch (Type) {
576 // Now handle all dynamic tags except the architecture specific ones
577 #define AARCH64_DYNAMIC_TAG(name, value)
578 #define MIPS_DYNAMIC_TAG(name, value)
579 #define HEXAGON_DYNAMIC_TAG(name, value)
580 #define PPC_DYNAMIC_TAG(name, value)
581 #define PPC64_DYNAMIC_TAG(name, value)
582 #define RISCV_DYNAMIC_TAG(name, value)
583 // Also ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
584 #define DYNAMIC_TAG_MARKER(name, value)
585 #define DYNAMIC_TAG(name, value) case value: return #name;
586 #include "llvm/BinaryFormat/DynamicTags.def"
587 #undef DYNAMIC_TAG
588 #undef AARCH64_DYNAMIC_TAG
589 #undef MIPS_DYNAMIC_TAG
590 #undef HEXAGON_DYNAMIC_TAG
591 #undef PPC_DYNAMIC_TAG
592 #undef PPC64_DYNAMIC_TAG
593 #undef RISCV_DYNAMIC_TAG
594 #undef DYNAMIC_TAG_MARKER
595 #undef DYNAMIC_STRINGIFY_ENUM
596 default:
597 return "<unknown:>0x" + utohexstr(Type, true);
598 }
599 }
600
601 template <class ELFT>
getDynamicTagAsString(uint64_t Type) const602 std::string ELFFile<ELFT>::getDynamicTagAsString(uint64_t Type) const {
603 return getDynamicTagAsString(getHeader().e_machine, Type);
604 }
605
606 template <class ELFT>
dynamicEntries() const607 Expected<typename ELFT::DynRange> ELFFile<ELFT>::dynamicEntries() const {
608 ArrayRef<Elf_Dyn> Dyn;
609
610 auto ProgramHeadersOrError = program_headers();
611 if (!ProgramHeadersOrError)
612 return ProgramHeadersOrError.takeError();
613
614 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
615 if (Phdr.p_type == ELF::PT_DYNAMIC) {
616 const uint8_t *DynOffset = base() + Phdr.p_offset;
617 if (DynOffset > end())
618 return createError(
619 "dynamic section offset past file size: corrupted ELF");
620 Dyn = ArrayRef(reinterpret_cast<const Elf_Dyn *>(DynOffset),
621 Phdr.p_filesz / sizeof(Elf_Dyn));
622 break;
623 }
624 }
625
626 // If we can't find the dynamic section in the program headers, we just fall
627 // back on the sections.
628 if (Dyn.empty()) {
629 auto SectionsOrError = sections();
630 if (!SectionsOrError)
631 return SectionsOrError.takeError();
632
633 for (const Elf_Shdr &Sec : *SectionsOrError) {
634 if (Sec.sh_type == ELF::SHT_DYNAMIC) {
635 Expected<ArrayRef<Elf_Dyn>> DynOrError =
636 getSectionContentsAsArray<Elf_Dyn>(Sec);
637 if (!DynOrError)
638 return DynOrError.takeError();
639 Dyn = *DynOrError;
640 break;
641 }
642 }
643
644 if (!Dyn.data())
645 return ArrayRef<Elf_Dyn>();
646 }
647
648 if (Dyn.empty())
649 return createError("invalid empty dynamic section");
650
651 if (Dyn.back().d_tag != ELF::DT_NULL)
652 return createError("dynamic sections must be DT_NULL terminated");
653
654 return Dyn;
655 }
656
657 template <class ELFT>
658 Expected<const uint8_t *>
toMappedAddr(uint64_t VAddr,WarningHandler WarnHandler) const659 ELFFile<ELFT>::toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler) const {
660 auto ProgramHeadersOrError = program_headers();
661 if (!ProgramHeadersOrError)
662 return ProgramHeadersOrError.takeError();
663
664 llvm::SmallVector<Elf_Phdr *, 4> LoadSegments;
665
666 for (const Elf_Phdr &Phdr : *ProgramHeadersOrError)
667 if (Phdr.p_type == ELF::PT_LOAD)
668 LoadSegments.push_back(const_cast<Elf_Phdr *>(&Phdr));
669
670 auto SortPred = [](const Elf_Phdr_Impl<ELFT> *A,
671 const Elf_Phdr_Impl<ELFT> *B) {
672 return A->p_vaddr < B->p_vaddr;
673 };
674 if (!llvm::is_sorted(LoadSegments, SortPred)) {
675 if (Error E =
676 WarnHandler("loadable segments are unsorted by virtual address"))
677 return std::move(E);
678 llvm::stable_sort(LoadSegments, SortPred);
679 }
680
681 const Elf_Phdr *const *I = llvm::upper_bound(
682 LoadSegments, VAddr, [](uint64_t VAddr, const Elf_Phdr_Impl<ELFT> *Phdr) {
683 return VAddr < Phdr->p_vaddr;
684 });
685
686 if (I == LoadSegments.begin())
687 return createError("virtual address is not in any segment: 0x" +
688 Twine::utohexstr(VAddr));
689 --I;
690 const Elf_Phdr &Phdr = **I;
691 uint64_t Delta = VAddr - Phdr.p_vaddr;
692 if (Delta >= Phdr.p_filesz)
693 return createError("virtual address is not in any segment: 0x" +
694 Twine::utohexstr(VAddr));
695
696 uint64_t Offset = Phdr.p_offset + Delta;
697 if (Offset >= getBufSize())
698 return createError("can't map virtual address 0x" +
699 Twine::utohexstr(VAddr) + " to the segment with index " +
700 Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +
701 ": the segment ends at 0x" +
702 Twine::utohexstr(Phdr.p_offset + Phdr.p_filesz) +
703 ", which is greater than the file size (0x" +
704 Twine::utohexstr(getBufSize()) + ")");
705
706 return base() + Offset;
707 }
708
709 // Helper to extract and decode the next ULEB128 value as unsigned int.
710 // Returns zero and sets ULEBSizeErr if the ULEB128 value exceeds the unsigned
711 // int limit.
712 // Also returns zero if ULEBSizeErr is already in an error state.
713 // ULEBSizeErr is an out variable if an error occurs.
714 template <typename IntTy, std::enable_if_t<std::is_unsigned_v<IntTy>, int> = 0>
readULEB128As(DataExtractor & Data,DataExtractor::Cursor & Cur,Error & ULEBSizeErr)715 static IntTy readULEB128As(DataExtractor &Data, DataExtractor::Cursor &Cur,
716 Error &ULEBSizeErr) {
717 // Bail out and do not extract data if ULEBSizeErr is already set.
718 if (ULEBSizeErr)
719 return 0;
720 uint64_t Offset = Cur.tell();
721 uint64_t Value = Data.getULEB128(Cur);
722 if (Value > std::numeric_limits<IntTy>::max()) {
723 ULEBSizeErr = createError("ULEB128 value at offset 0x" +
724 Twine::utohexstr(Offset) + " exceeds UINT" +
725 Twine(std::numeric_limits<IntTy>::digits) +
726 "_MAX (0x" + Twine::utohexstr(Value) + ")");
727 return 0;
728 }
729 return static_cast<IntTy>(Value);
730 }
731
732 template <typename ELFT>
733 static Expected<std::vector<BBAddrMap>>
decodeBBAddrMapImpl(const ELFFile<ELFT> & EF,const typename ELFFile<ELFT>::Elf_Shdr & Sec,const typename ELFFile<ELFT>::Elf_Shdr * RelaSec,std::vector<PGOAnalysisMap> * PGOAnalyses)734 decodeBBAddrMapImpl(const ELFFile<ELFT> &EF,
735 const typename ELFFile<ELFT>::Elf_Shdr &Sec,
736 const typename ELFFile<ELFT>::Elf_Shdr *RelaSec,
737 std::vector<PGOAnalysisMap> *PGOAnalyses) {
738 bool IsRelocatable = EF.getHeader().e_type == ELF::ET_REL;
739
740 // This DenseMap maps the offset of each function (the location of the
741 // reference to the function in the SHT_LLVM_BB_ADDR_MAP section) to the
742 // addend (the location of the function in the text section).
743 llvm::DenseMap<uint64_t, uint64_t> FunctionOffsetTranslations;
744 if (IsRelocatable && RelaSec) {
745 assert(RelaSec &&
746 "Can't read a SHT_LLVM_BB_ADDR_MAP section in a relocatable "
747 "object file without providing a relocation section.");
748 Expected<typename ELFFile<ELFT>::Elf_Rela_Range> Relas = EF.relas(*RelaSec);
749 if (!Relas)
750 return createError("unable to read relocations for section " +
751 describe(EF, Sec) + ": " +
752 toString(Relas.takeError()));
753 for (typename ELFFile<ELFT>::Elf_Rela Rela : *Relas)
754 FunctionOffsetTranslations[Rela.r_offset] = Rela.r_addend;
755 }
756 auto GetAddressForRelocation =
757 [&](unsigned RelocationOffsetInSection) -> Expected<unsigned> {
758 auto FOTIterator =
759 FunctionOffsetTranslations.find(RelocationOffsetInSection);
760 if (FOTIterator == FunctionOffsetTranslations.end()) {
761 return createError("failed to get relocation data for offset: " +
762 Twine::utohexstr(RelocationOffsetInSection) +
763 " in section " + describe(EF, Sec));
764 }
765 return FOTIterator->second;
766 };
767 Expected<ArrayRef<uint8_t>> ContentsOrErr = EF.getSectionContents(Sec);
768 if (!ContentsOrErr)
769 return ContentsOrErr.takeError();
770 ArrayRef<uint8_t> Content = *ContentsOrErr;
771 DataExtractor Data(Content, EF.isLE(), ELFT::Is64Bits ? 8 : 4);
772 std::vector<BBAddrMap> FunctionEntries;
773
774 DataExtractor::Cursor Cur(0);
775 Error ULEBSizeErr = Error::success();
776 Error MetadataDecodeErr = Error::success();
777
778 // Helper lampda to extract the (possiblly relocatable) address stored at Cur.
779 auto ExtractAddress = [&]() -> Expected<typename ELFFile<ELFT>::uintX_t> {
780 uint64_t RelocationOffsetInSection = Cur.tell();
781 auto Address =
782 static_cast<typename ELFFile<ELFT>::uintX_t>(Data.getAddress(Cur));
783 if (!Cur)
784 return Cur.takeError();
785 if (!IsRelocatable)
786 return Address;
787 assert(Address == 0);
788 Expected<unsigned> AddressOrErr =
789 GetAddressForRelocation(RelocationOffsetInSection);
790 if (!AddressOrErr)
791 return AddressOrErr.takeError();
792 return *AddressOrErr;
793 };
794
795 uint8_t Version = 0;
796 uint8_t Feature = 0;
797 BBAddrMap::Features FeatEnable{};
798 while (!ULEBSizeErr && !MetadataDecodeErr && Cur &&
799 Cur.tell() < Content.size()) {
800 if (Sec.sh_type == ELF::SHT_LLVM_BB_ADDR_MAP) {
801 Version = Data.getU8(Cur);
802 if (!Cur)
803 break;
804 if (Version > 2)
805 return createError("unsupported SHT_LLVM_BB_ADDR_MAP version: " +
806 Twine(static_cast<int>(Version)));
807 Feature = Data.getU8(Cur); // Feature byte
808 if (!Cur)
809 break;
810 auto FeatEnableOrErr = BBAddrMap::Features::decode(Feature);
811 if (!FeatEnableOrErr)
812 return FeatEnableOrErr.takeError();
813 FeatEnable = *FeatEnableOrErr;
814 if (Feature != 0 && Version < 2 && Cur)
815 return createError(
816 "version should be >= 2 for SHT_LLVM_BB_ADDR_MAP when "
817 "PGO features are enabled: version = " +
818 Twine(static_cast<int>(Version)) +
819 " feature = " + Twine(static_cast<int>(Feature)));
820 }
821 uint32_t NumBlocksInBBRange = 0;
822 uint32_t NumBBRanges = 1;
823 typename ELFFile<ELFT>::uintX_t RangeBaseAddress = 0;
824 std::vector<BBAddrMap::BBEntry> BBEntries;
825 if (FeatEnable.MultiBBRange) {
826 NumBBRanges = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
827 if (!Cur || ULEBSizeErr)
828 break;
829 if (!NumBBRanges)
830 return createError("invalid zero number of BB ranges at offset " +
831 Twine::utohexstr(Cur.tell()) + " in " +
832 describe(EF, Sec));
833 } else {
834 auto AddressOrErr = ExtractAddress();
835 if (!AddressOrErr)
836 return AddressOrErr.takeError();
837 RangeBaseAddress = *AddressOrErr;
838 NumBlocksInBBRange = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
839 }
840 std::vector<BBAddrMap::BBRangeEntry> BBRangeEntries;
841 uint32_t TotalNumBlocks = 0;
842 for (uint32_t BBRangeIndex = 0; BBRangeIndex < NumBBRanges;
843 ++BBRangeIndex) {
844 uint32_t PrevBBEndOffset = 0;
845 if (FeatEnable.MultiBBRange) {
846 auto AddressOrErr = ExtractAddress();
847 if (!AddressOrErr)
848 return AddressOrErr.takeError();
849 RangeBaseAddress = *AddressOrErr;
850 NumBlocksInBBRange = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
851 }
852 for (uint32_t BlockIndex = 0; !MetadataDecodeErr && !ULEBSizeErr && Cur &&
853 (BlockIndex < NumBlocksInBBRange);
854 ++BlockIndex) {
855 uint32_t ID = Version >= 2
856 ? readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr)
857 : BlockIndex;
858 uint32_t Offset = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
859 uint32_t Size = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
860 uint32_t MD = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
861 if (Version >= 1) {
862 // Offset is calculated relative to the end of the previous BB.
863 Offset += PrevBBEndOffset;
864 PrevBBEndOffset = Offset + Size;
865 }
866 Expected<BBAddrMap::BBEntry::Metadata> MetadataOrErr =
867 BBAddrMap::BBEntry::Metadata::decode(MD);
868 if (!MetadataOrErr) {
869 MetadataDecodeErr = MetadataOrErr.takeError();
870 break;
871 }
872 BBEntries.push_back({ID, Offset, Size, *MetadataOrErr});
873 }
874 TotalNumBlocks += BBEntries.size();
875 BBRangeEntries.push_back({RangeBaseAddress, std::move(BBEntries)});
876 }
877 FunctionEntries.push_back({std::move(BBRangeEntries)});
878
879 if (PGOAnalyses || FeatEnable.hasPGOAnalysis()) {
880 // Function entry count
881 uint64_t FuncEntryCount =
882 FeatEnable.FuncEntryCount
883 ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr)
884 : 0;
885
886 std::vector<PGOAnalysisMap::PGOBBEntry> PGOBBEntries;
887 for (uint32_t BlockIndex = 0;
888 FeatEnable.hasPGOAnalysisBBData() && !MetadataDecodeErr &&
889 !ULEBSizeErr && Cur && (BlockIndex < TotalNumBlocks);
890 ++BlockIndex) {
891 // Block frequency
892 uint64_t BBF = FeatEnable.BBFreq
893 ? readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr)
894 : 0;
895
896 // Branch probability
897 llvm::SmallVector<PGOAnalysisMap::PGOBBEntry::SuccessorEntry, 2>
898 Successors;
899 if (FeatEnable.BrProb) {
900 auto SuccCount = readULEB128As<uint64_t>(Data, Cur, ULEBSizeErr);
901 for (uint64_t I = 0; I < SuccCount; ++I) {
902 uint32_t BBID = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
903 uint32_t BrProb = readULEB128As<uint32_t>(Data, Cur, ULEBSizeErr);
904 if (PGOAnalyses)
905 Successors.push_back({BBID, BranchProbability::getRaw(BrProb)});
906 }
907 }
908
909 if (PGOAnalyses)
910 PGOBBEntries.push_back({BlockFrequency(BBF), std::move(Successors)});
911 }
912
913 if (PGOAnalyses)
914 PGOAnalyses->push_back(
915 {FuncEntryCount, std::move(PGOBBEntries), FeatEnable});
916 }
917 }
918 // Either Cur is in the error state, or we have an error in ULEBSizeErr or
919 // MetadataDecodeErr (but not both), but we join all errors here to be safe.
920 if (!Cur || ULEBSizeErr || MetadataDecodeErr)
921 return joinErrors(joinErrors(Cur.takeError(), std::move(ULEBSizeErr)),
922 std::move(MetadataDecodeErr));
923 return FunctionEntries;
924 }
925
926 template <class ELFT>
927 Expected<std::vector<BBAddrMap>>
decodeBBAddrMap(const Elf_Shdr & Sec,const Elf_Shdr * RelaSec,std::vector<PGOAnalysisMap> * PGOAnalyses) const928 ELFFile<ELFT>::decodeBBAddrMap(const Elf_Shdr &Sec, const Elf_Shdr *RelaSec,
929 std::vector<PGOAnalysisMap> *PGOAnalyses) const {
930 size_t OriginalPGOSize = PGOAnalyses ? PGOAnalyses->size() : 0;
931 auto AddrMapsOrErr = decodeBBAddrMapImpl(*this, Sec, RelaSec, PGOAnalyses);
932 // remove new analyses when an error occurs
933 if (!AddrMapsOrErr && PGOAnalyses)
934 PGOAnalyses->resize(OriginalPGOSize);
935 return std::move(AddrMapsOrErr);
936 }
937
938 template <class ELFT>
939 Expected<
940 MapVector<const typename ELFT::Shdr *, const typename ELFT::Shdr *>>
getSectionAndRelocations(std::function<Expected<bool> (const Elf_Shdr &)> IsMatch) const941 ELFFile<ELFT>::getSectionAndRelocations(
942 std::function<Expected<bool>(const Elf_Shdr &)> IsMatch) const {
943 MapVector<const Elf_Shdr *, const Elf_Shdr *> SecToRelocMap;
944 Error Errors = Error::success();
945 for (const Elf_Shdr &Sec : cantFail(this->sections())) {
946 Expected<bool> DoesSectionMatch = IsMatch(Sec);
947 if (!DoesSectionMatch) {
948 Errors = joinErrors(std::move(Errors), DoesSectionMatch.takeError());
949 continue;
950 }
951 if (*DoesSectionMatch) {
952 if (SecToRelocMap.insert(std::make_pair(&Sec, (const Elf_Shdr *)nullptr))
953 .second)
954 continue;
955 }
956
957 if (Sec.sh_type != ELF::SHT_RELA && Sec.sh_type != ELF::SHT_REL)
958 continue;
959
960 Expected<const Elf_Shdr *> RelSecOrErr = this->getSection(Sec.sh_info);
961 if (!RelSecOrErr) {
962 Errors = joinErrors(std::move(Errors),
963 createError(describe(*this, Sec) +
964 ": failed to get a relocated section: " +
965 toString(RelSecOrErr.takeError())));
966 continue;
967 }
968 const Elf_Shdr *ContentsSec = *RelSecOrErr;
969 Expected<bool> DoesRelTargetMatch = IsMatch(*ContentsSec);
970 if (!DoesRelTargetMatch) {
971 Errors = joinErrors(std::move(Errors), DoesRelTargetMatch.takeError());
972 continue;
973 }
974 if (*DoesRelTargetMatch)
975 SecToRelocMap[ContentsSec] = &Sec;
976 }
977 if(Errors)
978 return std::move(Errors);
979 return SecToRelocMap;
980 }
981
982 template class llvm::object::ELFFile<ELF32LE>;
983 template class llvm::object::ELFFile<ELF32BE>;
984 template class llvm::object::ELFFile<ELF64LE>;
985 template class llvm::object::ELFFile<ELF64BE>;
986