llvm/lib/Object/RelocationResolver.cpp

   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
  15 namespace llvm {
  16 namespace object {
  17
  18 static int64_t getELFAddend(RelocationRef R) {
  19   Expected<int64_t> AddendOrErr = ELFRelocationRef(R).getAddend();
  20   handleAllErrors(AddendOrErr.takeError(), [](const ErrorInfoBase &EI) {
  21     report_fatal_error(EI.message());
  22   });
  23   return *AddendOrErr;
  24 }
  25
  26 static bool supportsX86_64(uint64_t Type) {
  27   switch (Type) {
  28   case ELF::R_X86_64_NONE:
  29   case ELF::R_X86_64_64:
  30   case ELF::R_X86_64_DTPOFF32:
  31   case ELF::R_X86_64_DTPOFF64:
  32   case ELF::R_X86_64_PC32:
  33   case ELF::R_X86_64_PC64:
  34   case ELF::R_X86_64_32:
  35   case ELF::R_X86_64_32S:
  36     return true;
  37   default:
  38     return false;
  39   }
  40 }
  41
  42 static uint64_t resolveX86_64(RelocationRef R, uint64_t S, uint64_t A) {
  43   switch (R.getType()) {
  44   case ELF::R_X86_64_NONE:
  45     return A;
  46   case ELF::R_X86_64_64:
  47   case ELF::R_X86_64_DTPOFF32:
  48   case ELF::R_X86_64_DTPOFF64:
  49     return S + getELFAddend(R);
  50   case ELF::R_X86_64_PC32:
  51   case ELF::R_X86_64_PC64:
  52     return S + getELFAddend(R) - R.getOffset();
  53   case ELF::R_X86_64_32:
  54   case ELF::R_X86_64_32S:
  55     return (S + getELFAddend(R)) & 0xFFFFFFFF;
  56   default:
  57     llvm_unreachable("Invalid relocation type");
  58   }
  59 }
  60
  61 static bool supportsAArch64(uint64_t Type) {
  62   switch (Type) {
  63   case ELF::R_AARCH64_ABS32:
  64   case ELF::R_AARCH64_ABS64:
  65     return true;
  66   default:
  67     return false;
  68   }
  69 }
  70
  71 static uint64_t resolveAArch64(RelocationRef R, uint64_t S, uint64_t A) {
  72   switch (R.getType()) {
  73   case ELF::R_AARCH64_ABS32:
  74     return (S + getELFAddend(R)) & 0xFFFFFFFF;
  75   case ELF::R_AARCH64_ABS64:
  76     return S + getELFAddend(R);
  77   default:
  78     llvm_unreachable("Invalid relocation type");
  79   }
  80 }
  81
  82 static bool supportsBPF(uint64_t Type) {
  83   switch (Type) {
  84   case ELF::R_BPF_64_32:
  85   case ELF::R_BPF_64_64:
  86     return true;
  87   default:
  88     return false;
  89   }
  90 }
  91
  92 static uint64_t resolveBPF(RelocationRef R, uint64_t S, uint64_t A) {
  93   switch (R.getType()) {
  94   case ELF::R_BPF_64_32:
  95     return (S + A) & 0xFFFFFFFF;
  96   case ELF::R_BPF_64_64:
  97     return S + A;
  98   default:
  99     llvm_unreachable("Invalid relocation type");
 100   }
 101 }
 102
 103 static bool supportsMips64(uint64_t Type) {
 104   switch (Type) {
 105   case ELF::R_MIPS_32:
 106   case ELF::R_MIPS_64:
 107   case ELF::R_MIPS_TLS_DTPREL64:
 108   case ELF::R_MIPS_PC32:
 109     return true;
 110   default:
 111     return false;
 112   }
 113 }
 114
 115 static uint64_t resolveMips64(RelocationRef R, uint64_t S, uint64_t A) {
 116   switch (R.getType()) {
 117   case ELF::R_MIPS_32:
 118     return (S + getELFAddend(R)) & 0xFFFFFFFF;
 119   case ELF::R_MIPS_64:
 120     return S + getELFAddend(R);
 121   case ELF::R_MIPS_TLS_DTPREL64:
 122     return S + getELFAddend(R) - 0x8000;
 123   case ELF::R_MIPS_PC32:
 124     return S + getELFAddend(R) - R.getOffset();
 125   default:
 126     llvm_unreachable("Invalid relocation type");
 127   }
 128 }
 129
 130 static bool supportsPPC64(uint64_t Type) {
 131   switch (Type) {
 132   case ELF::R_PPC64_ADDR32:
 133   case ELF::R_PPC64_ADDR64:
 134     return true;
 135   default:
 136     return false;
 137   }
 138 }
 139
 140 static uint64_t resolvePPC64(RelocationRef R, uint64_t S, uint64_t A) {
 141   switch (R.getType()) {
 142   case ELF::R_PPC64_ADDR32:
 143     return (S + getELFAddend(R)) & 0xFFFFFFFF;
 144   case ELF::R_PPC64_ADDR64:
 145     return S + getELFAddend(R);
 146   default:
 147     llvm_unreachable("Invalid relocation type");
 148   }
 149 }
 150
 151 static bool supportsSystemZ(uint64_t Type) {
 152   switch (Type) {
 153   case ELF::R_390_32:
 154   case ELF::R_390_64:
 155     return true;
 156   default:
 157     return false;
 158   }
 159 }
 160
 161 static uint64_t resolveSystemZ(RelocationRef R, uint64_t S, uint64_t A) {
 162   switch (R.getType()) {
 163   case ELF::R_390_32:
 164     return (S + getELFAddend(R)) & 0xFFFFFFFF;
 165   case ELF::R_390_64:
 166     return S + getELFAddend(R);
 167   default:
 168     llvm_unreachable("Invalid relocation type");
 169   }
 170 }
 171
 172 static bool supportsSparc64(uint64_t Type) {
 173   switch (Type) {
 174   case ELF::R_SPARC_32:
 175   case ELF::R_SPARC_64:
 176   case ELF::R_SPARC_UA32:
 177   case ELF::R_SPARC_UA64:
 178     return true;
 179   default:
 180     return false;
 181   }
 182 }
 183
 184 static uint64_t resolveSparc64(RelocationRef R, uint64_t S, uint64_t A) {
 185   switch (R.getType()) {
 186   case ELF::R_SPARC_32:
 187   case ELF::R_SPARC_64:
 188   case ELF::R_SPARC_UA32:
 189   case ELF::R_SPARC_UA64:
 190     return S + getELFAddend(R);
 191   default:
 192     llvm_unreachable("Invalid relocation type");
 193   }
 194 }
 195
 196 static bool supportsAmdgpu(uint64_t Type) {
 197   switch (Type) {
 198   case ELF::R_AMDGPU_ABS32:
 199   case ELF::R_AMDGPU_ABS64:
 200     return true;
 201   default:
 202     return false;
 203   }
 204 }
 205
 206 static uint64_t resolveAmdgpu(RelocationRef R, uint64_t S, uint64_t A) {
 207   switch (R.getType()) {
 208   case ELF::R_AMDGPU_ABS32:
 209   case ELF::R_AMDGPU_ABS64:
 210     return S + getELFAddend(R);
 211   default:
 212     llvm_unreachable("Invalid relocation type");
 213   }
 214 }
 215
 216 static bool supportsX86(uint64_t Type) {
 217   switch (Type) {
 218   case ELF::R_386_NONE:
 219   case ELF::R_386_32:
 220   case ELF::R_386_PC32:
 221     return true;
 222   default:
 223     return false;
 224   }
 225 }
 226
 227 static uint64_t resolveX86(RelocationRef R, uint64_t S, uint64_t A) {
 228   switch (R.getType()) {
 229   case ELF::R_386_NONE:
 230     return A;
 231   case ELF::R_386_32:
 232     return S + A;
 233   case ELF::R_386_PC32:
 234     return S - R.getOffset() + A;
 235   default:
 236     llvm_unreachable("Invalid relocation type");
 237   }
 238 }
 239
 240 static bool supportsPPC32(uint64_t Type) {
 241   return Type == ELF::R_PPC_ADDR32;
 242 }
 243
 244 static uint64_t resolvePPC32(RelocationRef R, uint64_t S, uint64_t A) {
 245   if (R.getType() == ELF::R_PPC_ADDR32)
 246     return (S + getELFAddend(R)) & 0xFFFFFFFF;
 247   llvm_unreachable("Invalid relocation type");
 248 }
 249
 250 static bool supportsARM(uint64_t Type) {
 251   return Type == ELF::R_ARM_ABS32;
 252 }
 253
 254 static uint64_t resolveARM(RelocationRef R, uint64_t S, uint64_t A) {
 255   if (R.getType() == ELF::R_ARM_ABS32)
 256     return (S + A) & 0xFFFFFFFF;
 257   llvm_unreachable("Invalid relocation type");
 258 }
 259
 260 static bool supportsAVR(uint64_t Type) {
 261   switch (Type) {
 262   case ELF::R_AVR_16:
 263   case ELF::R_AVR_32:
 264     return true;
 265   default:
 266     return false;
 267   }
 268 }
 269
 270 static uint64_t resolveAVR(RelocationRef R, uint64_t S, uint64_t A) {
 271   switch (R.getType()) {
 272   case ELF::R_AVR_16:
 273     return (S + getELFAddend(R)) & 0xFFFF;
 274   case ELF::R_AVR_32:
 275     return (S + getELFAddend(R)) & 0xFFFFFFFF;
 276   default:
 277     llvm_unreachable("Invalid relocation type");
 278   }
 279 }
 280
 281 static bool supportsLanai(uint64_t Type) {
 282   return Type == ELF::R_LANAI_32;
 283 }
 284
 285 static uint64_t resolveLanai(RelocationRef R, uint64_t S, uint64_t A) {
 286   if (R.getType() == ELF::R_LANAI_32)
 287     return (S + getELFAddend(R)) & 0xFFFFFFFF;
 288   llvm_unreachable("Invalid relocation type");
 289 }
 290
 291 static bool supportsMips32(uint64_t Type) {
 292   switch (Type) {
 293   case ELF::R_MIPS_32:
 294   case ELF::R_MIPS_TLS_DTPREL32:
 295     return true;
 296   default:
 297     return false;
 298   }
 299 }
 300
 301 static uint64_t resolveMips32(RelocationRef R, uint64_t S, uint64_t A) {
 302   // FIXME: Take in account implicit addends to get correct results.
 303   uint32_t Rel = R.getType();
 304   if (Rel == ELF::R_MIPS_32)
 305     return (S + A) & 0xFFFFFFFF;
 306   if (Rel == ELF::R_MIPS_TLS_DTPREL32)
 307     return (S + A) & 0xFFFFFFFF;
 308   llvm_unreachable("Invalid relocation type");
 309 }
 310
 311 static bool supportsSparc32(uint64_t Type) {
 312   switch (Type) {
 313   case ELF::R_SPARC_32:
 314   case ELF::R_SPARC_UA32:
 315     return true;
 316   default:
 317     return false;
 318   }
 319 }
 320
 321 static uint64_t resolveSparc32(RelocationRef R, uint64_t S, uint64_t A) {
 322   uint32_t Rel = R.getType();
 323   if (Rel == ELF::R_SPARC_32 || Rel == ELF::R_SPARC_UA32)
 324     return S + getELFAddend(R);
 325   return A;
 326 }
 327
 328 static bool supportsHexagon(uint64_t Type) {
 329   return Type == ELF::R_HEX_32;
 330 }
 331
 332 static uint64_t resolveHexagon(RelocationRef R, uint64_t S, uint64_t A) {
 333   if (R.getType() == ELF::R_HEX_32)
 334     return S + getELFAddend(R);
 335   llvm_unreachable("Invalid relocation type");
 336 }
 337
 338 static bool supportsRISCV(uint64_t Type) {
 339   switch (Type) {
 340   case ELF::R_RISCV_NONE:
 341   case ELF::R_RISCV_32:
 342   case ELF::R_RISCV_32_PCREL:
 343   case ELF::R_RISCV_64:
 344   case ELF::R_RISCV_SET6:
 345   case ELF::R_RISCV_SUB6:
 346   case ELF::R_RISCV_ADD8:
 347   case ELF::R_RISCV_SUB8:
 348   case ELF::R_RISCV_ADD16:
 349   case ELF::R_RISCV_SUB16:
 350   case ELF::R_RISCV_ADD32:
 351   case ELF::R_RISCV_SUB32:
 352   case ELF::R_RISCV_ADD64:
 353   case ELF::R_RISCV_SUB64:
 354     return true;
 355   default:
 356     return false;
 357   }
 358 }
 359
 360 static uint64_t resolveRISCV(RelocationRef R, uint64_t S, uint64_t A) {
 361   int64_t RA = getELFAddend(R);
 362   switch (R.getType()) {
 363   case ELF::R_RISCV_NONE:
 364     return A;
 365   case ELF::R_RISCV_32:
 366     return (S + RA) & 0xFFFFFFFF;
 367   case ELF::R_RISCV_32_PCREL:
 368     return (S + RA - R.getOffset()) & 0xFFFFFFFF;
 369   case ELF::R_RISCV_64:
 370     return S + RA;
 371   case ELF::R_RISCV_SET6:
 372     return (A & 0xC0) | ((S + RA) & 0x3F);
 373   case ELF::R_RISCV_SUB6:
 374     return (A & 0xC0) | (((A & 0x3F) - (S + RA)) & 0x3F);
 375   case ELF::R_RISCV_ADD8:
 376     return (A + (S + RA)) & 0xFF;
 377   case ELF::R_RISCV_SUB8:
 378     return (A - (S + RA)) & 0xFF;
 379   case ELF::R_RISCV_ADD16:
 380     return (A + (S + RA)) & 0xFFFF;
 381   case ELF::R_RISCV_SUB16:
 382     return (A - (S + RA)) & 0xFFFF;
 383   case ELF::R_RISCV_ADD32:
 384     return (A + (S + RA)) & 0xFFFFFFFF;
 385   case ELF::R_RISCV_SUB32:
 386     return (A - (S + RA)) & 0xFFFFFFFF;
 387   case ELF::R_RISCV_ADD64:
 388     return (A + (S + RA));
 389   case ELF::R_RISCV_SUB64:
 390     return (A - (S + RA));
 391   default:
 392     llvm_unreachable("Invalid relocation type");
 393   }
 394 }
 395
 396 static bool supportsCOFFX86(uint64_t Type) {
 397   switch (Type) {
 398   case COFF::IMAGE_REL_I386_SECREL:
 399   case COFF::IMAGE_REL_I386_DIR32:
 400     return true;
 401   default:
 402     return false;
 403   }
 404 }
 405
 406 static uint64_t resolveCOFFX86(RelocationRef R, uint64_t S, uint64_t A) {
 407   switch (R.getType()) {
 408   case COFF::IMAGE_REL_I386_SECREL:
 409   case COFF::IMAGE_REL_I386_DIR32:
 410     return (S + A) & 0xFFFFFFFF;
 411   default:
 412     llvm_unreachable("Invalid relocation type");
 413   }
 414 }
 415
 416 static bool supportsCOFFX86_64(uint64_t Type) {
 417   switch (Type) {
 418   case COFF::IMAGE_REL_AMD64_SECREL:
 419   case COFF::IMAGE_REL_AMD64_ADDR64:
 420     return true;
 421   default:
 422     return false;
 423   }
 424 }
 425
 426 static uint64_t resolveCOFFX86_64(RelocationRef R, uint64_t S, uint64_t A) {
 427   switch (R.getType()) {
 428   case COFF::IMAGE_REL_AMD64_SECREL:
 429     return (S + A) & 0xFFFFFFFF;
 430   case COFF::IMAGE_REL_AMD64_ADDR64:
 431     return S + A;
 432   default:
 433     llvm_unreachable("Invalid relocation type");
 434   }
 435 }
 436
 437 static bool supportsCOFFARM(uint64_t Type) {
 438   switch (Type) {
 439   case COFF::IMAGE_REL_ARM_SECREL:
 440   case COFF::IMAGE_REL_ARM_ADDR32:
 441     return true;
 442   default:
 443     return false;
 444   }
 445 }
 446
 447 static uint64_t resolveCOFFARM(RelocationRef R, uint64_t S, uint64_t A) {
 448   switch (R.getType()) {
 449   case COFF::IMAGE_REL_ARM_SECREL:
 450   case COFF::IMAGE_REL_ARM_ADDR32:
 451     return (S + A) & 0xFFFFFFFF;
 452   default:
 453     llvm_unreachable("Invalid relocation type");
 454   }
 455 }
 456
 457 static bool supportsCOFFARM64(uint64_t Type) {
 458   switch (Type) {
 459   case COFF::IMAGE_REL_ARM64_SECREL:
 460   case COFF::IMAGE_REL_ARM64_ADDR64:
 461     return true;
 462   default:
 463     return false;
 464   }
 465 }
 466
 467 static uint64_t resolveCOFFARM64(RelocationRef R, uint64_t S, uint64_t A) {
 468   switch (R.getType()) {
 469   case COFF::IMAGE_REL_ARM64_SECREL:
 470     return (S + A) & 0xFFFFFFFF;
 471   case COFF::IMAGE_REL_ARM64_ADDR64:
 472     return S + A;
 473   default:
 474     llvm_unreachable("Invalid relocation type");
 475   }
 476 }
 477
 478 static bool supportsMachOX86_64(uint64_t Type) {
 479   return Type == MachO::X86_64_RELOC_UNSIGNED;
 480 }
 481
 482 static uint64_t resolveMachOX86_64(RelocationRef R, uint64_t S, uint64_t A) {
 483   if (R.getType() == MachO::X86_64_RELOC_UNSIGNED)
 484     return S;
 485   llvm_unreachable("Invalid relocation type");
 486 }
 487
 488 static bool supportsWasm32(uint64_t Type) {
 489   switch (Type) {
 490   case wasm::R_WASM_FUNCTION_INDEX_LEB:
 491   case wasm::R_WASM_TABLE_INDEX_SLEB:
 492   case wasm::R_WASM_TABLE_INDEX_I32:
 493   case wasm::R_WASM_MEMORY_ADDR_LEB:
 494   case wasm::R_WASM_MEMORY_ADDR_SLEB:
 495   case wasm::R_WASM_MEMORY_ADDR_I32:
 496   case wasm::R_WASM_TYPE_INDEX_LEB:
 497   case wasm::R_WASM_GLOBAL_INDEX_LEB:
 498   case wasm::R_WASM_FUNCTION_OFFSET_I32:
 499   case wasm::R_WASM_SECTION_OFFSET_I32:
 500   case wasm::R_WASM_EVENT_INDEX_LEB:
 501     return true;
 502   default:
 503     return false;
 504   }
 505 }
 506
 507 static uint64_t resolveWasm32(RelocationRef R, uint64_t S, uint64_t A) {
 508   switch (R.getType()) {
 509   case wasm::R_WASM_FUNCTION_INDEX_LEB:
 510   case wasm::R_WASM_TABLE_INDEX_SLEB:
 511   case wasm::R_WASM_TABLE_INDEX_I32:
 512   case wasm::R_WASM_MEMORY_ADDR_LEB:
 513   case wasm::R_WASM_MEMORY_ADDR_SLEB:
 514   case wasm::R_WASM_MEMORY_ADDR_I32:
 515   case wasm::R_WASM_TYPE_INDEX_LEB:
 516   case wasm::R_WASM_GLOBAL_INDEX_LEB:
 517   case wasm::R_WASM_FUNCTION_OFFSET_I32:
 518   case wasm::R_WASM_SECTION_OFFSET_I32:
 519   case wasm::R_WASM_EVENT_INDEX_LEB:
 520     // For wasm section, its offset at 0 -- ignoring Value
 521     return A;
 522   default:
 523     llvm_unreachable("Invalid relocation type");
 524   }
 525 }
 526
 527 std::pair<bool (*)(uint64_t), RelocationResolver>
 528 getRelocationResolver(const ObjectFile &Obj) {
 529   if (Obj.isCOFF()) {
 530     switch (Obj.getArch()) {
 531     case Triple::x86_64:
 532       return {supportsCOFFX86_64, resolveCOFFX86_64};
 533     case Triple::x86:
 534       return {supportsCOFFX86, resolveCOFFX86};
 535     case Triple::arm:
 536     case Triple::thumb:
 537       return {supportsCOFFARM, resolveCOFFARM};
 538     case Triple::aarch64:
 539       return {supportsCOFFARM64, resolveCOFFARM64};
 540     default:
 541       return {nullptr, nullptr};
 542     }
 543   } else if (Obj.isELF()) {
 544     if (Obj.getBytesInAddress() == 8) {
 545       switch (Obj.getArch()) {
 546       case Triple::x86_64:
 547         return {supportsX86_64, resolveX86_64};
 548       case Triple::aarch64:
 549       case Triple::aarch64_be:
 550         return {supportsAArch64, resolveAArch64};
 551       case Triple::bpfel:
 552       case Triple::bpfeb:
 553         return {supportsBPF, resolveBPF};
 554       case Triple::mips64el:
 555       case Triple::mips64:
 556         return {supportsMips64, resolveMips64};
 557       case Triple::ppc64le:
 558       case Triple::ppc64:
 559         return {supportsPPC64, resolvePPC64};
 560       case Triple::systemz:
 561         return {supportsSystemZ, resolveSystemZ};
 562       case Triple::sparcv9:
 563         return {supportsSparc64, resolveSparc64};
 564       case Triple::amdgcn:
 565         return {supportsAmdgpu, resolveAmdgpu};
 566       case Triple::riscv64:
 567         return {supportsRISCV, resolveRISCV};
 568       default:
 569         return {nullptr, nullptr};
 570       }
 571     }
 572
 573     // 32-bit object file
 574     assert(Obj.getBytesInAddress() == 4 &&
 575            "Invalid word size in object file");
 576
 577     switch (Obj.getArch()) {
 578     case Triple::x86:
 579       return {supportsX86, resolveX86};
 580     case Triple::ppc:
 581       return {supportsPPC32, resolvePPC32};
 582     case Triple::arm:
 583     case Triple::armeb:
 584       return {supportsARM, resolveARM};
 585     case Triple::avr:
 586       return {supportsAVR, resolveAVR};
 587     case Triple::lanai:
 588       return {supportsLanai, resolveLanai};
 589     case Triple::mipsel:
 590     case Triple::mips:
 591       return {supportsMips32, resolveMips32};
 592     case Triple::sparc:
 593       return {supportsSparc32, resolveSparc32};
 594     case Triple::hexagon:
 595       return {supportsHexagon, resolveHexagon};
 596     case Triple::riscv32:
 597       return {supportsRISCV, resolveRISCV};
 598     default:
 599       return {nullptr, nullptr};
 600     }
 601   } else if (Obj.isMachO()) {
 602     if (Obj.getArch() == Triple::x86_64)
 603       return {supportsMachOX86_64, resolveMachOX86_64};
 604     return {nullptr, nullptr};
 605   } else if (Obj.isWasm()) {
 606     if (Obj.getArch() == Triple::wasm32)
 607       return {supportsWasm32, resolveWasm32};
 608     return {nullptr, nullptr};
 609   }
 610
 611   llvm_unreachable("Invalid object file");
 612 }
 613
 614 } // namespace object
 615 } // namespace llvm