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