1 //===- RelocationResolver.cpp ------------------------------------*- C++ -*-===//
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 // This file defines utilities to resolve relocations in object files.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm/Object/RelocationResolver.h"
14 #include "llvm/ADT/Twine.h"
15 #include "llvm/BinaryFormat/COFF.h"
16 #include "llvm/BinaryFormat/ELF.h"
17 #include "llvm/BinaryFormat/MachO.h"
18 #include "llvm/BinaryFormat/Wasm.h"
19 #include "llvm/Object/ELFObjectFile.h"
20 #include "llvm/Object/ELFTypes.h"
21 #include "llvm/Object/ObjectFile.h"
22 #include "llvm/Object/SymbolicFile.h"
23 #include "llvm/Support/Casting.h"
24 #include "llvm/Support/Error.h"
25 #include "llvm/Support/ErrorHandling.h"
26 #include "llvm/TargetParser/Triple.h"
27 #include <cassert>
28 #include <vector>
29 
30 namespace llvm {
31 namespace object {
32 
33 static int64_t getELFAddend(RelocationRef R) {
34   Expected<int64_t> AddendOrErr = ELFRelocationRef(R).getAddend();
35   handleAllErrors(AddendOrErr.takeError(), [](const ErrorInfoBase &EI) {
36     report_fatal_error(Twine(EI.message()));
37   });
38   return *AddendOrErr;
39 }
40 
41 static bool supportsX86_64(uint64_t Type) {
42   switch (Type) {
43   case ELF::R_X86_64_NONE:
44   case ELF::R_X86_64_64:
45   case ELF::R_X86_64_DTPOFF32:
46   case ELF::R_X86_64_DTPOFF64:
47   case ELF::R_X86_64_PC32:
48   case ELF::R_X86_64_PC64:
49   case ELF::R_X86_64_32:
50   case ELF::R_X86_64_32S:
51     return true;
52   default:
53     return false;
54   }
55 }
56 
57 static uint64_t resolveX86_64(uint64_t Type, uint64_t Offset, uint64_t S,
58                               uint64_t LocData, int64_t Addend) {
59   switch (Type) {
60   case ELF::R_X86_64_NONE:
61     return LocData;
62   case ELF::R_X86_64_64:
63   case ELF::R_X86_64_DTPOFF32:
64   case ELF::R_X86_64_DTPOFF64:
65     return S + Addend;
66   case ELF::R_X86_64_PC32:
67   case ELF::R_X86_64_PC64:
68     return S + Addend - Offset;
69   case ELF::R_X86_64_32:
70   case ELF::R_X86_64_32S:
71     return (S + Addend) & 0xFFFFFFFF;
72   default:
73     llvm_unreachable("Invalid relocation type");
74   }
75 }
76 
77 static bool supportsAArch64(uint64_t Type) {
78   switch (Type) {
79   case ELF::R_AARCH64_ABS32:
80   case ELF::R_AARCH64_ABS64:
81   case ELF::R_AARCH64_PREL16:
82   case ELF::R_AARCH64_PREL32:
83   case ELF::R_AARCH64_PREL64:
84     return true;
85   default:
86     return false;
87   }
88 }
89 
90 static uint64_t resolveAArch64(uint64_t Type, uint64_t Offset, uint64_t S,
91                                uint64_t /*LocData*/, int64_t Addend) {
92   switch (Type) {
93   case ELF::R_AARCH64_ABS32:
94     return (S + Addend) & 0xFFFFFFFF;
95   case ELF::R_AARCH64_ABS64:
96     return S + Addend;
97   case ELF::R_AARCH64_PREL16:
98     return (S + Addend - Offset) & 0xFFFF;
99   case ELF::R_AARCH64_PREL32:
100     return (S + Addend - Offset) & 0xFFFFFFFF;
101   case ELF::R_AARCH64_PREL64:
102     return S + Addend - Offset;
103   default:
104     llvm_unreachable("Invalid relocation type");
105   }
106 }
107 
108 static bool supportsBPF(uint64_t Type) {
109   switch (Type) {
110   case ELF::R_BPF_64_ABS32:
111   case ELF::R_BPF_64_ABS64:
112     return true;
113   default:
114     return false;
115   }
116 }
117 
118 static uint64_t resolveBPF(uint64_t Type, uint64_t Offset, uint64_t S,
119                            uint64_t LocData, int64_t /*Addend*/) {
120   switch (Type) {
121   case ELF::R_BPF_64_ABS32:
122     return (S + LocData) & 0xFFFFFFFF;
123   case ELF::R_BPF_64_ABS64:
124     return S + LocData;
125   default:
126     llvm_unreachable("Invalid relocation type");
127   }
128 }
129 
130 static bool supportsMips64(uint64_t Type) {
131   switch (Type) {
132   case ELF::R_MIPS_32:
133   case ELF::R_MIPS_64:
134   case ELF::R_MIPS_TLS_DTPREL64:
135   case ELF::R_MIPS_PC32:
136     return true;
137   default:
138     return false;
139   }
140 }
141 
142 static uint64_t resolveMips64(uint64_t Type, uint64_t Offset, uint64_t S,
143                               uint64_t /*LocData*/, int64_t Addend) {
144   switch (Type) {
145   case ELF::R_MIPS_32:
146     return (S + Addend) & 0xFFFFFFFF;
147   case ELF::R_MIPS_64:
148     return S + Addend;
149   case ELF::R_MIPS_TLS_DTPREL64:
150     return S + Addend - 0x8000;
151   case ELF::R_MIPS_PC32:
152     return S + Addend - Offset;
153   default:
154     llvm_unreachable("Invalid relocation type");
155   }
156 }
157 
158 static bool supportsMSP430(uint64_t Type) {
159   switch (Type) {
160   case ELF::R_MSP430_32:
161   case ELF::R_MSP430_16_BYTE:
162     return true;
163   default:
164     return false;
165   }
166 }
167 
168 static uint64_t resolveMSP430(uint64_t Type, uint64_t Offset, uint64_t S,
169                               uint64_t /*LocData*/, int64_t Addend) {
170   switch (Type) {
171   case ELF::R_MSP430_32:
172     return (S + Addend) & 0xFFFFFFFF;
173   case ELF::R_MSP430_16_BYTE:
174     return (S + Addend) & 0xFFFF;
175   default:
176     llvm_unreachable("Invalid relocation type");
177   }
178 }
179 
180 static bool supportsPPC64(uint64_t Type) {
181   switch (Type) {
182   case ELF::R_PPC64_ADDR32:
183   case ELF::R_PPC64_ADDR64:
184   case ELF::R_PPC64_REL32:
185   case ELF::R_PPC64_REL64:
186     return true;
187   default:
188     return false;
189   }
190 }
191 
192 static uint64_t resolvePPC64(uint64_t Type, uint64_t Offset, uint64_t S,
193                              uint64_t /*LocData*/, int64_t Addend) {
194   switch (Type) {
195   case ELF::R_PPC64_ADDR32:
196     return (S + Addend) & 0xFFFFFFFF;
197   case ELF::R_PPC64_ADDR64:
198     return S + Addend;
199   case ELF::R_PPC64_REL32:
200     return (S + Addend - Offset) & 0xFFFFFFFF;
201   case ELF::R_PPC64_REL64:
202     return S + Addend - Offset;
203   default:
204     llvm_unreachable("Invalid relocation type");
205   }
206 }
207 
208 static bool supportsSystemZ(uint64_t Type) {
209   switch (Type) {
210   case ELF::R_390_32:
211   case ELF::R_390_64:
212     return true;
213   default:
214     return false;
215   }
216 }
217 
218 static uint64_t resolveSystemZ(uint64_t Type, uint64_t Offset, uint64_t S,
219                                uint64_t /*LocData*/, int64_t Addend) {
220   switch (Type) {
221   case ELF::R_390_32:
222     return (S + Addend) & 0xFFFFFFFF;
223   case ELF::R_390_64:
224     return S + Addend;
225   default:
226     llvm_unreachable("Invalid relocation type");
227   }
228 }
229 
230 static bool supportsSparc64(uint64_t Type) {
231   switch (Type) {
232   case ELF::R_SPARC_32:
233   case ELF::R_SPARC_64:
234   case ELF::R_SPARC_UA32:
235   case ELF::R_SPARC_UA64:
236     return true;
237   default:
238     return false;
239   }
240 }
241 
242 static uint64_t resolveSparc64(uint64_t Type, uint64_t Offset, uint64_t S,
243                                uint64_t /*LocData*/, int64_t Addend) {
244   switch (Type) {
245   case ELF::R_SPARC_32:
246   case ELF::R_SPARC_64:
247   case ELF::R_SPARC_UA32:
248   case ELF::R_SPARC_UA64:
249     return S + Addend;
250   default:
251     llvm_unreachable("Invalid relocation type");
252   }
253 }
254 
255 /// Returns true if \c Obj is an AMDGPU code object based solely on the value
256 /// of e_machine.
257 ///
258 /// AMDGPU code objects with an e_machine of EF_AMDGPU_MACH_NONE do not
259 /// identify their arch as either r600 or amdgcn, but we can still handle
260 /// their relocations. When we identify an ELF object with an UnknownArch,
261 /// we use isAMDGPU to check for this case.
262 static bool isAMDGPU(const ObjectFile &Obj) {
263   if (const auto *ELFObj = dyn_cast<ELFObjectFileBase>(&Obj))
264     return ELFObj->getEMachine() == ELF::EM_AMDGPU;
265   return false;
266 }
267 
268 static bool supportsAmdgpu(uint64_t Type) {
269   switch (Type) {
270   case ELF::R_AMDGPU_ABS32:
271   case ELF::R_AMDGPU_ABS64:
272     return true;
273   default:
274     return false;
275   }
276 }
277 
278 static uint64_t resolveAmdgpu(uint64_t Type, uint64_t Offset, uint64_t S,
279                               uint64_t /*LocData*/, int64_t Addend) {
280   switch (Type) {
281   case ELF::R_AMDGPU_ABS32:
282   case ELF::R_AMDGPU_ABS64:
283     return S + Addend;
284   default:
285     llvm_unreachable("Invalid relocation type");
286   }
287 }
288 
289 static bool supportsX86(uint64_t Type) {
290   switch (Type) {
291   case ELF::R_386_NONE:
292   case ELF::R_386_32:
293   case ELF::R_386_PC32:
294     return true;
295   default:
296     return false;
297   }
298 }
299 
300 static uint64_t resolveX86(uint64_t Type, uint64_t Offset, uint64_t S,
301                            uint64_t LocData, int64_t /*Addend*/) {
302   switch (Type) {
303   case ELF::R_386_NONE:
304     return LocData;
305   case ELF::R_386_32:
306     return S + LocData;
307   case ELF::R_386_PC32:
308     return S - Offset + LocData;
309   default:
310     llvm_unreachable("Invalid relocation type");
311   }
312 }
313 
314 static bool supportsPPC32(uint64_t Type) {
315   switch (Type) {
316   case ELF::R_PPC_ADDR32:
317   case ELF::R_PPC_REL32:
318     return true;
319   default:
320     return false;
321   }
322 }
323 
324 static uint64_t resolvePPC32(uint64_t Type, uint64_t Offset, uint64_t S,
325                              uint64_t /*LocData*/, int64_t Addend) {
326   switch (Type) {
327   case ELF::R_PPC_ADDR32:
328     return (S + Addend) & 0xFFFFFFFF;
329   case ELF::R_PPC_REL32:
330     return (S + Addend - Offset) & 0xFFFFFFFF;
331   }
332   llvm_unreachable("Invalid relocation type");
333 }
334 
335 static bool supportsARM(uint64_t Type) {
336   switch (Type) {
337   case ELF::R_ARM_ABS32:
338   case ELF::R_ARM_REL32:
339     return true;
340   default:
341     return false;
342   }
343 }
344 
345 static uint64_t resolveARM(uint64_t Type, uint64_t Offset, uint64_t S,
346                            uint64_t LocData, int64_t Addend) {
347   // Support both RELA and REL relocations. The caller is responsible
348   // for supplying the correct values for LocData and Addend, i.e.
349   // Addend == 0 for REL and LocData == 0 for RELA.
350   assert((LocData == 0 || Addend == 0) &&
351          "one of LocData and Addend must be 0");
352   switch (Type) {
353   case ELF::R_ARM_ABS32:
354     return (S + LocData + Addend) & 0xFFFFFFFF;
355   case ELF::R_ARM_REL32:
356     return (S + LocData + Addend - Offset) & 0xFFFFFFFF;
357   }
358   llvm_unreachable("Invalid relocation type");
359 }
360 
361 static bool supportsAVR(uint64_t Type) {
362   switch (Type) {
363   case ELF::R_AVR_16:
364   case ELF::R_AVR_32:
365     return true;
366   default:
367     return false;
368   }
369 }
370 
371 static uint64_t resolveAVR(uint64_t Type, uint64_t Offset, uint64_t S,
372                            uint64_t /*LocData*/, int64_t Addend) {
373   switch (Type) {
374   case ELF::R_AVR_16:
375     return (S + Addend) & 0xFFFF;
376   case ELF::R_AVR_32:
377     return (S + Addend) & 0xFFFFFFFF;
378   default:
379     llvm_unreachable("Invalid relocation type");
380   }
381 }
382 
383 static bool supportsLanai(uint64_t Type) {
384   return Type == ELF::R_LANAI_32;
385 }
386 
387 static uint64_t resolveLanai(uint64_t Type, uint64_t Offset, uint64_t S,
388                              uint64_t /*LocData*/, int64_t Addend) {
389   if (Type == ELF::R_LANAI_32)
390     return (S + Addend) & 0xFFFFFFFF;
391   llvm_unreachable("Invalid relocation type");
392 }
393 
394 static bool supportsMips32(uint64_t Type) {
395   switch (Type) {
396   case ELF::R_MIPS_32:
397   case ELF::R_MIPS_TLS_DTPREL32:
398     return true;
399   default:
400     return false;
401   }
402 }
403 
404 static uint64_t resolveMips32(uint64_t Type, uint64_t Offset, uint64_t S,
405                               uint64_t LocData, int64_t /*Addend*/) {
406   // FIXME: Take in account implicit addends to get correct results.
407   if (Type == ELF::R_MIPS_32)
408     return (S + LocData) & 0xFFFFFFFF;
409   if (Type == ELF::R_MIPS_TLS_DTPREL32)
410     return (S + LocData) & 0xFFFFFFFF;
411   llvm_unreachable("Invalid relocation type");
412 }
413 
414 static bool supportsSparc32(uint64_t Type) {
415   switch (Type) {
416   case ELF::R_SPARC_32:
417   case ELF::R_SPARC_UA32:
418     return true;
419   default:
420     return false;
421   }
422 }
423 
424 static uint64_t resolveSparc32(uint64_t Type, uint64_t Offset, uint64_t S,
425                                uint64_t LocData, int64_t Addend) {
426   if (Type == ELF::R_SPARC_32 || Type == ELF::R_SPARC_UA32)
427     return S + Addend;
428   return LocData;
429 }
430 
431 static bool supportsHexagon(uint64_t Type) {
432   return Type == ELF::R_HEX_32;
433 }
434 
435 static uint64_t resolveHexagon(uint64_t Type, uint64_t Offset, uint64_t S,
436                                uint64_t /*LocData*/, int64_t Addend) {
437   if (Type == ELF::R_HEX_32)
438     return S + Addend;
439   llvm_unreachable("Invalid relocation type");
440 }
441 
442 static bool supportsRISCV(uint64_t Type) {
443   switch (Type) {
444   case ELF::R_RISCV_NONE:
445   case ELF::R_RISCV_32:
446   case ELF::R_RISCV_32_PCREL:
447   case ELF::R_RISCV_64:
448   case ELF::R_RISCV_SET6:
449   case ELF::R_RISCV_SET8:
450   case ELF::R_RISCV_SUB6:
451   case ELF::R_RISCV_ADD8:
452   case ELF::R_RISCV_SUB8:
453   case ELF::R_RISCV_SET16:
454   case ELF::R_RISCV_ADD16:
455   case ELF::R_RISCV_SUB16:
456   case ELF::R_RISCV_SET32:
457   case ELF::R_RISCV_ADD32:
458   case ELF::R_RISCV_SUB32:
459   case ELF::R_RISCV_ADD64:
460   case ELF::R_RISCV_SUB64:
461     return true;
462   default:
463     return false;
464   }
465 }
466 
467 static uint64_t resolveRISCV(uint64_t Type, uint64_t Offset, uint64_t S,
468                              uint64_t LocData, int64_t Addend) {
469   int64_t RA = Addend;
470   uint64_t A = LocData;
471   switch (Type) {
472   case ELF::R_RISCV_NONE:
473     return LocData;
474   case ELF::R_RISCV_32:
475     return (S + RA) & 0xFFFFFFFF;
476   case ELF::R_RISCV_32_PCREL:
477     return (S + RA - Offset) & 0xFFFFFFFF;
478   case ELF::R_RISCV_64:
479     return S + RA;
480   case ELF::R_RISCV_SET6:
481     return (A & 0xC0) | ((S + RA) & 0x3F);
482   case ELF::R_RISCV_SUB6:
483     return (A & 0xC0) | (((A & 0x3F) - (S + RA)) & 0x3F);
484   case ELF::R_RISCV_SET8:
485     return (S + RA) & 0xFF;
486   case ELF::R_RISCV_ADD8:
487     return (A + (S + RA)) & 0xFF;
488   case ELF::R_RISCV_SUB8:
489     return (A - (S + RA)) & 0xFF;
490   case ELF::R_RISCV_SET16:
491     return (S + RA) & 0xFFFF;
492   case ELF::R_RISCV_ADD16:
493     return (A + (S + RA)) & 0xFFFF;
494   case ELF::R_RISCV_SUB16:
495     return (A - (S + RA)) & 0xFFFF;
496   case ELF::R_RISCV_SET32:
497     return (S + RA) & 0xFFFFFFFF;
498   case ELF::R_RISCV_ADD32:
499     return (A + (S + RA)) & 0xFFFFFFFF;
500   case ELF::R_RISCV_SUB32:
501     return (A - (S + RA)) & 0xFFFFFFFF;
502   case ELF::R_RISCV_ADD64:
503     return (A + (S + RA));
504   case ELF::R_RISCV_SUB64:
505     return (A - (S + RA));
506   default:
507     llvm_unreachable("Invalid relocation type");
508   }
509 }
510 
511 static bool supportsCSKY(uint64_t Type) {
512   switch (Type) {
513   case ELF::R_CKCORE_NONE:
514   case ELF::R_CKCORE_ADDR32:
515   case ELF::R_CKCORE_PCREL32:
516     return true;
517   default:
518     return false;
519   }
520 }
521 
522 static uint64_t resolveCSKY(uint64_t Type, uint64_t Offset, uint64_t S,
523                             uint64_t LocData, int64_t Addend) {
524   switch (Type) {
525   case ELF::R_CKCORE_NONE:
526     return LocData;
527   case ELF::R_CKCORE_ADDR32:
528     return (S + Addend) & 0xFFFFFFFF;
529   case ELF::R_CKCORE_PCREL32:
530     return (S + Addend - Offset) & 0xFFFFFFFF;
531   default:
532     llvm_unreachable("Invalid relocation type");
533   }
534 }
535 
536 static bool supportsLoongArch(uint64_t Type) {
537   switch (Type) {
538   case ELF::R_LARCH_NONE:
539   case ELF::R_LARCH_32:
540   case ELF::R_LARCH_32_PCREL:
541   case ELF::R_LARCH_64:
542   case ELF::R_LARCH_ADD8:
543   case ELF::R_LARCH_SUB8:
544   case ELF::R_LARCH_ADD16:
545   case ELF::R_LARCH_SUB16:
546   case ELF::R_LARCH_ADD32:
547   case ELF::R_LARCH_SUB32:
548   case ELF::R_LARCH_ADD64:
549   case ELF::R_LARCH_SUB64:
550     return true;
551   default:
552     return false;
553   }
554 }
555 
556 static uint64_t resolveLoongArch(uint64_t Type, uint64_t Offset, uint64_t S,
557                                  uint64_t LocData, int64_t Addend) {
558   switch (Type) {
559   case ELF::R_LARCH_NONE:
560     return LocData;
561   case ELF::R_LARCH_32:
562     return (S + Addend) & 0xFFFFFFFF;
563   case ELF::R_LARCH_32_PCREL:
564     return (S + Addend - Offset) & 0xFFFFFFFF;
565   case ELF::R_LARCH_64:
566     return S + Addend;
567   case ELF::R_LARCH_ADD8:
568     return (LocData + (S + Addend)) & 0xFF;
569   case ELF::R_LARCH_SUB8:
570     return (LocData - (S + Addend)) & 0xFF;
571   case ELF::R_LARCH_ADD16:
572     return (LocData + (S + Addend)) & 0xFFFF;
573   case ELF::R_LARCH_SUB16:
574     return (LocData - (S + Addend)) & 0xFFFF;
575   case ELF::R_LARCH_ADD32:
576     return (LocData + (S + Addend)) & 0xFFFFFFFF;
577   case ELF::R_LARCH_SUB32:
578     return (LocData - (S + Addend)) & 0xFFFFFFFF;
579   case ELF::R_LARCH_ADD64:
580     return (LocData + (S + Addend));
581   case ELF::R_LARCH_SUB64:
582     return (LocData - (S + Addend));
583   default:
584     llvm_unreachable("Invalid relocation type");
585   }
586 }
587 
588 static bool supportsCOFFX86(uint64_t Type) {
589   switch (Type) {
590   case COFF::IMAGE_REL_I386_SECREL:
591   case COFF::IMAGE_REL_I386_DIR32:
592     return true;
593   default:
594     return false;
595   }
596 }
597 
598 static uint64_t resolveCOFFX86(uint64_t Type, uint64_t Offset, uint64_t S,
599                                uint64_t LocData, int64_t /*Addend*/) {
600   switch (Type) {
601   case COFF::IMAGE_REL_I386_SECREL:
602   case COFF::IMAGE_REL_I386_DIR32:
603     return (S + LocData) & 0xFFFFFFFF;
604   default:
605     llvm_unreachable("Invalid relocation type");
606   }
607 }
608 
609 static bool supportsCOFFX86_64(uint64_t Type) {
610   switch (Type) {
611   case COFF::IMAGE_REL_AMD64_SECREL:
612   case COFF::IMAGE_REL_AMD64_ADDR64:
613     return true;
614   default:
615     return false;
616   }
617 }
618 
619 static uint64_t resolveCOFFX86_64(uint64_t Type, uint64_t Offset, uint64_t S,
620                                   uint64_t LocData, int64_t /*Addend*/) {
621   switch (Type) {
622   case COFF::IMAGE_REL_AMD64_SECREL:
623     return (S + LocData) & 0xFFFFFFFF;
624   case COFF::IMAGE_REL_AMD64_ADDR64:
625     return S + LocData;
626   default:
627     llvm_unreachable("Invalid relocation type");
628   }
629 }
630 
631 static bool supportsCOFFARM(uint64_t Type) {
632   switch (Type) {
633   case COFF::IMAGE_REL_ARM_SECREL:
634   case COFF::IMAGE_REL_ARM_ADDR32:
635     return true;
636   default:
637     return false;
638   }
639 }
640 
641 static uint64_t resolveCOFFARM(uint64_t Type, uint64_t Offset, uint64_t S,
642                                uint64_t LocData, int64_t /*Addend*/) {
643   switch (Type) {
644   case COFF::IMAGE_REL_ARM_SECREL:
645   case COFF::IMAGE_REL_ARM_ADDR32:
646     return (S + LocData) & 0xFFFFFFFF;
647   default:
648     llvm_unreachable("Invalid relocation type");
649   }
650 }
651 
652 static bool supportsCOFFARM64(uint64_t Type) {
653   switch (Type) {
654   case COFF::IMAGE_REL_ARM64_SECREL:
655   case COFF::IMAGE_REL_ARM64_ADDR64:
656     return true;
657   default:
658     return false;
659   }
660 }
661 
662 static uint64_t resolveCOFFARM64(uint64_t Type, uint64_t Offset, uint64_t S,
663                                  uint64_t LocData, int64_t /*Addend*/) {
664   switch (Type) {
665   case COFF::IMAGE_REL_ARM64_SECREL:
666     return (S + LocData) & 0xFFFFFFFF;
667   case COFF::IMAGE_REL_ARM64_ADDR64:
668     return S + LocData;
669   default:
670     llvm_unreachable("Invalid relocation type");
671   }
672 }
673 
674 static bool supportsMachOX86_64(uint64_t Type) {
675   return Type == MachO::X86_64_RELOC_UNSIGNED;
676 }
677 
678 static uint64_t resolveMachOX86_64(uint64_t Type, uint64_t Offset, uint64_t S,
679                                    uint64_t LocData, int64_t /*Addend*/) {
680   if (Type == MachO::X86_64_RELOC_UNSIGNED)
681     return S;
682   llvm_unreachable("Invalid relocation type");
683 }
684 
685 static bool supportsWasm32(uint64_t Type) {
686   switch (Type) {
687   case wasm::R_WASM_FUNCTION_INDEX_LEB:
688   case wasm::R_WASM_TABLE_INDEX_SLEB:
689   case wasm::R_WASM_TABLE_INDEX_I32:
690   case wasm::R_WASM_MEMORY_ADDR_LEB:
691   case wasm::R_WASM_MEMORY_ADDR_SLEB:
692   case wasm::R_WASM_MEMORY_ADDR_I32:
693   case wasm::R_WASM_TYPE_INDEX_LEB:
694   case wasm::R_WASM_GLOBAL_INDEX_LEB:
695   case wasm::R_WASM_FUNCTION_OFFSET_I32:
696   case wasm::R_WASM_SECTION_OFFSET_I32:
697   case wasm::R_WASM_TAG_INDEX_LEB:
698   case wasm::R_WASM_GLOBAL_INDEX_I32:
699   case wasm::R_WASM_TABLE_NUMBER_LEB:
700   case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
701     return true;
702   default:
703     return false;
704   }
705 }
706 
707 static bool supportsWasm64(uint64_t Type) {
708   switch (Type) {
709   case wasm::R_WASM_MEMORY_ADDR_LEB64:
710   case wasm::R_WASM_MEMORY_ADDR_SLEB64:
711   case wasm::R_WASM_MEMORY_ADDR_I64:
712   case wasm::R_WASM_TABLE_INDEX_SLEB64:
713   case wasm::R_WASM_TABLE_INDEX_I64:
714   case wasm::R_WASM_FUNCTION_OFFSET_I64:
715     return true;
716   default:
717     return supportsWasm32(Type);
718   }
719 }
720 
721 static uint64_t resolveWasm32(uint64_t Type, uint64_t Offset, uint64_t S,
722                               uint64_t LocData, int64_t /*Addend*/) {
723   switch (Type) {
724   case wasm::R_WASM_FUNCTION_INDEX_LEB:
725   case wasm::R_WASM_TABLE_INDEX_SLEB:
726   case wasm::R_WASM_TABLE_INDEX_I32:
727   case wasm::R_WASM_MEMORY_ADDR_LEB:
728   case wasm::R_WASM_MEMORY_ADDR_SLEB:
729   case wasm::R_WASM_MEMORY_ADDR_I32:
730   case wasm::R_WASM_TYPE_INDEX_LEB:
731   case wasm::R_WASM_GLOBAL_INDEX_LEB:
732   case wasm::R_WASM_FUNCTION_OFFSET_I32:
733   case wasm::R_WASM_SECTION_OFFSET_I32:
734   case wasm::R_WASM_TAG_INDEX_LEB:
735   case wasm::R_WASM_GLOBAL_INDEX_I32:
736   case wasm::R_WASM_TABLE_NUMBER_LEB:
737   case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
738     // For wasm section, its offset at 0 -- ignoring Value
739     return LocData;
740   default:
741     llvm_unreachable("Invalid relocation type");
742   }
743 }
744 
745 static uint64_t resolveWasm64(uint64_t Type, uint64_t Offset, uint64_t S,
746                               uint64_t LocData, int64_t Addend) {
747   switch (Type) {
748   case wasm::R_WASM_MEMORY_ADDR_LEB64:
749   case wasm::R_WASM_MEMORY_ADDR_SLEB64:
750   case wasm::R_WASM_MEMORY_ADDR_I64:
751   case wasm::R_WASM_TABLE_INDEX_SLEB64:
752   case wasm::R_WASM_TABLE_INDEX_I64:
753   case wasm::R_WASM_FUNCTION_OFFSET_I64:
754     // For wasm section, its offset at 0 -- ignoring Value
755     return LocData;
756   default:
757     return resolveWasm32(Type, Offset, S, LocData, Addend);
758   }
759 }
760 
761 std::pair<SupportsRelocation, RelocationResolver>
762 getRelocationResolver(const ObjectFile &Obj) {
763   if (Obj.isCOFF()) {
764     switch (Obj.getArch()) {
765     case Triple::x86_64:
766       return {supportsCOFFX86_64, resolveCOFFX86_64};
767     case Triple::x86:
768       return {supportsCOFFX86, resolveCOFFX86};
769     case Triple::arm:
770     case Triple::thumb:
771       return {supportsCOFFARM, resolveCOFFARM};
772     case Triple::aarch64:
773       return {supportsCOFFARM64, resolveCOFFARM64};
774     default:
775       return {nullptr, nullptr};
776     }
777   } else if (Obj.isELF()) {
778     if (Obj.getBytesInAddress() == 8) {
779       switch (Obj.getArch()) {
780       case Triple::x86_64:
781         return {supportsX86_64, resolveX86_64};
782       case Triple::aarch64:
783       case Triple::aarch64_be:
784         return {supportsAArch64, resolveAArch64};
785       case Triple::bpfel:
786       case Triple::bpfeb:
787         return {supportsBPF, resolveBPF};
788       case Triple::loongarch64:
789         return {supportsLoongArch, resolveLoongArch};
790       case Triple::mips64el:
791       case Triple::mips64:
792         return {supportsMips64, resolveMips64};
793       case Triple::ppc64le:
794       case Triple::ppc64:
795         return {supportsPPC64, resolvePPC64};
796       case Triple::systemz:
797         return {supportsSystemZ, resolveSystemZ};
798       case Triple::sparcv9:
799         return {supportsSparc64, resolveSparc64};
800       case Triple::amdgcn:
801         return {supportsAmdgpu, resolveAmdgpu};
802       case Triple::riscv64:
803         return {supportsRISCV, resolveRISCV};
804       default:
805         if (isAMDGPU(Obj))
806           return {supportsAmdgpu, resolveAmdgpu};
807         return {nullptr, nullptr};
808       }
809     }
810 
811     // 32-bit object file
812     assert(Obj.getBytesInAddress() == 4 &&
813            "Invalid word size in object file");
814 
815     switch (Obj.getArch()) {
816     case Triple::x86:
817       return {supportsX86, resolveX86};
818     case Triple::ppcle:
819     case Triple::ppc:
820       return {supportsPPC32, resolvePPC32};
821     case Triple::arm:
822     case Triple::armeb:
823       return {supportsARM, resolveARM};
824     case Triple::avr:
825       return {supportsAVR, resolveAVR};
826     case Triple::lanai:
827       return {supportsLanai, resolveLanai};
828     case Triple::loongarch32:
829       return {supportsLoongArch, resolveLoongArch};
830     case Triple::mipsel:
831     case Triple::mips:
832       return {supportsMips32, resolveMips32};
833     case Triple::msp430:
834       return {supportsMSP430, resolveMSP430};
835     case Triple::sparc:
836       return {supportsSparc32, resolveSparc32};
837     case Triple::hexagon:
838       return {supportsHexagon, resolveHexagon};
839     case Triple::r600:
840       return {supportsAmdgpu, resolveAmdgpu};
841     case Triple::riscv32:
842       return {supportsRISCV, resolveRISCV};
843     case Triple::csky:
844       return {supportsCSKY, resolveCSKY};
845     default:
846       if (isAMDGPU(Obj))
847         return {supportsAmdgpu, resolveAmdgpu};
848       return {nullptr, nullptr};
849     }
850   } else if (Obj.isMachO()) {
851     if (Obj.getArch() == Triple::x86_64)
852       return {supportsMachOX86_64, resolveMachOX86_64};
853     return {nullptr, nullptr};
854   } else if (Obj.isWasm()) {
855     if (Obj.getArch() == Triple::wasm32)
856       return {supportsWasm32, resolveWasm32};
857     if (Obj.getArch() == Triple::wasm64)
858       return {supportsWasm64, resolveWasm64};
859     return {nullptr, nullptr};
860   }
861 
862   llvm_unreachable("Invalid object file");
863 }
864 
865 uint64_t resolveRelocation(RelocationResolver Resolver, const RelocationRef &R,
866                            uint64_t S, uint64_t LocData) {
867   if (const ObjectFile *Obj = R.getObject()) {
868     int64_t Addend = 0;
869     if (Obj->isELF()) {
870       auto GetRelSectionType = [&]() -> unsigned {
871         if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(Obj))
872           return Elf32LEObj->getRelSection(R.getRawDataRefImpl())->sh_type;
873         if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(Obj))
874           return Elf64LEObj->getRelSection(R.getRawDataRefImpl())->sh_type;
875         if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(Obj))
876           return Elf32BEObj->getRelSection(R.getRawDataRefImpl())->sh_type;
877         auto *Elf64BEObj = cast<ELF64BEObjectFile>(Obj);
878         return Elf64BEObj->getRelSection(R.getRawDataRefImpl())->sh_type;
879       };
880 
881       if (GetRelSectionType() == ELF::SHT_RELA) {
882         Addend = getELFAddend(R);
883         // RISCV relocations use both LocData and Addend.
884         if (Obj->getArch() != Triple::riscv32 &&
885             Obj->getArch() != Triple::riscv64)
886           LocData = 0;
887       }
888     }
889 
890     return Resolver(R.getType(), R.getOffset(), S, LocData, Addend);
891   }
892 
893   // Sometimes the caller might want to use its own specific implementation of
894   // the resolver function. E.g. this is used by LLD when it resolves debug
895   // relocations and assumes that all of them have the same computation (S + A).
896   // The relocation R has no owner object in this case and we don't need to
897   // provide Type and Offset fields. It is also assumed the DataRefImpl.p
898   // contains the addend, provided by the caller.
899   return Resolver(/*Type=*/0, /*Offset=*/0, S, LocData,
900                   R.getRawDataRefImpl().p);
901 }
902 
903 } // namespace object
904 } // namespace llvm
905