contrib/llvm/tools/lld/ELF/Thunks.cpp

   1 //===- Thunks.cpp --------------------------------------------------------===//
   2 //
   3 //                             The LLVM Linker
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===---------------------------------------------------------------------===//
   9 //
  10 // This file contains Thunk subclasses.
  11 //
  12 // A thunk is a small piece of code written after an input section
  13 // which is used to jump between "incompatible" functions
  14 // such as MIPS PIC and non-PIC or ARM non-Thumb and Thumb functions.
  15 //
  16 // If a jump target is too far and its address doesn't fit to a
  17 // short jump instruction, we need to create a thunk too, but we
  18 // haven't supported it yet.
  19 //
  20 // i386 and x86-64 don't need thunks.
  21 //
  22 //===---------------------------------------------------------------------===//
  23
  24 #include "Thunks.h"
  25 #include "Config.h"
  26 #include "InputSection.h"
  27 #include "OutputSections.h"
  28 #include "Symbols.h"
  29 #include "SyntheticSections.h"
  30 #include "Target.h"
  31 #include "lld/Common/ErrorHandler.h"
  32 #include "lld/Common/Memory.h"
  33 #include "llvm/BinaryFormat/ELF.h"
  34 #include "llvm/Support/Casting.h"
  35 #include "llvm/Support/Endian.h"
  36 #include "llvm/Support/ErrorHandling.h"
  37 #include "llvm/Support/MathExtras.h"
  38 #include <cstdint>
  39 #include <cstring>
  40
  41 using namespace llvm;
  42 using namespace llvm::object;
  43 using namespace llvm::support::endian;
  44 using namespace llvm::ELF;
  45
  46 namespace lld {
  47 namespace elf {
  48
  49 namespace {
  50
  51 // AArch64 long range Thunks
  52 class AArch64ABSLongThunk final : public Thunk {
  53 public:
  54   AArch64ABSLongThunk(Symbol &Dest) : Thunk(Dest) {}
  55   uint32_t size() const override { return 16; }
  56   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
  57   void addSymbols(ThunkSection &IS) override;
  58 };
  59
  60 class AArch64ADRPThunk final : public Thunk {
  61 public:
  62   AArch64ADRPThunk(Symbol &Dest) : Thunk(Dest) {}
  63   uint32_t size() const override { return 12; }
  64   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
  65   void addSymbols(ThunkSection &IS) override;
  66 };
  67
  68 // Specific ARM Thunk implementations. The naming convention is:
  69 // Source State, TargetState, Target Requirement, ABS or PI, Range
  70 class ARMV7ABSLongThunk final : public Thunk {
  71 public:
  72   ARMV7ABSLongThunk(Symbol &Dest) : Thunk(Dest) {}
  73
  74   uint32_t size() const override { return 12; }
  75   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
  76   void addSymbols(ThunkSection &IS) override;
  77   bool isCompatibleWith(RelType Type) const override;
  78 };
  79
  80 class ARMV7PILongThunk final : public Thunk {
  81 public:
  82   ARMV7PILongThunk(Symbol &Dest) : Thunk(Dest) {}
  83
  84   uint32_t size() const override { return 16; }
  85   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
  86   void addSymbols(ThunkSection &IS) override;
  87   bool isCompatibleWith(RelType Type) const override;
  88 };
  89
  90 class ThumbV7ABSLongThunk final : public Thunk {
  91 public:
  92   ThumbV7ABSLongThunk(Symbol &Dest) : Thunk(Dest) { Alignment = 2; }
  93
  94   uint32_t size() const override { return 10; }
  95   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
  96   void addSymbols(ThunkSection &IS) override;
  97   bool isCompatibleWith(RelType Type) const override;
  98 };
  99
 100 class ThumbV7PILongThunk final : public Thunk {
 101 public:
 102   ThumbV7PILongThunk(Symbol &Dest) : Thunk(Dest) { Alignment = 2; }
 103
 104   uint32_t size() const override { return 12; }
 105   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
 106   void addSymbols(ThunkSection &IS) override;
 107   bool isCompatibleWith(RelType Type) const override;
 108 };
 109
 110 // MIPS LA25 thunk
 111 class MipsThunk final : public Thunk {
 112 public:
 113   MipsThunk(Symbol &Dest) : Thunk(Dest) {}
 114
 115   uint32_t size() const override { return 16; }
 116   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
 117   void addSymbols(ThunkSection &IS) override;
 118   InputSection *getTargetInputSection() const override;
 119 };
 120
 121 // microMIPS R2-R5 LA25 thunk
 122 class MicroMipsThunk final : public Thunk {
 123 public:
 124   MicroMipsThunk(Symbol &Dest) : Thunk(Dest) {}
 125
 126   uint32_t size() const override { return 14; }
 127   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
 128   void addSymbols(ThunkSection &IS) override;
 129   InputSection *getTargetInputSection() const override;
 130 };
 131
 132 // microMIPS R6 LA25 thunk
 133 class MicroMipsR6Thunk final : public Thunk {
 134 public:
 135   MicroMipsR6Thunk(Symbol &Dest) : Thunk(Dest) {}
 136
 137   uint32_t size() const override { return 12; }
 138   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
 139   void addSymbols(ThunkSection &IS) override;
 140   InputSection *getTargetInputSection() const override;
 141 };
 142
 143 } // end anonymous namespace
 144
 145 // AArch64 long range Thunks
 146
 147 static uint64_t getAArch64ThunkDestVA(const Symbol &S) {
 148   uint64_t V = S.isInPlt() ? S.getPltVA() : S.getVA();
 149   return V;
 150 }
 151
 152 void AArch64ABSLongThunk::writeTo(uint8_t *Buf, ThunkSection &IS) const {
 153   const uint8_t Data[] = {
 154     0x50, 0x00, 0x00, 0x58, //     ldr x16, L0
 155     0x00, 0x02, 0x1f, 0xd6, //     br  x16
 156     0x00, 0x00, 0x00, 0x00, // L0: .xword S
 157     0x00, 0x00, 0x00, 0x00,
 158   };
 159   uint64_t S = getAArch64ThunkDestVA(Destination);
 160   memcpy(Buf, Data, sizeof(Data));
 161   Target->relocateOne(Buf + 8, R_AARCH64_ABS64, S);
 162 }
 163
 164 void AArch64ABSLongThunk::addSymbols(ThunkSection &IS) {
 165   ThunkSym = addSyntheticLocal(
 166       Saver.save("__AArch64AbsLongThunk_" + Destination.getName()), STT_FUNC,
 167       Offset, size(), IS);
 168   addSyntheticLocal("$x", STT_NOTYPE, Offset, 0, IS);
 169   addSyntheticLocal("$d", STT_NOTYPE, Offset + 8, 0, IS);
 170 }
 171
 172 // This Thunk has a maximum range of 4Gb, this is sufficient for all programs
 173 // using the small code model, including pc-relative ones. At time of writing
 174 // clang and gcc do not support the large code model for position independent
 175 // code so it is safe to use this for position independent thunks without
 176 // worrying about the destination being more than 4Gb away.
 177 void AArch64ADRPThunk::writeTo(uint8_t *Buf, ThunkSection &IS) const {
 178   const uint8_t Data[] = {
 179       0x10, 0x00, 0x00, 0x90, // adrp x16, Dest R_AARCH64_ADR_PREL_PG_HI21(Dest)
 180       0x10, 0x02, 0x00, 0x91, // add  x16, x16, R_AARCH64_ADD_ABS_LO12_NC(Dest)
 181       0x00, 0x02, 0x1f, 0xd6, // br   x16
 182   };
 183   uint64_t S = getAArch64ThunkDestVA(Destination);
 184   uint64_t P = ThunkSym->getVA();
 185   memcpy(Buf, Data, sizeof(Data));
 186   Target->relocateOne(Buf, R_AARCH64_ADR_PREL_PG_HI21,
 187                       getAArch64Page(S) - getAArch64Page(P));
 188   Target->relocateOne(Buf + 4, R_AARCH64_ADD_ABS_LO12_NC, S);
 189 }
 190
 191 void AArch64ADRPThunk::addSymbols(ThunkSection &IS)
 192 {
 193   ThunkSym = addSyntheticLocal(
 194       Saver.save("__AArch64ADRPThunk_" + Destination.getName()), STT_FUNC,
 195       Offset, size(), IS);
 196   addSyntheticLocal("$x", STT_NOTYPE, Offset, 0, IS);
 197 }
 198
 199 // ARM Target Thunks
 200 static uint64_t getARMThunkDestVA(const Symbol &S) {
 201   uint64_t V = S.isInPlt() ? S.getPltVA() : S.getVA();
 202   return SignExtend64<32>(V);
 203 }
 204
 205 void ARMV7ABSLongThunk::writeTo(uint8_t *Buf, ThunkSection &IS) const {
 206   const uint8_t Data[] = {
 207       0x00, 0xc0, 0x00, 0xe3, // movw         ip,:lower16:S
 208       0x00, 0xc0, 0x40, 0xe3, // movt         ip,:upper16:S
 209       0x1c, 0xff, 0x2f, 0xe1, // bx   ip
 210   };
 211   uint64_t S = getARMThunkDestVA(Destination);
 212   memcpy(Buf, Data, sizeof(Data));
 213   Target->relocateOne(Buf, R_ARM_MOVW_ABS_NC, S);
 214   Target->relocateOne(Buf + 4, R_ARM_MOVT_ABS, S);
 215 }
 216
 217 void ARMV7ABSLongThunk::addSymbols(ThunkSection &IS) {
 218   ThunkSym = addSyntheticLocal(
 219       Saver.save("__ARMv7ABSLongThunk_" + Destination.getName()), STT_FUNC,
 220       Offset, size(), IS);
 221   addSyntheticLocal("$a", STT_NOTYPE, Offset, 0, IS);
 222 }
 223
 224 bool ARMV7ABSLongThunk::isCompatibleWith(RelType Type) const {
 225   // Thumb branch relocations can't use BLX
 226   return Type != R_ARM_THM_JUMP19 && Type != R_ARM_THM_JUMP24;
 227 }
 228
 229 void ThumbV7ABSLongThunk::writeTo(uint8_t *Buf, ThunkSection &IS) const {
 230   const uint8_t Data[] = {
 231       0x40, 0xf2, 0x00, 0x0c, // movw         ip, :lower16:S
 232       0xc0, 0xf2, 0x00, 0x0c, // movt         ip, :upper16:S
 233       0x60, 0x47,             // bx   ip
 234   };
 235   uint64_t S = getARMThunkDestVA(Destination);
 236   memcpy(Buf, Data, sizeof(Data));
 237   Target->relocateOne(Buf, R_ARM_THM_MOVW_ABS_NC, S);
 238   Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_ABS, S);
 239 }
 240
 241 void ThumbV7ABSLongThunk::addSymbols(ThunkSection &IS) {
 242   ThunkSym = addSyntheticLocal(
 243       Saver.save("__Thumbv7ABSLongThunk_" + Destination.getName()), STT_FUNC,
 244       Offset | 0x1, size(), IS);
 245   addSyntheticLocal("$t", STT_NOTYPE, Offset, 0, IS);
 246 }
 247
 248 bool ThumbV7ABSLongThunk::isCompatibleWith(RelType Type) const {
 249   // ARM branch relocations can't use BLX
 250   return Type != R_ARM_JUMP24 && Type != R_ARM_PC24 && Type != R_ARM_PLT32;
 251 }
 252
 253 void ARMV7PILongThunk::writeTo(uint8_t *Buf, ThunkSection &IS) const {
 254   const uint8_t Data[] = {
 255       0xf0, 0xcf, 0x0f, 0xe3, // P:  movw ip,:lower16:S - (P + (L1-P) + 8)
 256       0x00, 0xc0, 0x40, 0xe3, //     movt ip,:upper16:S - (P + (L1-P) + 8)
 257       0x0f, 0xc0, 0x8c, 0xe0, // L1: add ip, ip, pc
 258       0x1c, 0xff, 0x2f, 0xe1, //     bx r12
 259   };
 260   uint64_t S = getARMThunkDestVA(Destination);
 261   uint64_t P = ThunkSym->getVA();
 262   uint64_t Offset = S - P - 16;
 263   memcpy(Buf, Data, sizeof(Data));
 264   Target->relocateOne(Buf, R_ARM_MOVW_PREL_NC, Offset);
 265   Target->relocateOne(Buf + 4, R_ARM_MOVT_PREL, Offset);
 266 }
 267
 268 void ARMV7PILongThunk::addSymbols(ThunkSection &IS) {
 269   ThunkSym = addSyntheticLocal(
 270       Saver.save("__ARMV7PILongThunk_" + Destination.getName()), STT_FUNC,
 271       Offset, size(), IS);
 272   addSyntheticLocal("$a", STT_NOTYPE, Offset, 0, IS);
 273 }
 274
 275 bool ARMV7PILongThunk::isCompatibleWith(RelType Type) const {
 276   // Thumb branch relocations can't use BLX
 277   return Type != R_ARM_THM_JUMP19 && Type != R_ARM_THM_JUMP24;
 278 }
 279
 280 void ThumbV7PILongThunk::writeTo(uint8_t *Buf, ThunkSection &IS) const {
 281   const uint8_t Data[] = {
 282       0x4f, 0xf6, 0xf4, 0x7c, // P:  movw ip,:lower16:S - (P + (L1-P) + 4)
 283       0xc0, 0xf2, 0x00, 0x0c, //     movt ip,:upper16:S - (P + (L1-P) + 4)
 284       0xfc, 0x44,             // L1: add  r12, pc
 285       0x60, 0x47,             //     bx   r12
 286   };
 287   uint64_t S = getARMThunkDestVA(Destination);
 288   uint64_t P = ThunkSym->getVA() & ~0x1;
 289   uint64_t Offset = S - P - 12;
 290   memcpy(Buf, Data, sizeof(Data));
 291   Target->relocateOne(Buf, R_ARM_THM_MOVW_PREL_NC, Offset);
 292   Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_PREL, Offset);
 293 }
 294
 295 void ThumbV7PILongThunk::addSymbols(ThunkSection &IS) {
 296   ThunkSym = addSyntheticLocal(
 297       Saver.save("__ThumbV7PILongThunk_" + Destination.getName()), STT_FUNC,
 298       Offset | 0x1, size(), IS);
 299   addSyntheticLocal("$t", STT_NOTYPE, Offset, 0, IS);
 300 }
 301
 302 bool ThumbV7PILongThunk::isCompatibleWith(RelType Type) const {
 303   // ARM branch relocations can't use BLX
 304   return Type != R_ARM_JUMP24 && Type != R_ARM_PC24 && Type != R_ARM_PLT32;
 305 }
 306
 307 // Write MIPS LA25 thunk code to call PIC function from the non-PIC one.
 308 void MipsThunk::writeTo(uint8_t *Buf, ThunkSection &) const {
 309   uint64_t S = Destination.getVA();
 310   write32(Buf, 0x3c190000, Config->Endianness); // lui   $25, %hi(func)
 311   write32(Buf + 4, 0x08000000 | (S >> 2), Config->Endianness); // j     func
 312   write32(Buf + 8, 0x27390000, Config->Endianness); // addiu $25, $25, %lo(func)
 313   write32(Buf + 12, 0x00000000, Config->Endianness); // nop
 314   Target->relocateOne(Buf, R_MIPS_HI16, S);
 315   Target->relocateOne(Buf + 8, R_MIPS_LO16, S);
 316 }
 317
 318 void MipsThunk::addSymbols(ThunkSection &IS) {
 319   ThunkSym =
 320       addSyntheticLocal(Saver.save("__LA25Thunk_" + Destination.getName()),
 321                         STT_FUNC, Offset, size(), IS);
 322 }
 323
 324 InputSection *MipsThunk::getTargetInputSection() const {
 325   auto &DR = cast<Defined>(Destination);
 326   return dyn_cast<InputSection>(DR.Section);
 327 }
 328
 329 // Write microMIPS R2-R5 LA25 thunk code
 330 // to call PIC function from the non-PIC one.
 331 void MicroMipsThunk::writeTo(uint8_t *Buf, ThunkSection &) const {
 332   uint64_t S = Destination.getVA() | 1;
 333   write16(Buf, 0x41b9, Config->Endianness);       // lui   $25, %hi(func)
 334   write16(Buf + 4, 0xd400, Config->Endianness);   // j     func
 335   write16(Buf + 8, 0x3339, Config->Endianness);   // addiu $25, $25, %lo(func)
 336   write16(Buf + 12, 0x0c00, Config->Endianness);  // nop
 337   Target->relocateOne(Buf, R_MICROMIPS_HI16, S);
 338   Target->relocateOne(Buf + 4, R_MICROMIPS_26_S1, S);
 339   Target->relocateOne(Buf + 8, R_MICROMIPS_LO16, S);
 340 }
 341
 342 void MicroMipsThunk::addSymbols(ThunkSection &IS) {
 343   ThunkSym =
 344       addSyntheticLocal(Saver.save("__microLA25Thunk_" + Destination.getName()),
 345                         STT_FUNC, Offset, size(), IS);
 346   ThunkSym->StOther |= STO_MIPS_MICROMIPS;
 347 }
 348
 349 InputSection *MicroMipsThunk::getTargetInputSection() const {
 350   auto &DR = cast<Defined>(Destination);
 351   return dyn_cast<InputSection>(DR.Section);
 352 }
 353
 354 // Write microMIPS R6 LA25 thunk code
 355 // to call PIC function from the non-PIC one.
 356 void MicroMipsR6Thunk::writeTo(uint8_t *Buf, ThunkSection &) const {
 357   uint64_t S = Destination.getVA() | 1;
 358   uint64_t P = ThunkSym->getVA();
 359   write16(Buf, 0x1320, Config->Endianness);       // lui   $25, %hi(func)
 360   write16(Buf + 4, 0x3339, Config->Endianness);   // addiu $25, $25, %lo(func)
 361   write16(Buf + 8, 0x9400, Config->Endianness);   // bc    func
 362   Target->relocateOne(Buf, R_MICROMIPS_HI16, S);
 363   Target->relocateOne(Buf + 4, R_MICROMIPS_LO16, S);
 364   Target->relocateOne(Buf + 8, R_MICROMIPS_PC26_S1, S - P - 12);
 365 }
 366
 367 void MicroMipsR6Thunk::addSymbols(ThunkSection &IS) {
 368   ThunkSym =
 369       addSyntheticLocal(Saver.save("__microLA25Thunk_" + Destination.getName()),
 370                         STT_FUNC, Offset, size(), IS);
 371   ThunkSym->StOther |= STO_MIPS_MICROMIPS;
 372 }
 373
 374 InputSection *MicroMipsR6Thunk::getTargetInputSection() const {
 375   auto &DR = cast<Defined>(Destination);
 376   return dyn_cast<InputSection>(DR.Section);
 377 }
 378
 379 Thunk::Thunk(Symbol &D) : Destination(D), Offset(0) {}
 380
 381 Thunk::~Thunk() = default;
 382
 383 static Thunk *addThunkAArch64(RelType Type, Symbol &S) {
 384   if (Type != R_AARCH64_CALL26 && Type != R_AARCH64_JUMP26)
 385     fatal("unrecognized relocation type");
 386   if (Config->Pic)
 387     return make<AArch64ADRPThunk>(S);
 388   return make<AArch64ABSLongThunk>(S);
 389 }
 390
 391 // Creates a thunk for Thumb-ARM interworking.
 392 static Thunk *addThunkArm(RelType Reloc, Symbol &S) {
 393   // ARM relocations need ARM to Thumb interworking Thunks.
 394   // Thumb relocations need Thumb to ARM relocations.
 395   // Use position independent Thunks if we require position independent code.
 396   switch (Reloc) {
 397   case R_ARM_PC24:
 398   case R_ARM_PLT32:
 399   case R_ARM_JUMP24:
 400   case R_ARM_CALL:
 401     if (Config->Pic)
 402       return make<ARMV7PILongThunk>(S);
 403     return make<ARMV7ABSLongThunk>(S);
 404   case R_ARM_THM_JUMP19:
 405   case R_ARM_THM_JUMP24:
 406   case R_ARM_THM_CALL:
 407     if (Config->Pic)
 408       return make<ThumbV7PILongThunk>(S);
 409     return make<ThumbV7ABSLongThunk>(S);
 410   }
 411   fatal("unrecognized relocation type");
 412 }
 413
 414 static Thunk *addThunkMips(RelType Type, Symbol &S) {
 415   if ((S.StOther & STO_MIPS_MICROMIPS) && isMipsR6())
 416     return make<MicroMipsR6Thunk>(S);
 417   if (S.StOther & STO_MIPS_MICROMIPS)
 418     return make<MicroMipsThunk>(S);
 419   return make<MipsThunk>(S);
 420 }
 421
 422 Thunk *addThunk(RelType Type, Symbol &S) {
 423   if (Config->EMachine == EM_AARCH64)
 424     return addThunkAArch64(Type, S);
 425   else if (Config->EMachine == EM_ARM)
 426     return addThunkArm(Type, S);
 427   else if (Config->EMachine == EM_MIPS)
 428     return addThunkMips(Type, S);
 429   llvm_unreachable("add Thunk only supported for ARM and Mips");
 430   return nullptr;
 431 }
 432
 433 } // end namespace elf
 434 } // end namespace lld