[LLD][ELF] Introduce Thunk reuse compatibility

[peter.smith]

Summary

On ARM the interworking thunks are only produced for branch instructions that can't be changed into a blx instruction so only Thumb callers would call Thumb thunks and only ARM callers would call ARM thunks. With range extension thunks branch and link instructions may need a Thunk. These instructions can be rewritten as a blx and can use either ARM or Thumb thunks.

We introduce a compatibleWith() function so that a caller can check if an existing Thunk is compatible before reusing it.

[peter.smith]

Rebased to account for changes in D31654

[peter.smith]

I'm abandoning the range thunks implementation that inserts into OutputSections in favour of an implementation that inserts into InputSectionDescription.

ELF/Relocations.cpp

ThunkSection *ThunkCreator<ELFT>::getISThunkSec(InputSection *IS,
   ThunkedSections[IS] = TS;
   return TS;
 }
 
 template <class ELFT>
 std::pair<Thunk *, bool> ThunkCreator<ELFT>::getThunk(SymbolBody &Body,
                                                       uint32_t Type) {
   auto res = ThunkedSymbols.insert({&Body, nullptr});
-  if (res.second)
+  if (res.second || !res.first->second->compatibleWith(Type))
     res.first->second = addThunk<ELFT>(Type, Body);
   return std::make_pair(res.first->second, res.second);
 }
 
 // Make a new ThunkSection at offset Off and it to the persistent and per pass
 // records per OutputSection.
 template <class ELFT>
 ThunkSection *ThunkCreator<ELFT>::addThunkSection(OutputSection *OS,

ELF/Thunks.h

public:
   // All Thunks must define at least one symbol ThunkSym so that we can
   // redirect relocations to it.
   virtual void addSymbols(ThunkSection &IS) {}
 
   // Some Thunks must be placed immediately before their Target as they elide
   // a branch and fall through to the first Symbol in the Target.
   virtual InputSection *getTargetInputSection() const { return nullptr; }
 
+  // To reuse a Thunk the caller as identified by the RelocType must be
+  // compatible with it.
+  virtual bool compatibleWith(uint32_t RelocType) const { return true; }
+
   // The alignment requirement for this Thunk, defaults to the size of the
   // typical code section alignment.
   const SymbolBody &Destination;
   SymbolBody *ThunkSym;
   uint64_t Offset;
   uint32_t alignment = 4;
 };
 
 // For a Relocation to symbol S create a Thunk to be added to a synthetic
 // ThunkSection. At present there are implementations for ARM and Mips Thunks.
 template <class ELFT> Thunk *addThunk(uint32_t RelocType, SymbolBody &S);
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Thunks.cpp

 // Source State, TargetState, Target Requirement, ABS or PI, Range
 template <class ELFT> class ARMV7ABSLongThunk final : public Thunk {
 public:
   ARMV7ABSLongThunk(const SymbolBody &Dest) : Thunk(Dest) {}
 
   uint32_t size() const override { return 12; }
   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
   void addSymbols(ThunkSection &IS) override;
+  bool compatibleWith(uint32_t RelocType) const override;
 };
 
 template <class ELFT> class ARMV7PILongThunk final : public Thunk {
 public:
   ARMV7PILongThunk(const SymbolBody &Dest) : Thunk(Dest) {}
 
   uint32_t size() const override { return 16; }
   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
   void addSymbols(ThunkSection &IS) override;
+  bool compatibleWith(uint32_t RelocType) const override;
 };
 
 template <class ELFT> class ThumbV7ABSLongThunk final : public Thunk {
 public:
   ThumbV7ABSLongThunk(const SymbolBody &Dest) : Thunk(Dest) {
     this->alignment = 2;
   }
 
   uint32_t size() const override { return 10; }
   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
   void addSymbols(ThunkSection &IS) override;
+  bool compatibleWith(uint32_t RelocType) const override;
 };
 
 template <class ELFT> class ThumbV7PILongThunk final : public Thunk {
 public:
   ThumbV7PILongThunk(const SymbolBody &Dest) : Thunk(Dest) {
     this->alignment = 2;
   }
 
   uint32_t size() const override { return 12; }
   void writeTo(uint8_t *Buf, ThunkSection &IS) const override;
   void addSymbols(ThunkSection &IS) override;
+  bool compatibleWith(uint32_t RelocType) const override;
 };
 
 // MIPS LA25 thunk
 template <class ELFT> class MipsThunk final : public Thunk {
 public:
   MipsThunk(const SymbolBody &Dest) : Thunk(Dest) {}
 
   uint32_t size() const override { return 16; }

 void ARMV7ABSLongThunk<ELFT>::addSymbols(ThunkSection &IS) {
   this->ThunkSym = addSyntheticLocal<ELFT>(
       Saver.save("__ARMv7ABSLongThunk_" + this->Destination.getName()),
       STT_FUNC, this->Offset, size(), &IS);
   addSyntheticLocal<ELFT>("$a", STT_NOTYPE, this->Offset, 0, &IS);
 }
 
 template <class ELFT>
+bool ARMV7ABSLongThunk<ELFT>::compatibleWith(uint32_t RelocType) const {
+  // Thumb branch relocations can't use BLX
+  return RelocType != R_ARM_THM_JUMP19 && RelocType != R_ARM_THM_JUMP24;
+}
+
+template <class ELFT>
 void ThumbV7ABSLongThunk<ELFT>::writeTo(uint8_t *Buf, ThunkSection &IS) const {
   const uint8_t Data[] = {
       0x40, 0xf2, 0x00, 0x0c, // movw         ip, :lower16:S
       0xc0, 0xf2, 0x00, 0x0c, // movt         ip, :upper16:S
       0x60, 0x47,             // bx   ip
   };
   uint64_t S = getARMThunkDestVA(this->Destination);
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_THM_MOVW_ABS_NC, S);
   Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_ABS, S);
 }
 
 template <class ELFT>
 void ThumbV7ABSLongThunk<ELFT>::addSymbols(ThunkSection &IS) {
   this->ThunkSym = addSyntheticLocal<ELFT>(
       Saver.save("__Thumbv7ABSLongThunk_" + this->Destination.getName()),
       STT_FUNC, this->Offset, size(), &IS);
   addSyntheticLocal<ELFT>("$t", STT_NOTYPE, this->Offset, 0, &IS);
 }
 
 template <class ELFT>
