xref: /llvm-project/llvm/lib/Object/ELFObjectFile.cpp (revision 96ebf9bc8016543e404c856cd0839d3bffbbf718)
1 //===- ELFObjectFile.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 // Part of the ELFObjectFile class implementation.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/Object/ELFObjectFile.h"
14 #include "llvm/ADT/Triple.h"
15 #include "llvm/BinaryFormat/ELF.h"
16 #include "llvm/MC/MCInstrAnalysis.h"
17 #include "llvm/MC/SubtargetFeature.h"
18 #include "llvm/MC/TargetRegistry.h"
19 #include "llvm/Object/ELF.h"
20 #include "llvm/Object/ELFTypes.h"
21 #include "llvm/Object/Error.h"
22 #include "llvm/Support/ARMAttributeParser.h"
23 #include "llvm/Support/ARMBuildAttributes.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/MathExtras.h"
26 #include "llvm/Support/RISCVAttributeParser.h"
27 #include "llvm/Support/RISCVAttributes.h"
28 #include <algorithm>
29 #include <cstddef>
30 #include <cstdint>
31 #include <memory>
32 #include <optional>
33 #include <string>
34 #include <utility>
35 
36 using namespace llvm;
37 using namespace object;
38 
39 const EnumEntry<unsigned> llvm::object::ElfSymbolTypes[NumElfSymbolTypes] = {
40     {"None", "NOTYPE", ELF::STT_NOTYPE},
41     {"Object", "OBJECT", ELF::STT_OBJECT},
42     {"Function", "FUNC", ELF::STT_FUNC},
43     {"Section", "SECTION", ELF::STT_SECTION},
44     {"File", "FILE", ELF::STT_FILE},
45     {"Common", "COMMON", ELF::STT_COMMON},
46     {"TLS", "TLS", ELF::STT_TLS},
47     {"Unknown", "<unknown>: 7", 7},
48     {"Unknown", "<unknown>: 8", 8},
49     {"Unknown", "<unknown>: 9", 9},
50     {"GNU_IFunc", "IFUNC", ELF::STT_GNU_IFUNC},
51     {"OS Specific", "<OS specific>: 11", 11},
52     {"OS Specific", "<OS specific>: 12", 12},
53     {"Proc Specific", "<processor specific>: 13", 13},
54     {"Proc Specific", "<processor specific>: 14", 14},
55     {"Proc Specific", "<processor specific>: 15", 15}
56 };
57 
58 ELFObjectFileBase::ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)
59     : ObjectFile(Type, Source) {}
60 
61 template <class ELFT>
62 static Expected<std::unique_ptr<ELFObjectFile<ELFT>>>
63 createPtr(MemoryBufferRef Object, bool InitContent) {
64   auto Ret = ELFObjectFile<ELFT>::create(Object, InitContent);
65   if (Error E = Ret.takeError())
66     return std::move(E);
67   return std::make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));
68 }
69 
70 Expected<std::unique_ptr<ObjectFile>>
71 ObjectFile::createELFObjectFile(MemoryBufferRef Obj, bool InitContent) {
72   std::pair<unsigned char, unsigned char> Ident =
73       getElfArchType(Obj.getBuffer());
74   std::size_t MaxAlignment =
75       1ULL << countTrailingZeros(
76           reinterpret_cast<uintptr_t>(Obj.getBufferStart()));
77 
78   if (MaxAlignment < 2)
79     return createError("Insufficient alignment");
80 
81   if (Ident.first == ELF::ELFCLASS32) {
82     if (Ident.second == ELF::ELFDATA2LSB)
83       return createPtr<ELF32LE>(Obj, InitContent);
84     else if (Ident.second == ELF::ELFDATA2MSB)
85       return createPtr<ELF32BE>(Obj, InitContent);
86     else
87       return createError("Invalid ELF data");
88   } else if (Ident.first == ELF::ELFCLASS64) {
89     if (Ident.second == ELF::ELFDATA2LSB)
90       return createPtr<ELF64LE>(Obj, InitContent);
91     else if (Ident.second == ELF::ELFDATA2MSB)
92       return createPtr<ELF64BE>(Obj, InitContent);
93     else
94       return createError("Invalid ELF data");
95   }
96   return createError("Invalid ELF class");
97 }
98 
99 SubtargetFeatures ELFObjectFileBase::getMIPSFeatures() const {
100   SubtargetFeatures Features;
101   unsigned PlatformFlags = getPlatformFlags();
102 
103   switch (PlatformFlags & ELF::EF_MIPS_ARCH) {
104   case ELF::EF_MIPS_ARCH_1:
105     break;
106   case ELF::EF_MIPS_ARCH_2:
107     Features.AddFeature("mips2");
108     break;
109   case ELF::EF_MIPS_ARCH_3:
110     Features.AddFeature("mips3");
111     break;
112   case ELF::EF_MIPS_ARCH_4:
113     Features.AddFeature("mips4");
114     break;
115   case ELF::EF_MIPS_ARCH_5:
116     Features.AddFeature("mips5");
117     break;
118   case ELF::EF_MIPS_ARCH_32:
119     Features.AddFeature("mips32");
120     break;
121   case ELF::EF_MIPS_ARCH_64:
122     Features.AddFeature("mips64");
123     break;
124   case ELF::EF_MIPS_ARCH_32R2:
125     Features.AddFeature("mips32r2");
126     break;
127   case ELF::EF_MIPS_ARCH_64R2:
128     Features.AddFeature("mips64r2");
129     break;
130   case ELF::EF_MIPS_ARCH_32R6:
131     Features.AddFeature("mips32r6");
132     break;
133   case ELF::EF_MIPS_ARCH_64R6:
134     Features.AddFeature("mips64r6");
135     break;
136   default:
137     llvm_unreachable("Unknown EF_MIPS_ARCH value");
138   }
139 
140   switch (PlatformFlags & ELF::EF_MIPS_MACH) {
141   case ELF::EF_MIPS_MACH_NONE:
142     // No feature associated with this value.
143     break;
144   case ELF::EF_MIPS_MACH_OCTEON:
145     Features.AddFeature("cnmips");
146     break;
147   default:
148     llvm_unreachable("Unknown EF_MIPS_ARCH value");
149   }
150 
151   if (PlatformFlags & ELF::EF_MIPS_ARCH_ASE_M16)
152     Features.AddFeature("mips16");
153   if (PlatformFlags & ELF::EF_MIPS_MICROMIPS)
154     Features.AddFeature("micromips");
155 
156   return Features;
157 }
158 
159 SubtargetFeatures ELFObjectFileBase::getARMFeatures() const {
160   SubtargetFeatures Features;
161   ARMAttributeParser Attributes;
162   if (Error E = getBuildAttributes(Attributes)) {
163     consumeError(std::move(E));
164     return SubtargetFeatures();
165   }
166 
167   // both ARMv7-M and R have to support thumb hardware div
168   bool isV7 = false;
169   Optional<unsigned> Attr =
170       Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
171   if (Attr)
172     isV7 = Attr.value() == ARMBuildAttrs::v7;
173 
174   Attr = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile);
175   if (Attr) {
176     switch (Attr.value()) {
177     case ARMBuildAttrs::ApplicationProfile:
178       Features.AddFeature("aclass");
179       break;
180     case ARMBuildAttrs::RealTimeProfile:
181       Features.AddFeature("rclass");
182       if (isV7)
183         Features.AddFeature("hwdiv");
184       break;
185     case ARMBuildAttrs::MicroControllerProfile:
186       Features.AddFeature("mclass");
187       if (isV7)
188         Features.AddFeature("hwdiv");
189       break;
190     }
191   }
192 
193   Attr = Attributes.getAttributeValue(ARMBuildAttrs::THUMB_ISA_use);
194   if (Attr) {
195     switch (Attr.value()) {
196     default:
197       break;
198     case ARMBuildAttrs::Not_Allowed:
199       Features.AddFeature("thumb", false);
200       Features.AddFeature("thumb2", false);
201       break;
202     case ARMBuildAttrs::AllowThumb32:
203       Features.AddFeature("thumb2");
204       break;
205     }
206   }
207 
208   Attr = Attributes.getAttributeValue(ARMBuildAttrs::FP_arch);
209   if (Attr) {
210     switch (Attr.value()) {
211     default:
212       break;
213     case ARMBuildAttrs::Not_Allowed:
214       Features.AddFeature("vfp2sp", false);
215       Features.AddFeature("vfp3d16sp", false);
216       Features.AddFeature("vfp4d16sp", false);
217       break;
218     case ARMBuildAttrs::AllowFPv2:
219       Features.AddFeature("vfp2");
220       break;
221     case ARMBuildAttrs::AllowFPv3A:
222     case ARMBuildAttrs::AllowFPv3B:
223       Features.AddFeature("vfp3");
224       break;
225     case ARMBuildAttrs::AllowFPv4A:
226     case ARMBuildAttrs::AllowFPv4B:
227       Features.AddFeature("vfp4");
228       break;
229     }
230   }
231 
232   Attr = Attributes.getAttributeValue(ARMBuildAttrs::Advanced_SIMD_arch);
233   if (Attr) {
234     switch (Attr.value()) {
235     default:
236       break;
237     case ARMBuildAttrs::Not_Allowed:
238       Features.AddFeature("neon", false);
239       Features.AddFeature("fp16", false);
240       break;
241     case ARMBuildAttrs::AllowNeon:
242       Features.AddFeature("neon");
243       break;
244     case ARMBuildAttrs::AllowNeon2:
245       Features.AddFeature("neon");
246       Features.AddFeature("fp16");
247       break;
248     }
249   }
250 
251   Attr = Attributes.getAttributeValue(ARMBuildAttrs::MVE_arch);
252   if (Attr) {
253     switch (Attr.value()) {
254     default:
255       break;
256     case ARMBuildAttrs::Not_Allowed:
257       Features.AddFeature("mve", false);
258       Features.AddFeature("mve.fp", false);
259       break;
260     case ARMBuildAttrs::AllowMVEInteger:
261       Features.AddFeature("mve.fp", false);
262       Features.AddFeature("mve");
263       break;
264     case ARMBuildAttrs::AllowMVEIntegerAndFloat:
265       Features.AddFeature("mve.fp");
266       break;
267     }
268   }
269 
270   Attr = Attributes.getAttributeValue(ARMBuildAttrs::DIV_use);
271   if (Attr) {
272     switch (Attr.value()) {
273     default:
274       break;
275     case ARMBuildAttrs::DisallowDIV:
276       Features.AddFeature("hwdiv", false);
277       Features.AddFeature("hwdiv-arm", false);
278       break;
279     case ARMBuildAttrs::AllowDIVExt:
280       Features.AddFeature("hwdiv");
281       Features.AddFeature("hwdiv-arm");
282       break;
283     }
284   }
285 
286   return Features;
287 }
288 
289 SubtargetFeatures ELFObjectFileBase::getRISCVFeatures() const {
290   SubtargetFeatures Features;
291   unsigned PlatformFlags = getPlatformFlags();
292 
293   if (PlatformFlags & ELF::EF_RISCV_RVC) {
294     Features.AddFeature("c");
295   }
296 
297   // Add features according to the ELF attribute section.
298   // If there are any unrecognized features, ignore them.
299   RISCVAttributeParser Attributes;
300   if (Error E = getBuildAttributes(Attributes)) {
301     // TODO Propagate Error.
302     consumeError(std::move(E));
303     return Features; // Keep "c" feature if there is one in PlatformFlags.
304   }
305 
306   Optional<StringRef> Attr = Attributes.getAttributeString(RISCVAttrs::ARCH);
307   if (Attr) {
308     // The Arch pattern is [rv32|rv64][i|e]version(_[m|a|f|d|c]version)*
309     // Version string pattern is (major)p(minor). Major and minor are optional.
310     // For example, a version number could be 2p0, 2, or p92.
311     StringRef Arch = *Attr;
312     if (Arch.consume_front("rv32"))
313       Features.AddFeature("64bit", false);
314     else if (Arch.consume_front("rv64"))
315       Features.AddFeature("64bit");
316 
317     while (!Arch.empty()) {
318       switch (Arch[0]) {
319       default:
320         break; // Ignore unexpected features.
321       case 'i':
322         Features.AddFeature("e", false);
323         break;
324       case 'd':
325         Features.AddFeature("f"); // D-ext will imply F-ext.
326         [[fallthrough]];
327       case 'e':
328       case 'm':
329       case 'a':
330       case 'f':
331       case 'c':
332         Features.AddFeature(Arch.take_front());
333         break;
334       }
335 
336       // FIXME: Handle version numbers.
337       Arch = Arch.drop_until([](char c) { return c == '_' || c == '\0'; });
338       Arch = Arch.drop_while([](char c) { return c == '_'; });
339     }
340   }
341 
342   return Features;
343 }
344 
345 SubtargetFeatures ELFObjectFileBase::getFeatures() const {
346   switch (getEMachine()) {
347   case ELF::EM_MIPS:
348     return getMIPSFeatures();
349   case ELF::EM_ARM:
350     return getARMFeatures();
351   case ELF::EM_RISCV:
352     return getRISCVFeatures();
353   default:
354     return SubtargetFeatures();
355   }
356 }
357 
358 Optional<StringRef> ELFObjectFileBase::tryGetCPUName() const {
359   switch (getEMachine()) {
360   case ELF::EM_AMDGPU:
361     return getAMDGPUCPUName();
362   case ELF::EM_PPC64:
363     return StringRef("future");
364   default:
365     return None;
366   }
367 }
368 
369 StringRef ELFObjectFileBase::getAMDGPUCPUName() const {
370   assert(getEMachine() == ELF::EM_AMDGPU);
371   unsigned CPU = getPlatformFlags() & ELF::EF_AMDGPU_MACH;
372 
373   switch (CPU) {
374   // Radeon HD 2000/3000 Series (R600).
375   case ELF::EF_AMDGPU_MACH_R600_R600:
376     return "r600";
377   case ELF::EF_AMDGPU_MACH_R600_R630:
378     return "r630";
379   case ELF::EF_AMDGPU_MACH_R600_RS880:
380     return "rs880";
381   case ELF::EF_AMDGPU_MACH_R600_RV670:
382     return "rv670";
383 
384   // Radeon HD 4000 Series (R700).
385   case ELF::EF_AMDGPU_MACH_R600_RV710:
386     return "rv710";
387   case ELF::EF_AMDGPU_MACH_R600_RV730:
388     return "rv730";
389   case ELF::EF_AMDGPU_MACH_R600_RV770:
390     return "rv770";
391 
392   // Radeon HD 5000 Series (Evergreen).
393   case ELF::EF_AMDGPU_MACH_R600_CEDAR:
394     return "cedar";
395   case ELF::EF_AMDGPU_MACH_R600_CYPRESS:
396     return "cypress";
397   case ELF::EF_AMDGPU_MACH_R600_JUNIPER:
398     return "juniper";
399   case ELF::EF_AMDGPU_MACH_R600_REDWOOD:
400     return "redwood";
401   case ELF::EF_AMDGPU_MACH_R600_SUMO:
402     return "sumo";
403 
404   // Radeon HD 6000 Series (Northern Islands).
405   case ELF::EF_AMDGPU_MACH_R600_BARTS:
406     return "barts";
407   case ELF::EF_AMDGPU_MACH_R600_CAICOS:
408     return "caicos";
409   case ELF::EF_AMDGPU_MACH_R600_CAYMAN:
410     return "cayman";
411   case ELF::EF_AMDGPU_MACH_R600_TURKS:
412     return "turks";
413 
414   // AMDGCN GFX6.
415   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX600:
416     return "gfx600";
417   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX601:
418     return "gfx601";
419   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX602:
420     return "gfx602";
421 
422   // AMDGCN GFX7.
423   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX700:
424     return "gfx700";
425   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX701:
426     return "gfx701";
427   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX702:
428     return "gfx702";
429   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX703:
430     return "gfx703";
431   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX704:
432     return "gfx704";
433   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX705:
434     return "gfx705";
435 
436   // AMDGCN GFX8.
437   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX801:
438     return "gfx801";
439   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX802:
440     return "gfx802";
441   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX803:
442     return "gfx803";
443   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX805:
444     return "gfx805";
445   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX810:
446     return "gfx810";
447 
448   // AMDGCN GFX9.
449   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX900:
450     return "gfx900";
451   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX902:
452     return "gfx902";
453   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX904:
454     return "gfx904";
455   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX906:
456     return "gfx906";
457   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX908:
458     return "gfx908";
459   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX909:
460     return "gfx909";
461   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX90A:
462     return "gfx90a";
463   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX90C:
464     return "gfx90c";
465   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX940:
466     return "gfx940";
467 
468   // AMDGCN GFX10.
469   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1010:
470     return "gfx1010";
471   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1011:
472     return "gfx1011";
473   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1012:
474     return "gfx1012";
475   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1013:
476     return "gfx1013";
477   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1030:
478     return "gfx1030";
479   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1031:
480     return "gfx1031";
481   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1032:
482     return "gfx1032";
483   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1033:
484     return "gfx1033";
485   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1034:
486     return "gfx1034";
487   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1035:
488     return "gfx1035";
489   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1036:
490     return "gfx1036";
491 
492   // AMDGCN GFX11.
493   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1100:
494     return "gfx1100";
495   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1101:
496     return "gfx1101";
497   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1102:
498     return "gfx1102";
499   case ELF::EF_AMDGPU_MACH_AMDGCN_GFX1103:
500     return "gfx1103";
501   default:
502     llvm_unreachable("Unknown EF_AMDGPU_MACH value");
503   }
504 }
505 
506 // FIXME Encode from a tablegen description or target parser.
507 void ELFObjectFileBase::setARMSubArch(Triple &TheTriple) const {
508   if (TheTriple.getSubArch() != Triple::NoSubArch)
509     return;
510 
511   ARMAttributeParser Attributes;
512   if (Error E = getBuildAttributes(Attributes)) {
513     // TODO Propagate Error.
514     consumeError(std::move(E));
515     return;
516   }
517 
518   std::string Triple;
519   // Default to ARM, but use the triple if it's been set.
520   if (TheTriple.isThumb())
521     Triple = "thumb";
522   else
523     Triple = "arm";
524 
525   Optional<unsigned> Attr =
526       Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch);
527   if (Attr) {
528     switch (Attr.value()) {
529     case ARMBuildAttrs::v4:
530       Triple += "v4";
531       break;
532     case ARMBuildAttrs::v4T:
533       Triple += "v4t";
534       break;
535     case ARMBuildAttrs::v5T:
536       Triple += "v5t";
537       break;
538     case ARMBuildAttrs::v5TE:
539       Triple += "v5te";
540       break;
541     case ARMBuildAttrs::v5TEJ:
542       Triple += "v5tej";
543       break;
544     case ARMBuildAttrs::v6:
545       Triple += "v6";
546       break;
547     case ARMBuildAttrs::v6KZ:
548       Triple += "v6kz";
549       break;
550     case ARMBuildAttrs::v6T2:
551       Triple += "v6t2";
552       break;
553     case ARMBuildAttrs::v6K:
554       Triple += "v6k";
555       break;
556     case ARMBuildAttrs::v7: {
557       Optional<unsigned> ArchProfileAttr =
558           Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile);
559       if (ArchProfileAttr &&
560           ArchProfileAttr.value() == ARMBuildAttrs::MicroControllerProfile)
561         Triple += "v7m";
562       else
563         Triple += "v7";
564       break;
565     }
566     case ARMBuildAttrs::v6_M:
567       Triple += "v6m";
568       break;
569     case ARMBuildAttrs::v6S_M:
570       Triple += "v6sm";
571       break;
572     case ARMBuildAttrs::v7E_M:
573       Triple += "v7em";
574       break;
575     case ARMBuildAttrs::v8_A:
576       Triple += "v8a";
577       break;
578     case ARMBuildAttrs::v8_R:
579       Triple += "v8r";
580       break;
581     case ARMBuildAttrs::v8_M_Base:
582       Triple += "v8m.base";
583       break;
584     case ARMBuildAttrs::v8_M_Main:
585       Triple += "v8m.main";
586       break;
587     case ARMBuildAttrs::v8_1_M_Main:
588       Triple += "v8.1m.main";
589       break;
590     case ARMBuildAttrs::v9_A:
591       Triple += "v9a";
592       break;
593     }
594   }
595   if (!isLittleEndian())
596     Triple += "eb";
597 
598   TheTriple.setArchName(Triple);
599 }
600 
601 std::vector<std::pair<Optional<DataRefImpl>, uint64_t>>
602 ELFObjectFileBase::getPltAddresses() const {
603   std::string Err;
604   const auto Triple = makeTriple();
605   const auto *T = TargetRegistry::lookupTarget(Triple.str(), Err);
606   if (!T)
607     return {};
608   uint64_t JumpSlotReloc = 0;
609   switch (Triple.getArch()) {
610     case Triple::x86:
611       JumpSlotReloc = ELF::R_386_JUMP_SLOT;
612       break;
613     case Triple::x86_64:
614       JumpSlotReloc = ELF::R_X86_64_JUMP_SLOT;
615       break;
616     case Triple::aarch64:
617     case Triple::aarch64_be:
618       JumpSlotReloc = ELF::R_AARCH64_JUMP_SLOT;
619       break;
620     default:
621       return {};
622   }
623   std::unique_ptr<const MCInstrInfo> MII(T->createMCInstrInfo());
624   std::unique_ptr<const MCInstrAnalysis> MIA(
625       T->createMCInstrAnalysis(MII.get()));
626   if (!MIA)
627     return {};
628   std::optional<SectionRef> Plt, RelaPlt, GotPlt;
629   for (const SectionRef &Section : sections()) {
630     Expected<StringRef> NameOrErr = Section.getName();
631     if (!NameOrErr) {
632       consumeError(NameOrErr.takeError());
633       continue;
634     }
635     StringRef Name = *NameOrErr;
636 
637     if (Name == ".plt")
638       Plt = Section;
639     else if (Name == ".rela.plt" || Name == ".rel.plt")
640       RelaPlt = Section;
641     else if (Name == ".got.plt")
642       GotPlt = Section;
643   }
644   if (!Plt || !RelaPlt || !GotPlt)
645     return {};
646   Expected<StringRef> PltContents = Plt->getContents();
647   if (!PltContents) {
648     consumeError(PltContents.takeError());
649     return {};
650   }
651   auto PltEntries = MIA->findPltEntries(Plt->getAddress(),
652                                         arrayRefFromStringRef(*PltContents),
653                                         GotPlt->getAddress(), Triple);
654   // Build a map from GOT entry virtual address to PLT entry virtual address.
655   DenseMap<uint64_t, uint64_t> GotToPlt;
656   for (const auto &Entry : PltEntries)
657     GotToPlt.insert(std::make_pair(Entry.second, Entry.first));
658   // Find the relocations in the dynamic relocation table that point to
659   // locations in the GOT for which we know the corresponding PLT entry.
660   std::vector<std::pair<Optional<DataRefImpl>, uint64_t>> Result;
661   for (const auto &Relocation : RelaPlt->relocations()) {
662     if (Relocation.getType() != JumpSlotReloc)
663       continue;
664     auto PltEntryIter = GotToPlt.find(Relocation.getOffset());
665     if (PltEntryIter != GotToPlt.end()) {
666       symbol_iterator Sym = Relocation.getSymbol();
667       if (Sym == symbol_end())
668         Result.emplace_back(None, PltEntryIter->second);
669       else
670         Result.emplace_back(Sym->getRawDataRefImpl(), PltEntryIter->second);
671     }
672   }
673   return Result;
674 }
675 
676 template <class ELFT>
677 Expected<std::vector<BBAddrMap>> static readBBAddrMapImpl(
678     const ELFFile<ELFT> &EF, Optional<unsigned> TextSectionIndex) {
679   using Elf_Shdr = typename ELFT::Shdr;
680   std::vector<BBAddrMap> BBAddrMaps;
681   const auto &Sections = cantFail(EF.sections());
682   for (const Elf_Shdr &Sec : Sections) {
683     if (Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP &&
684         Sec.sh_type != ELF::SHT_LLVM_BB_ADDR_MAP_V0)
685       continue;
686     if (TextSectionIndex) {
687       Expected<const Elf_Shdr *> TextSecOrErr = EF.getSection(Sec.sh_link);
688       if (!TextSecOrErr)
689         return createError("unable to get the linked-to section for " +
690                            describe(EF, Sec) + ": " +
691                            toString(TextSecOrErr.takeError()));
692       if (*TextSectionIndex != std::distance(Sections.begin(), *TextSecOrErr))
693         continue;
694     }
695     Expected<std::vector<BBAddrMap>> BBAddrMapOrErr = EF.decodeBBAddrMap(Sec);
696     if (!BBAddrMapOrErr)
697       return createError("unable to read " + describe(EF, Sec) + ": " +
698                          toString(BBAddrMapOrErr.takeError()));
699     std::move(BBAddrMapOrErr->begin(), BBAddrMapOrErr->end(),
700               std::back_inserter(BBAddrMaps));
701   }
702   return BBAddrMaps;
703 }
704 
705 template <class ELFT>
706 static Expected<std::vector<VersionEntry>>
707 readDynsymVersionsImpl(const ELFFile<ELFT> &EF,
708                        ELFObjectFileBase::elf_symbol_iterator_range Symbols) {
709   using Elf_Shdr = typename ELFT::Shdr;
710   const Elf_Shdr *VerSec = nullptr;
711   const Elf_Shdr *VerNeedSec = nullptr;
712   const Elf_Shdr *VerDefSec = nullptr;
713   // The user should ensure sections() can't fail here.
714   for (const Elf_Shdr &Sec : cantFail(EF.sections())) {
715     if (Sec.sh_type == ELF::SHT_GNU_versym)
716       VerSec = &Sec;
717     else if (Sec.sh_type == ELF::SHT_GNU_verdef)
718       VerDefSec = &Sec;
719     else if (Sec.sh_type == ELF::SHT_GNU_verneed)
720       VerNeedSec = &Sec;
721   }
722   if (!VerSec)
723     return std::vector<VersionEntry>();
724 
725   Expected<SmallVector<Optional<VersionEntry>, 0>> MapOrErr =
726       EF.loadVersionMap(VerNeedSec, VerDefSec);
727   if (!MapOrErr)
728     return MapOrErr.takeError();
729 
730   std::vector<VersionEntry> Ret;
731   size_t I = 0;
732   for (const ELFSymbolRef &Sym : Symbols) {
733     ++I;
734     Expected<const typename ELFT::Versym *> VerEntryOrErr =
735         EF.template getEntry<typename ELFT::Versym>(*VerSec, I);
736     if (!VerEntryOrErr)
737       return createError("unable to read an entry with index " + Twine(I) +
738                          " from " + describe(EF, *VerSec) + ": " +
739                          toString(VerEntryOrErr.takeError()));
740 
741     Expected<uint32_t> FlagsOrErr = Sym.getFlags();
742     if (!FlagsOrErr)
743       return createError("unable to read flags for symbol with index " +
744                          Twine(I) + ": " + toString(FlagsOrErr.takeError()));
745 
746     bool IsDefault;
747     Expected<StringRef> VerOrErr = EF.getSymbolVersionByIndex(
748         (*VerEntryOrErr)->vs_index, IsDefault, *MapOrErr,
749         (*FlagsOrErr) & SymbolRef::SF_Undefined);
750     if (!VerOrErr)
751       return createError("unable to get a version for entry " + Twine(I) +
752                          " of " + describe(EF, *VerSec) + ": " +
753                          toString(VerOrErr.takeError()));
754 
755     Ret.push_back({(*VerOrErr).str(), IsDefault});
756   }
757 
758   return Ret;
759 }
760 
761 Expected<std::vector<VersionEntry>>
762 ELFObjectFileBase::readDynsymVersions() const {
763   elf_symbol_iterator_range Symbols = getDynamicSymbolIterators();
764   if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
765     return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
766   if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
767     return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
768   if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
769     return readDynsymVersionsImpl(Obj->getELFFile(), Symbols);
770   return readDynsymVersionsImpl(cast<ELF64BEObjectFile>(this)->getELFFile(),
771                                 Symbols);
772 }
773 
774 Expected<std::vector<BBAddrMap>>
775 ELFObjectFileBase::readBBAddrMap(Optional<unsigned> TextSectionIndex) const {
776   if (const auto *Obj = dyn_cast<ELF32LEObjectFile>(this))
777     return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
778   if (const auto *Obj = dyn_cast<ELF64LEObjectFile>(this))
779     return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
780   if (const auto *Obj = dyn_cast<ELF32BEObjectFile>(this))
781     return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
782   if (const auto *Obj = cast<ELF64BEObjectFile>(this))
783     return readBBAddrMapImpl(Obj->getELFFile(), TextSectionIndex);
784   else
785     llvm_unreachable("Unsupported binary format");
786 }
787