+bool ThumbV7ABSLongThunk<ELFT>::compatibleWith(uint32_t RelocType) const {
+  // ARM branch relocations can't use BLX
+  return RelocType != R_ARM_JUMP24 && RelocType != R_ARM_PC24 &&
+         RelocType != R_ARM_PLT32;
+}
+
+template <class ELFT>
 void ARMV7PILongThunk<ELFT>::writeTo(uint8_t *Buf, ThunkSection &IS) const {
   const uint8_t Data[] = {
       0xf0, 0xcf, 0x0f, 0xe3, // P:  movw ip,:lower16:S - (P + (L1-P) +8)
       0x00, 0xc0, 0x40, 0xe3, //     movt ip,:upper16:S - (P + (L1-P+4) +8)
       0x0f, 0xc0, 0x8c, 0xe0, // L1: add ip, ip, pc
       0x1c, 0xff, 0x2f, 0xe1, //     bx r12
   };
   uint64_t S = getARMThunkDestVA(this->Destination);
   uint64_t P = this->ThunkSym->getVA();
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_MOVW_PREL_NC, S - P - 16);
   Target->relocateOne(Buf + 4, R_ARM_MOVT_PREL, S - P - 12);
 }
 
 template <class ELFT>
 void ARMV7PILongThunk<ELFT>::addSymbols(ThunkSection &IS) {
   this->ThunkSym = addSyntheticLocal<ELFT>(
       Saver.save("__ARMV7PILongThunk_" + this->Destination.getName()), STT_FUNC,
       this->Offset, size(), &IS);
   addSyntheticLocal<ELFT>("$a", STT_NOTYPE, this->Offset, 0, &IS);
 }
 
 template <class ELFT>
+bool ARMV7PILongThunk<ELFT>::compatibleWith(uint32_t RelocType) const {
+  // Thumb branch relocations can't use BLX
+  return RelocType != R_ARM_THM_JUMP19 && RelocType != R_ARM_THM_JUMP24;
+}
+
+template <class ELFT>
 void ThumbV7PILongThunk<ELFT>::writeTo(uint8_t *Buf, ThunkSection &IS) const {
   const uint8_t Data[] = {
       0x4f, 0xf6, 0xf4, 0x7c, // P:  movw ip,:lower16:S - (P + (L1-P) + 4)
       0xc0, 0xf2, 0x00, 0x0c, //     movt ip,:upper16:S - (P + (L1-P+4) + 4)
       0xfc, 0x44,             // L1: add  r12, pc
       0x60, 0x47,             //     bx   r12
   };
   uint64_t S = getARMThunkDestVA(this->Destination);
   uint64_t P = this->ThunkSym->getVA();
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_THM_MOVW_PREL_NC, S - P - 12);
   Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_PREL, S - P - 8);
 }
 
 template <class ELFT>
 void ThumbV7PILongThunk<ELFT>::addSymbols(ThunkSection &IS) {
   this->ThunkSym = addSyntheticLocal<ELFT>(
       Saver.save("__ThumbV7PILongThunk_" + this->Destination.getName()),
       STT_FUNC, this->Offset, size(), &IS);
   addSyntheticLocal<ELFT>("$t", STT_NOTYPE, this->Offset, 0, &IS);
 }
 
+template <class ELFT>
+bool ThumbV7PILongThunk<ELFT>::compatibleWith(uint32_t RelocType) const {
+  // ARM branch relocations can't use BLX
+  return RelocType != R_ARM_JUMP24 && RelocType != R_ARM_PC24 &&
+         RelocType != R_ARM_PLT32;
+}
+
 // Write MIPS LA25 thunk code to call PIC function from the non-PIC one.
 template <class ELFT>
 void MipsThunk<ELFT>::writeTo(uint8_t *Buf, ThunkSection &) const {
   const endianness E = ELFT::TargetEndianness;
 
   uint64_t S = this->Destination.getVA();
   write32<E>(Buf, 0x3c190000);                // lui   $25, %hi(func)
   write32<E>(Buf + 4, 0x08000000 | (S >> 2)); // j     func