[LLD][ELF] Use Synthetic Sections for Thunks

[peter.smith]

Summary

Thunks are now implemented by redirecting a relocation to the symbol S, to a symbol TS defined in a Thunk. The Thunk will transfer control to S. This has the following implications:

• All the side-effects of Thunks happen within createThunks()
• Thunks are no longer stored in InputSections and Symbols no longer need to hold a pointer to a Thunk
• The synthetic Thunk sections need to be merged into OutputSections

This implementation is almost a direct conversion of the existing Thunks with the following exceptions:

• Mips LA25 Thunks are placed before the InputSection that defines the symbol that needs a Thunk.
• All ARM Thunks are placed at the end of the OutputSection of the first caller to the Thunk.

Range extension Thunks are not supported yet so it is optimistically assumed that all Thunks can be reused.

Design decisions:
I've used the synthetic section as a container for multiple thunks. This minimises the number of insertions into the InputSections, makes it easier to insert multiple Mips LA25 thunks before the target InputSection, and will make it easier to support range-extension thunks as Gold and ld.bfd implement them (thunk pools placed at regular intervals). Alternatives would be a single Thunk per SyntheticSection or derive each Thunk from SyntheticSection.

I've put the Mips LA25 Thunks ahead of the Target Input Section as Simon has mentioned that this will enable an optimization to allow control to drop through into the next section without a jump instruction. I have not implemented that optimization.

As the Thunks define symbols they need to be ahead of the code that adds symbols into the symbol table so I've moved the createThunks call to before the code to finalize the SymTab.

There isn't a standard naming convention for Thunks, every ARM linker does it differently, I've somewhat arbitrarily chosen names that are close to the Thunk class names, but do not have a strong opinion what we should use. I find it helpful to have the symbol for the Thunk displayed in disassembly.

I expect that supporting range extension thunks will need quite a bit of change to the code in createThunks(). The current implementation is only good enough to handle Mips LA25 Thunks that need precise insertion, and ARM Thunks that can go at the end of the OutputSection.

[ruiu]

ELF/Relocations.cpp

809

Capitalize all local variables in this function (i.e. thunkCmp, a, b, tmp and mergeCmp).

823–826

Could you describe not only what it is doing but why we want that behavior?

831

Probably move assignment is more C++11-ish than swap.

863

Flip the condition to use continue.

872–874

Can you flip the conditions of these ifs to reduce indentation?

ELF/Symbols.h

419–420

clang-format-diff?

ELF/SyntheticSections.h

708

nit: add a blank line.

ELF/Thunks.cpp

264–266

Remove else after return

[peter.smith]

Thanks very much for the comments.

I've updated the diff to apply the changes. I wasn't able to find a way to reduce the indentation createThunks by inverting some the if statements.
What I've done instead is extracted the main operations into lambdas. This hopefully makes the main loop processing relocations easier to follow.

[ruiu]

LGTM

ELF/Relocations.cpp

858–863

This code looks up ThunkedSymbols twice with the same key. I wonder if you can avoid that by doing something like this with a reference.

Thunk<ELFT> *&T = ThunkedSymbols[&Body];
if (T)
  return std::make_pair(T, false);
T = addThunk<ELFT>(Type, Body);
return std::make_pair(T, true);

ELF/Thunks.h

47

nit: Can you make this a member variable set by ctor to avoid the cost of virtual function call?

[peter.smith]

Thanks for the suggestions. Now committed r293283. I'll now go about thinking about how best to add range extension thunks.

ELF/InputFiles.cpp

if (Sym->getType() == STT_FILE)
       SourceFile = check(Sym->getName(this->StringTable));
 
     if (this->StringTable.size() <= Sym->st_name)
       fatal(toString(this) + ": invalid symbol name offset");
 
     StringRefZ Name = this->StringTable.data() + Sym->st_name;
     if (Sym->st_shndx == SHN_UNDEF)
       return new (BAlloc)
-          Undefined<ELFT>(Name, /*IsLocal=*/true, StOther, Type, this);
+          Undefined(Name, /*IsLocal=*/true, StOther, Type, this);
 
     return new (BAlloc) DefinedRegular<ELFT>(Name, /*IsLocal=*/true, StOther,
                                              Type, Value, Size, Sec, this);
   }
 
   StringRef Name = check(Sym->getName(this->StringTable));
 
   switch (Sym->st_shndx) {

ELF/InputSection.h

public:
 
   // InputSection that is dependent on us (reverse dependency for GC)
   InputSectionBase<ELFT> *DependentSection = nullptr;
 
   static bool classof(const InputSectionData *S);
 
   InputSectionBase<ELFT> *getRelocatedSection();
 
-  // Register thunk related to the symbol. When the section is written
-  // to a mmap'ed file, target is requested to write an actual thunk code.
-  // Now thunks is supported for MIPS and ARM target only.
-  void addThunk(const Thunk<ELFT> *T);
-
-  // The offset of synthetic thunk code from beginning of this section.
-  uint64_t getThunkOff() const;
-
-  // Size of chunk with thunks code.
-  uint64_t getThunksSize() const;
-
   template <class RelTy>
   void relocateNonAlloc(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
 
   // Used by ICF.
   uint32_t Class[2] = {0, 0};
 
   // Called by ICF to merge two input sections.
   void replace(InputSection<ELFT> *Other);
 
 private:
   template <class RelTy>
   void copyRelocations(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
-
-  llvm::TinyPtrVector<const Thunk<ELFT> *> Thunks;
 };
 
 template <class ELFT> InputSection<ELFT> InputSection<ELFT>::Discarded;
 } // namespace elf
 
 template <class ELFT> std::string toString(const elf::InputSectionBase<ELFT> *);
 } // namespace lld
 
 #endif

ELF/InputSection.cpp

: InputSectionBase(File, Hdr->sh_flags & ~SHF_INFO_LINK, Hdr->sh_type,
                        SectionKind) {
   this->Offset = Hdr->sh_offset;
 }
 
 template <class ELFT> size_t InputSectionBase<ELFT>::getSize() const {
   if (auto *S = dyn_cast<SyntheticSection<ELFT>>(this))
     return S->getSize();
 
-  if (auto *D = dyn_cast<InputSection<ELFT>>(this))
-    if (D->getThunksSize() > 0)
-      return D->getThunkOff() + D->getThunksSize();
-
   return Data.size();
 }
 
 template <class ELFT>
 typename ELFT::uint InputSectionBase<ELFT>::getOffset(uintX_t Offset) const {
   switch (kind()) {
   case Regular:
     return cast<InputSection<ELFT>>(this)->OutSecOff + Offset;

 
 template <class ELFT>
 InputSectionBase<ELFT> *InputSection<ELFT>::getRelocatedSection() {
   assert(this->Type == SHT_RELA || this->Type == SHT_REL);
   ArrayRef<InputSectionBase<ELFT> *> Sections = this->File->getSections();
   return Sections[this->Info];
 }
 
-template <class ELFT> void InputSection<ELFT>::addThunk(const Thunk<ELFT> *T) {
-  Thunks.push_back(T);
-}
-
-template <class ELFT> uint64_t InputSection<ELFT>::getThunkOff() const {
-  return this->Data.size();
-}
-
-template <class ELFT> uint64_t InputSection<ELFT>::getThunksSize() const {
-  uint64_t Total = 0;
-  for (const Thunk<ELFT> *T : Thunks)
-    Total += T->size();
-  return Total;
-}
-
 // This is used for -r. We can't use memcpy to copy relocations because we need
 // to update symbol table offset and section index for each relocation. So we
 // copy relocations one by one.
 template <class ELFT>
 template <class RelTy>
 void InputSection<ELFT>::copyRelocations(uint8_t *Buf, ArrayRef<RelTy> Rels) {
   InputSectionBase<ELFT> *RelocatedSection = getRelocatedSection();
 
getRelocTargetVA(uint32_t Type, typename ELFT::uint A, typename ELFT::uint P,
   switch (Expr) {
   case R_HINT:
   case R_TLSDESC_CALL:
     llvm_unreachable("cannot relocate hint relocs");
   case R_TLSLD:
     return In<ELFT>::Got->getTlsIndexOff() + A - In<ELFT>::Got->getSize();
   case R_TLSLD_PC:
     return In<ELFT>::Got->getTlsIndexVA() + A - P;
-  case R_THUNK_ABS:
-    return Body.getThunkVA<ELFT>() + A;
-  case R_THUNK_PC:
-  case R_THUNK_PLT_PC:
-    return Body.getThunkVA<ELFT>() + A - P;
   case R_PPC_TOC:
     return getPPC64TocBase() + A;
   case R_TLSGD:
     return In<ELFT>::Got->getGlobalDynOffset(Body) + A -
            In<ELFT>::Got->getSize();
   case R_TLSGD_PC:
     return In<ELFT>::Got->getGlobalDynAddr(Body) + A - P;
   case R_TLSDESC:
template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
 
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> Data = this->Data;
   memcpy(Buf + OutSecOff, Data.data(), Data.size());
 
   // Iterate over all relocation sections that apply to this section.
   uint8_t *BufEnd = Buf + OutSecOff + Data.size();
   this->relocate(Buf, BufEnd);
-
-  // The section might have a data/code generated by the linker and need
-  // to be written after the section. Usually these are thunks - small piece
-  // of code used to jump between "incompatible" functions like PIC and non-PIC
-  // or if the jump target too far and its address does not fit to the short
-  // jump istruction.
-  if (!Thunks.empty()) {
-    Buf += OutSecOff + getThunkOff();
-    for (const Thunk<ELFT> *T : Thunks) {
-      T->writeTo(Buf);
-      Buf += T->size();
-    }
-  }
 }
 
 template <class ELFT>
 void InputSection<ELFT>::replace(InputSection<ELFT> *Other) {
   this->Alignment = std::max(this->Alignment, Other->Alignment);
   Other->Repl = this->Repl;
   Other->Live = false;
 }

ELF/LTO.h

 class BitcodeFile;
 class InputFile;
 
 class BitcodeCompiler {
 public:
   BitcodeCompiler();
   ~BitcodeCompiler();
 
-  template <class ELFT> void add(BitcodeFile &F);
+  void add(BitcodeFile &F);
   std::vector<InputFile *> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> LTOObj;
   std::vector<SmallString<0>> Buff;
 };
 }
 }
 
 #endif

ELF/LTO.cpp

static std::unique_ptr<lto::LTO> createLTO() {
   return llvm::make_unique<lto::LTO>(std::move(Conf), Backend,
                                      Config->LTOPartitions);
 }
 
 BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {}
 
 BitcodeCompiler::~BitcodeCompiler() = default;
 
-template <class ELFT> static void undefine(Symbol *S) {
-  replaceBody<Undefined<ELFT>>(S, S->body()->getName(), /*IsLocal=*/false,
-                               STV_DEFAULT, S->body()->Type, nullptr);
+static void undefine(Symbol *S) {
+  replaceBody<Undefined>(S, S->body()->getName(), /*IsLocal=*/false,
 }
 
-template <class ELFT> void BitcodeCompiler::add(BitcodeFile &F) {
+void BitcodeCompiler::add(BitcodeFile &F) {
   lto::InputFile &Obj = *F.Obj;
   unsigned SymNum = 0;
   std::vector<Symbol *> Syms = F.getSymbols();
   std::vector<lto::SymbolResolution> Resols(Syms.size());
 
   // Provide a resolution to the LTO API for each symbol.
   for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     Symbol *Sym = Syms[SymNum];
     lto::SymbolResolution &R = Resols[SymNum];
     ++SymNum;
     SymbolBody *B = Sym->body();
 
     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
     // reports two symbols for module ASM defined. Without this check, lld
     // flags an undefined in IR with a definition in ASM as prevailing.
     // Once IRObjectFile is fixed to report only one symbol this hack can
     // be removed.
     R.Prevailing =
         !(ObjSym.getFlags() & object::BasicSymbolRef::SF_Undefined) &&
         B->File == &F;
 
     R.VisibleToRegularObj =
         Sym->IsUsedInRegularObj || (R.Prevailing && Sym->includeInDynsym());
     if (R.Prevailing)
-      undefine<ELFT>(Sym);
+      undefine(Sym);
   }
   checkError(LTOObj->add(std::move(F.Obj), Resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting ObjectFile(s).
 std::vector<InputFile *> BitcodeCompiler::compile() {
   std::vector<InputFile *> Ret;
if (Config->SaveTemps) {
       else
         saveBuffer(Buff[I], Config->OutputFile + Twine(I) + ".lto.o");
     }
     InputFile *Obj = createObjectFile(MemoryBufferRef(Buff[I], "lto.tmp"));
     Ret.push_back(Obj);
   }
   return Ret;
 }
-
-template void BitcodeCompiler::template add<ELF32LE>(BitcodeFile &);
-template void BitcodeCompiler::template add<ELF32BE>(BitcodeFile &);
-template void BitcodeCompiler::template add<ELF64LE>(BitcodeFile &);
-template void BitcodeCompiler::template add<ELF64BE>(BitcodeFile &);

ELF/Relocations.h

enum RelExpr {
   R_RELAX_TLS_GD_TO_IE_END,
   R_RELAX_TLS_GD_TO_IE_ABS,
   R_RELAX_TLS_GD_TO_IE_PAGE_PC,
   R_RELAX_TLS_GD_TO_LE,
   R_RELAX_TLS_GD_TO_LE_NEG,
   R_RELAX_TLS_IE_TO_LE,
   R_RELAX_TLS_LD_TO_LE,
   R_SIZE,
-  R_THUNK_ABS,
-  R_THUNK_PC,
-  R_THUNK_PLT_PC,
   R_TLS,
   R_TLSDESC,
   R_TLSDESC_PAGE,
   R_TLSDESC_CALL,
   R_TLSGD,
   R_TLSGD_PC,
   R_TLSLD,
   R_TLSLD_PC,

ELF/Relocations.cpp

 // because it doesn't know about the output file nor the output file buffer.
 // It instead stores Relocation objects to InputSection's Relocations
 // vector to let it apply later in InputSection::writeTo.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Relocations.h"
 #include "Config.h"
+#include "Memory.h"
 #include "OutputSections.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Thunks.h"
 
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
 namespace lld {
 namespace elf {
template <class ELFT> static bool isAbsolute(const SymbolBody &Body) {
   return false;
 }
 
 template <class ELFT> static bool isAbsoluteValue(const SymbolBody &Body) {
   return isAbsolute<ELFT>(Body) || Body.isTls();
 }
 
 static bool needsPlt(RelExpr Expr) {
-  return isRelExprOneOf<R_PLT_PC, R_PPC_PLT_OPD, R_PLT, R_PLT_PAGE_PC,
-                        R_THUNK_PLT_PC>(Expr);
+  return isRelExprOneOf<R_PLT_PC, R_PPC_PLT_OPD, R_PLT, R_PLT_PAGE_PC>(Expr);
 }
 
 // True if this expression is of the form Sym - X, where X is a position in the
 // file (PC, or GOT for example).
 static bool isRelExpr(RelExpr Expr) {
   return isRelExprOneOf<R_PC, R_GOTREL, R_GOTREL_FROM_END, R_MIPS_GOTREL,
-                        R_PAGE_PC, R_RELAX_GOT_PC, R_THUNK_PC, R_THUNK_PLT_PC>(
-      Expr);
+                        R_PAGE_PC, R_RELAX_GOT_PC>(Expr);
 }
 
 template <class ELFT>
 static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
                                      const SymbolBody &Body,
                                      InputSectionBase<ELFT> &S,
                                      typename ELFT::uint RelOff) {
   // These expressions always compute a constant
   if (isRelExprOneOf<R_SIZE, R_GOT_FROM_END, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE,
                      R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_TLSGD,
                      R_GOT_PAGE_PC, R_GOT_PC, R_PLT_PC, R_TLSGD_PC, R_TLSGD,
-                     R_PPC_PLT_OPD, R_TLSDESC_CALL, R_TLSDESC_PAGE, R_HINT,
-                     R_THUNK_PC, R_THUNK_PLT_PC>(E))
+                     R_PPC_PLT_OPD, R_TLSDESC_CALL, R_TLSDESC_PAGE, R_HINT>(E))
     return true;
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
   if (E == R_GOT || E == R_PLT || E == R_TLSDESC)
     return Target->usesOnlyLowPageBits(Type) || !Config->Pic;
 
   if (isPreemptible(Body, Type))
static RelExpr adjustExpr(const elf::ObjectFile<ELFT> &File, SymbolBody &Body,
   if (Body.isGnuIFunc()) {
     Expr = toPlt(Expr);
   } else if (!Preemptible) {
     if (needsPlt(Expr))
       Expr = fromPlt(Expr);
     if (Expr == R_GOT_PC && !isAbsoluteValue<ELFT>(Body))
       Expr = Target->adjustRelaxExpr(Type, Data, Expr);
   }
-  Expr = Target->getThunkExpr(Expr, Type, &File, Body);
 
   if (IsWrite || isStaticLinkTimeConstant<ELFT>(Expr, Type, Body, S, RelOff))
     return Expr;
 
   // This relocation would require the dynamic linker to write a value to read
   // only memory. We can hack around it if we are producing an executable and
   // the refered symbol can be preemepted to refer to the executable.
   if (Config->Shared || (Config->Pic && !isRelExpr(Expr))) {
for (auto I = Rels.begin(), E = Rels.end(); I != E; ++I) {
     }
 
     // Ignore "hint" and TLS Descriptor call relocation because they are
     // only markers for relaxation.
     if (isRelExprOneOf<R_HINT, R_TLSDESC_CALL>(Expr))
       continue;
 
     if (needsPlt(Expr) ||
-        isRelExprOneOf<R_THUNK_ABS, R_THUNK_PC, R_THUNK_PLT_PC>(Expr) ||
         refersToGotEntry(Expr) || !isPreemptible(Body, Type)) {
       // If the relocation points to something in the file, we can process it.
       bool Constant =
           isStaticLinkTimeConstant<ELFT>(Expr, Type, Body, C, RI.r_offset);
 
       // If the output being produced is position independent, the final value
       // is still not known. In that case we still need some help from the
       // dynamic linker. We can however do better than just copying the incoming

 
 template <class ELFT> void scanRelocations(InputSectionBase<ELFT> &S) {
   if (S.AreRelocsRela)
     scanRelocs(S, S.relas());
   else
     scanRelocs(S, S.rels());
 }
 
+// Insert the Thunks for OutputSection OS into their designated place
+// in the Sections vector, and recalculate the InputSection output section
+// offsets.
+// This may invalidate any output section offsets stored outside of InputSection
+template <class ELFT>
+static void mergeThunks(OutputSection<ELFT> *OS,
+                        std::vector<ThunkSection<ELFT> *> &Thunks) {
+  // Order Thunks in ascending OutSecOff
+  auto thunkCmp = [](const ThunkSection<ELFT> *a, const ThunkSection<ELFT> *b) {
+    return a->OutSecOff < b->OutSecOff;
+  };
+  std::stable_sort(Thunks.begin(), Thunks.end(), thunkCmp);
+
+  // Merge sorted vectors of Thunks and InputSections by OutSecOff
+  std::vector<InputSection<ELFT> *> tmp;
+  tmp.reserve(OS->Sections.size() + Thunks.size());
+  auto mergeCmp = [](const ThunkSection<ELFT> *Thunk,
+                     const InputSection<ELFT> *IS) {
+    // All thunks go before any non-executable InputSections
+    if ((IS->Flags & SHF_EXECINSTR) == 0)
+      return true;
+    // Equal Offsets to mean place Thunk before InputSection
+    return Thunk->OutSecOff <= IS->OutSecOff;
+  };
+  std::merge(OS->Sections.begin(), OS->Sections.end(), Thunks.begin(),
+             Thunks.end(), std::back_inserter(tmp), mergeCmp);
+  OS->Sections.swap(tmp);
+  OS->Size = 0;
+  OS->assignOffsets();
+}
+
+// Process all relocations from the InputSections that have been assigned
+// to OutputSections and redirect through Thunks if needed.
+//
+// createThunks must be called after scanRelocs has created the Relocations for
+// each InputSection. It must be called before the static symbol table is
+// finalized. If any Thunks are added to an OutputSection the output section
+// offsets of the InputSections will change.
+//
+// FIXME: All Thunks are assumed to be in range of the relocation. Range
+// extension Thunks are not yet supported.
 template <class ELFT>
 void createThunks(ArrayRef<OutputSectionBase *> OutputSections) {
+  // Track Symbols that already have a Thunk
+  DenseMap<SymbolBody *, Thunk<ELFT> *> ThunkedSymbols;
+  // Track InputSections that have a ThunkSection placed in front
+  DenseMap<InputSection<ELFT> *, ThunkSection<ELFT> *> ThunkedSections;
+  // Track the ThunksSections that need to be inserted into an OutputSection
+  std::map<OutputSection<ELFT> *, std::vector<ThunkSection<ELFT> *>>
+      ThunkSections;
+  
+  // Create all the Thunks and insert them into synthetic ThunkSections. The
+  // ThunkSections are later inserted back into the OutputSection.
+
+  // We separate the creation of ThunkSections from the insertion of the
+  // ThunkSections back into the OutputSection as ThunkSections are not always
+  // inserted into the same OutputSection as the caller.
   for (OutputSectionBase *Base : OutputSections) {
-    auto *OS = dyn_cast<OutputSection<ELFT>>(Base);
-    if (OS == nullptr)
-      continue;
+    if (auto *OS = dyn_cast<OutputSection<ELFT>>(Base)) {
+      ThunkSection<ELFT> *OSTS = nullptr;
       for (InputSection<ELFT> *IS : OS->Sections) {
-      for (const Relocation &Rel : IS->Relocations) {
-        if (Rel.Sym == nullptr)
-          continue;
+        for (Relocation &Rel : IS->Relocations) {
+          SymbolBody &Body = *Rel.Sym;
+          uint32_t Type = Rel.Type;
           RelExpr Expr = Rel.Expr;
-        // Some targets might require creation of thunks for relocations.
-        // Now we support only MIPS which requires LA25 thunk to call PIC
-        // code from non-PIC one, and ARM which requires interworking.
-        if (Expr == R_THUNK_ABS || Expr == R_THUNK_PC ||
-            Expr == R_THUNK_PLT_PC)
-          addThunk<ELFT>(Rel.Type, *Rel.Sym, *IS);
+          if (!isPreemptible(Body, Type) && needsPlt(Expr))
+            Expr = fromPlt(Expr);
+          if (Target->needsThunk(Expr, Type, IS->getFile(), Body)) {
+            Thunk<ELFT> *T = ThunkedSymbols.lookup(&Body);
+            if (T == nullptr) {
+              // No existing Thunk we can use, create new one
+              T = addThunk<ELFT>(Type, Body);
+              ThunkedSymbols[&Body] = T;
+              ThunkSection<ELFT> *TS = nullptr;
+              // Find a ThunkSection to place new Thunk into
+              if (auto *TIS = T->getTargetInputSection()) {
+                // Thunk must be placed before InputSection, if ThunkSection
+                // for TIS doesn't exist we must create it.
+                TS = ThunkedSections.lookup(TIS);
+                if (TS == nullptr) {
+                  auto *TOS = dyn_cast<OutputSection<ELFT>>(TIS->OutSec);
+                  TS = make<ThunkSection<ELFT>>(TOS, TIS->OutSecOff);
+                  ThunkSections[OS].push_back(TS);
+                  ThunkedSections[TIS] = TS;
+                }
+              } else {
+                // No placement restrictions insert into a ThunkSection after
+                // all other InputSections
+                if (OSTS == nullptr) {
+                  OSTS = make<ThunkSection<ELFT>>(OS, OS->Size);
+                  ThunkSections[OS].push_back(OSTS);
                 }
+                TS = OSTS;
+              }
+              TS->addThunk(T);
+            }
+
+            // Redirect relocation to Thunk, we never go via the PLT to a Thunk
+            Rel.Sym = T->ThunkSym;
+            Rel.Expr = fromPlt(Expr);
           }
         }
-  // Added thunks may affect the output section offset
-  for (OutputSectionBase *Base : OutputSections)
-    if (auto *OS = dyn_cast<OutputSection<ELFT>>(Base))
-      if (OS->Type == SHT_PROGBITS) {
-        OS->Size = 0;
-        OS->assignOffsets();
       }
     }
+  }
+
+  // Merge all created synthetic ThunkSections back into OutputSection
+  for (auto &KV : ThunkSections)
+    mergeThunks<ELFT>(KV.first, KV.second);
+}
 
 template void scanRelocations<ELF32LE>(InputSectionBase<ELF32LE> &);
 template void scanRelocations<ELF32BE>(InputSectionBase<ELF32BE> &);
 template void scanRelocations<ELF64LE>(InputSectionBase<ELF64LE> &);
 template void scanRelocations<ELF64BE>(InputSectionBase<ELF64BE> &);
 
 template void createThunks<ELF32LE>(ArrayRef<OutputSectionBase *>);
 template void createThunks<ELF32BE>(ArrayRef<OutputSectionBase *>);
 template void createThunks<ELF64LE>(ArrayRef<OutputSectionBase *>);
 template void createThunks<ELF64BE>(ArrayRef<OutputSectionBase *>);
 }
 }

ELF/SymbolTable.cpp

 // to the compiler at once, it can do whole-program optimization.
 template <class ELFT> void SymbolTable<ELFT>::addCombinedLTOObject() {
   if (BitcodeFiles.empty())
     return;
 
   // Compile bitcode files and replace bitcode symbols.
   LTO.reset(new BitcodeCompiler);
   for (BitcodeFile *F : BitcodeFiles)
-    LTO->add<ELFT>(*F);
+    LTO->add(*F);
 
   for (InputFile *File : LTO->compile()) {
     ObjectFile<ELFT> *Obj = cast<ObjectFile<ELFT>>(File);
     DenseSet<CachedHashStringRef> DummyGroups;
     Obj->parse(DummyGroups);
     ObjectFiles.push_back(Obj);
   }
 }
Symbol *SymbolTable<ELFT>::addUndefined(StringRef Name, bool IsLocal,
                                         uint8_t Type, bool CanOmitFromDynSym,
                                         InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) =
       insert(Name, Type, getVisibility(StOther), CanOmitFromDynSym, File);
   if (WasInserted) {
     S->Binding = Binding;
-    replaceBody<Undefined<ELFT>>(S, Name, IsLocal, StOther, Type, File);
+    replaceBody<Undefined>(S, Name, IsLocal, StOther, Type, File);
     return S;
   }
   if (Binding != STB_WEAK) {
     if (S->body()->isShared() || S->body()->isLazy())
       S->Binding = Binding;
     if (auto *SS = dyn_cast<SharedSymbol<ELFT>>(S->body()))
       SS->file()->IsUsed = true;
   }
void SymbolTable<ELFT>::addShared(SharedFile<ELFT> *F, StringRef Name,
   // unchanged.
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) =
       insert(Name, Sym.getType(), STV_DEFAULT, /*CanOmitFromDynSym*/ true, F);
   // Make sure we preempt DSO symbols with default visibility.
   if (Sym.getVisibility() == STV_DEFAULT)
     S->ExportDynamic = true;
-  if (WasInserted || isa<Undefined<ELFT>>(S->body())) {
+  if (WasInserted || isa<Undefined>(S->body())) {
     replaceBody<SharedSymbol<ELFT>>(S, F, Name, Sym, Verdef);
     if (!S->isWeak())
       F->IsUsed = true;
   }
 }
 
 template <class ELFT>
 Symbol *SymbolTable<ELFT>::addBitcode(StringRef Name, uint8_t Binding,

ELF/Symbols.h

public:
   bool isLocal() const { return IsLocal; }
   bool isPreemptible() const;
   StringRef getName() const { return Name; }
   uint8_t getVisibility() const { return StOther & 0x3; }
   void parseSymbolVersion();
 
   bool isInGot() const { return GotIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
-  template <class ELFT> bool hasThunk() const;
 
   template <class ELFT>
   typename ELFT::uint getVA(typename ELFT::uint Addend = 0) const;
 
   template <class ELFT> typename ELFT::uint getGotOffset() const;
   template <class ELFT> typename ELFT::uint getGotVA() const;
   template <class ELFT> typename ELFT::uint getGotPltOffset() const;
   template <class ELFT> typename ELFT::uint getGotPltVA() const;
   template <class ELFT> typename ELFT::uint getPltVA() const;
-  template <class ELFT> typename ELFT::uint getThunkVA() const;
   template <class ELFT> typename ELFT::uint getSize() const;
 
   // The file from which this symbol was created.
   InputFile *File = nullptr;
 
   uint32_t DynsymIndex = 0;
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
public:
   // The input section this symbol belongs to. Notice that this is
   // a reference to a pointer. We are using two levels of indirections
   // because of ICF. If ICF decides two sections need to be merged, it
   // manipulates this Section pointers so that they point to the same
   // section. This is a bit tricky, so be careful to not be confused.
   // If this is null, the symbol is an absolute symbol.
   InputSectionBase<ELFT> *&Section;
 
-  // If non-null the symbol has a Thunk that may be used as an alternative
-  // destination for callers of this Symbol.
-  Thunk<ELFT> *ThunkData = nullptr;
-
 private:
   static InputSectionBase<ELFT> *NullInputSection;
 };
 
 template <class ELFT>
 InputSectionBase<ELFT> *DefinedRegular<ELFT>::NullInputSection;
 
 // DefinedSynthetic is a class to represent linker-generated ELF symbols.
public:
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedSyntheticKind;
   }
 
   uint64_t Value;
   const OutputSectionBase *Section;
 };
 
-template <class ELFT> class Undefined : public SymbolBody {
+class Undefined : public SymbolBody {
 public:
   Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type,
             InputFile *F);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == UndefinedKind;
   }
 
-  // If non-null the symbol has a Thunk that may be used as an alternative
-  // destination for callers of this Symbol. When linking a DSO undefined
-  // symbols are implicitly imported, the symbol lookup will be performed by
-  // the dynamic loader. A call to an undefined symbol will be given a PLT
-  // entry and on ARM this may need a Thunk if the caller is in Thumb state.
-  Thunk<ELFT> *ThunkData = nullptr;
   InputFile *file() { return this->File; }
 };
 
 template <class ELFT> class SharedSymbol : public Defined {
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::uint uintX_t;
 
public:
   const Elf_Sym &Sym;
 
   // This field is a pointer to the symbol's version definition.
   const Elf_Verdef *Verdef;
 
   // CopyOffset is significant only when needsCopy() is true.
   uintX_t CopyOffset = 0;
 
-  // If non-null the symbol has a Thunk that may be used as an alternative
-  // destination for callers of this Symbol.
-  Thunk<ELFT> *ThunkData = nullptr;
   bool needsCopy() const { return this->NeedsCopyOrPltAddr && !this->isFunc(); }
 
   OutputSection<ELFT> *getBssSectionForCopy() const;
 };
 
 // This class represents a symbol defined in an archive file. It is
 // created from an archive file header, and it knows how to load an
 // object file from an archive to replace itself with a defined
struct Symbol {
 
   // This field is used to store the Symbol's SymbolBody. This instantiation of
   // AlignedCharArrayUnion gives us a struct with a char array field that is
   // large and aligned enough to store any derived class of SymbolBody. We
   // assume that the size and alignment of ELF64LE symbols is sufficient for any
   // ELFT, and we verify this with the static_asserts in replaceBody.
   llvm::AlignedCharArrayUnion<
       DefinedCommon, DefinedRegular<llvm::object::ELF64LE>, DefinedSynthetic,
-      Undefined<llvm::object::ELF64LE>, SharedSymbol<llvm::object::ELF64LE>,
+      Undefined, SharedSymbol<llvm::object::ELF64LE>,
       LazyArchive, LazyObject>
       Body;
 
   SymbolBody *body() { return reinterpret_cast<SymbolBody *>(Body.buffer); }
   const SymbolBody *body() const { return const_cast<Symbol *>(this)->body(); }
 };
 
 void printTraceSymbol(Symbol *Sym);
 

ELF/Symbols.cpp

if (symbol()->Visibility != STV_DEFAULT)
     return false;
 
   // -Bsymbolic means that definitions are not preempted.
   if (Config->Bsymbolic || (Config->BsymbolicFunctions && isFunc()))
     return !isDefined();
   return true;
 }
 
-template <class ELFT> bool SymbolBody::hasThunk() const {
-  if (auto *DR = dyn_cast<DefinedRegular<ELFT>>(this))
-    return DR->ThunkData != nullptr;
-  if (auto *S = dyn_cast<SharedSymbol<ELFT>>(this))
-    return S->ThunkData != nullptr;
-  return false;
-}
-
 template <class ELFT>
 typename ELFT::uint SymbolBody::getVA(typename ELFT::uint Addend) const {
   typename ELFT::uint OutVA = getSymVA<ELFT>(*this, Addend);
   return OutVA + Addend;
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotVA() const {
   return In<ELFT>::Got->getVA() + getGotOffset<ELFT>();

 
 template <class ELFT> typename ELFT::uint SymbolBody::getPltVA() const {
   if (this->IsInIplt)
     return In<ELFT>::Iplt->getVA() + PltIndex * Target->PltEntrySize;
   return In<ELFT>::Plt->getVA() + Target->PltHeaderSize +
          PltIndex * Target->PltEntrySize;
 }
 
-template <class ELFT> typename ELFT::uint SymbolBody::getThunkVA() const {
-  if (const auto *DR = dyn_cast<DefinedRegular<ELFT>>(this))
-    return DR->ThunkData->getVA();
-  if (const auto *S = dyn_cast<SharedSymbol<ELFT>>(this))
-    return S->ThunkData->getVA();
-  if (const auto *S = dyn_cast<Undefined<ELFT>>(this))
-    return S->ThunkData->getVA();
-  fatal("getThunkVA() not supported for Symbol class\n");
-}
-
 template <class ELFT> typename ELFT::uint SymbolBody::getSize() const {
   if (const auto *C = dyn_cast<DefinedCommon>(this))
     return C->Size;
   if (const auto *DR = dyn_cast<DefinedRegular<ELFT>>(this))
     return DR->Size;
   if (const auto *S = dyn_cast<SharedSymbol<ELFT>>(this))
     return S->Sym.st_size;
   return 0;

 
 template <class ELFT> bool DefinedRegular<ELFT>::isMipsPIC() const {
   if (!Section || !isFunc())
     return false;
   return (this->StOther & STO_MIPS_MIPS16) == STO_MIPS_PIC ||
          (Section->getFile()->getObj().getHeader()->e_flags & EF_MIPS_PIC);
 }
 
-template <typename ELFT>
-Undefined<ELFT>::Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther,
-                           uint8_t Type, InputFile *File)
+Undefined::Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther,
     : SymbolBody(SymbolBody::UndefinedKind, Name, IsLocal, StOther, Type) {
   this->File = File;
 }
 
 template <typename ELFT>
 OutputSection<ELFT> *SharedSymbol<ELFT>::getBssSectionForCopy() const {
   assert(needsCopy());
   return CopyIsInBssRelRo ? Out<ELFT>::BssRelRo : Out<ELFT>::Bss;

 // Returns a symbol for an error message.
 std::string lld::toString(const SymbolBody &B) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangle(B.getName()))
       return *S;
   return B.getName();
 }
 
-template bool SymbolBody::hasThunk<ELF32LE>() const;
-template bool SymbolBody::hasThunk<ELF32BE>() const;
-template bool SymbolBody::hasThunk<ELF64LE>() const;
-template bool SymbolBody::hasThunk<ELF64BE>() const;
-
 template uint32_t SymbolBody::template getVA<ELF32LE>(uint32_t) const;
 template uint32_t SymbolBody::template getVA<ELF32BE>(uint32_t) const;
 template uint64_t SymbolBody::template getVA<ELF64LE>(uint64_t) const;
 template uint64_t SymbolBody::template getVA<ELF64BE>(uint64_t) const;
 
 template uint32_t SymbolBody::template getGotVA<ELF32LE>() const;
 template uint32_t SymbolBody::template getGotVA<ELF32BE>() const;
 template uint64_t SymbolBody::template getGotVA<ELF64LE>() const;
 template uint64_t SymbolBody::template getGotVA<ELF64BE>() const;
 
 template uint32_t SymbolBody::template getGotOffset<ELF32LE>() const;
 template uint32_t SymbolBody::template getGotOffset<ELF32BE>() const;
 template uint64_t SymbolBody::template getGotOffset<ELF64LE>() const;
 template uint64_t SymbolBody::template getGotOffset<ELF64BE>() const;
 
 template uint32_t SymbolBody::template getGotPltVA<ELF32LE>() const;
 template uint32_t SymbolBody::template getGotPltVA<ELF32BE>() const;
 template uint64_t SymbolBody::template getGotPltVA<ELF64LE>() const;
 template uint64_t SymbolBody::template getGotPltVA<ELF64BE>() const;
 
-template uint32_t SymbolBody::template getThunkVA<ELF32LE>() const;
-template uint32_t SymbolBody::template getThunkVA<ELF32BE>() const;
-template uint64_t SymbolBody::template getThunkVA<ELF64LE>() const;
-template uint64_t SymbolBody::template getThunkVA<ELF64BE>() const;
-
 template uint32_t SymbolBody::template getGotPltOffset<ELF32LE>() const;
 template uint32_t SymbolBody::template getGotPltOffset<ELF32BE>() const;
 template uint64_t SymbolBody::template getGotPltOffset<ELF64LE>() const;
 template uint64_t SymbolBody::template getGotPltOffset<ELF64BE>() const;
 
 template uint32_t SymbolBody::template getPltVA<ELF32LE>() const;
 template uint32_t SymbolBody::template getPltVA<ELF32BE>() const;
 template uint64_t SymbolBody::template getPltVA<ELF64LE>() const;
 template uint64_t SymbolBody::template getPltVA<ELF64BE>() const;
 
 template uint32_t SymbolBody::template getSize<ELF32LE>() const;
 template uint32_t SymbolBody::template getSize<ELF32BE>() const;
 template uint64_t SymbolBody::template getSize<ELF64LE>() const;
 template uint64_t SymbolBody::template getSize<ELF64BE>() const;
 
-template class elf::Undefined<ELF32LE>;
-template class elf::Undefined<ELF32BE>;
-template class elf::Undefined<ELF64LE>;
-template class elf::Undefined<ELF64BE>;
-
 template class elf::SharedSymbol<ELF32LE>;
 template class elf::SharedSymbol<ELF32BE>;
 template class elf::SharedSymbol<ELF64LE>;
 template class elf::SharedSymbol<ELF64BE>;
 
 template class elf::DefinedRegular<ELF32LE>;
 template class elf::DefinedRegular<ELF32BE>;
 template class elf::DefinedRegular<ELF64LE>;
 template class elf::DefinedRegular<ELF64BE>;

ELF/SyntheticSections.h

 
 template <class ELFT> class ARMExidxSentinelSection : public SyntheticSection<ELFT> {
 public:
   ARMExidxSentinelSection();
   size_t getSize() const override { return 8; }
   void writeTo(uint8_t *Buf) override;
 };
 
+// A container for one or more linker generated thunks. Instances of these
+// thunks including ARM interworking and Mips LA25 PI to non-PI thunks.
+template <class ELFT> class ThunkSection : public SyntheticSection<ELFT> {
+public:
+  // ThunkSection in OS, with desired OutSecOff of Off
+  ThunkSection(OutputSectionBase *OS, uint64_t Off);
+  // Add a newly created Thunk to this container:
+  // Thunk is given offset from start of this InputSection
+  // Thunk defines a symbol in this InputSection that can be used as target
+  // of a relocation
+  void addThunk(Thunk<ELFT> *T);
+  size_t getSize() const { return Size; }
+  void writeTo(uint8_t *Buf) override;
+
+private:
+  std::vector<const Thunk<ELFT> *> Thunks;
+  size_t Size = 0;
+};
+
 template <class ELFT> InputSection<ELFT> *createCommonSection();
 template <class ELFT> InputSection<ELFT> *createInterpSection();
 template <class ELFT> MergeInputSection<ELFT> *createCommentSection();
 template <class ELFT>
 SymbolBody *
 addSyntheticLocal(StringRef Name, uint8_t Type, typename ELFT::uint Value,
                   typename ELFT::uint Size, InputSectionBase<ELFT> *Section);
 

ELF/SyntheticSections.cpp

void ARMExidxSentinelSection<ELFT>::writeTo(uint8_t *Buf) {
   InputSection<ELFT> *LE = *(++RI);
   InputSection<ELFT> *LC = cast<InputSection<ELFT>>(LE->getLinkOrderDep());
   uint64_t S = LC->OutSec->Addr + LC->getOffset(LC->getSize());
   uint64_t P = this->getVA();
   Target->relocateOne(Buf, R_ARM_PREL31, S - P);
   write32le(Buf + 4, 0x1);
 }
 
+template <class ELFT>
+ThunkSection<ELFT>::ThunkSection(OutputSectionBase *OS, uint64_t Off)
+    : SyntheticSection<ELFT>(SHF_ALLOC, SHT_PROGBITS,
+                             sizeof(typename ELFT::uint), ".text.thunk") {
+  this->OutSec = OS;
+  this->OutSecOff = Off;
+}
+
+template <class ELFT> void ThunkSection<ELFT>::addThunk(Thunk<ELFT> *T) {
+  uint64_t Off = alignTo(Size, T->alignment());
+  T->Offset = Off;
+  Thunks.push_back(T);
+  T->addSymbols(*this);
+  Size = Off + T->size();
+}
+
+template <class ELFT> void ThunkSection<ELFT>::writeTo(uint8_t *Buf) {
+  for (const Thunk<ELFT> *T : Thunks)
+    T->writeTo(Buf + T->Offset, *this);
+}
+
 template InputSection<ELF32LE> *elf::createCommonSection();
 template InputSection<ELF32BE> *elf::createCommonSection();
 template InputSection<ELF64LE> *elf::createCommonSection();
 template InputSection<ELF64BE> *elf::createCommonSection();
 
 template InputSection<ELF32LE> *elf::createInterpSection();
 template InputSection<ELF32BE> *elf::createInterpSection();
 template InputSection<ELF64LE> *elf::createInterpSection();

 template class elf::MipsRldMapSection<ELF32BE>;
 template class elf::MipsRldMapSection<ELF64LE>;
 template class elf::MipsRldMapSection<ELF64BE>;
 
 template class elf::ARMExidxSentinelSection<ELF32LE>;
 template class elf::ARMExidxSentinelSection<ELF32BE>;
 template class elf::ARMExidxSentinelSection<ELF64LE>;
 template class elf::ARMExidxSentinelSection<ELF64BE>;
+
+template class elf::ThunkSection<ELF32LE>;
+template class elf::ThunkSection<ELF32BE>;
+template class elf::ThunkSection<ELF64LE>;
+template class elf::ThunkSection<ELF64BE>;

ELF/Target.h

public:
   // If lazy binding is supported, the first entry of the PLT has code
   // to call the dynamic linker to resolve PLT entries the first time
   // they are called. This function writes that code.
   virtual void writePltHeader(uint8_t *Buf) const {}
 
   virtual void writePlt(uint8_t *Buf, uint64_t GotEntryAddr,
                         uint64_t PltEntryAddr, int32_t Index,
                         unsigned RelOff) const {}
-  virtual void addPltHeaderSymbols(InputSectionData* IS) const {}
-  virtual void addPltSymbols(InputSectionData* IS, uint64_t Off) const {}
+  virtual void addPltHeaderSymbols(InputSectionData *IS) const {}
+  virtual void addPltSymbols(InputSectionData *IS, uint64_t Off) const {}
   // Returns true if a relocation only uses the low bits of a value such that
   // all those bits are in in the same page. For example, if the relocation
   // only uses the low 12 bits in a system with 4k pages. If this is true, the
   // bits will always have the same value at runtime and we don't have to emit
   // a dynamic relocation.
   virtual bool usesOnlyLowPageBits(uint32_t Type) const;
 
   // Decide whether a Thunk is needed for the relocation from File
-  // targeting S. Returns one of:
-  // Expr if there is no Thunk required
-  // R_THUNK_ABS if thunk is required and expression is absolute
-  // R_THUNK_PC if thunk is required and expression is pc rel
-  // R_THUNK_PLT_PC if thunk is required to PLT entry and expression is pc rel
-  virtual RelExpr getThunkExpr(RelExpr Expr, uint32_t RelocType,
-                               const InputFile *File,
-                               const SymbolBody &S) const;
+  // targeting S.
+  virtual bool needsThunk(RelExpr Expr, uint32_t RelocType,
+                          const InputFile *File, const SymbolBody &S) const;
   virtual RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const = 0;
   virtual void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const = 0;
   virtual ~TargetInfo();
 
   unsigned TlsGdRelaxSkip = 1;
   unsigned PageSize = 4096;
   unsigned DefaultMaxPageSize = 4096;
 

ELF/Target.cpp

public:
   bool isTlsInitialExecRel(uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writeIgotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   void addPltSymbols(InputSectionData *IS, uint64_t Off) const override;
   void addPltHeaderSymbols(InputSectionData *ISD) const override;
-  RelExpr getThunkExpr(RelExpr Expr, uint32_t RelocType, const InputFile *File,
-                       const SymbolBody &S) const override;
+  bool needsThunk(RelExpr Expr, uint32_t RelocType, const InputFile *File,
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 
 template <class ELFT> class MipsTargetInfo final : public TargetInfo {
 public:
   MipsTargetInfo();
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;
   uint64_t getImplicitAddend(const uint8_t *Buf, uint32_t Type) const override;
   bool isPicRel(uint32_t Type) const override;
   uint32_t getDynRel(uint32_t Type) const override;
   bool isTlsLocalDynamicRel(uint32_t Type) const override;
   bool isTlsGlobalDynamicRel(uint32_t Type) const override;
   void writeGotPlt(uint8_t *Buf, const SymbolBody &S) const override;
   void writePltHeader(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
-  RelExpr getThunkExpr(RelExpr Expr, uint32_t RelocType, const InputFile *File,
-                       const SymbolBody &S) const override;
+  bool needsThunk(RelExpr Expr, uint32_t RelocType, const InputFile *File,
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   bool usesOnlyLowPageBits(uint32_t Type) const override;
 };
 } // anonymous namespace
 
 TargetInfo *createTarget() {
   switch (Config->EMachine) {
   case EM_386:

 
 uint64_t TargetInfo::getImplicitAddend(const uint8_t *Buf,
                                        uint32_t Type) const {
   return 0;
 }
 
 bool TargetInfo::usesOnlyLowPageBits(uint32_t Type) const { return false; }
 
-RelExpr TargetInfo::getThunkExpr(RelExpr Expr, uint32_t RelocType,
-                                 const InputFile *File,
-                                 const SymbolBody &S) const {
-  return Expr;
+bool TargetInfo::needsThunk(RelExpr Expr, uint32_t RelocType,
+                            const InputFile *File, const SymbolBody &S) const {
+  return false;
 }
 
 bool TargetInfo::isTlsInitialExecRel(uint32_t Type) const { return false; }
 
 bool TargetInfo::isTlsLocalDynamicRel(uint32_t Type) const { return false; }
 
 bool TargetInfo::isTlsGlobalDynamicRel(uint32_t Type) const { return false; }
 

 }
 
 void ARMTargetInfo::addPltSymbols(InputSectionData *ISD, uint64_t Off) const {
   auto *IS = cast<InputSection<ELF32LE>>(ISD);
   addSyntheticLocal("$a", STT_NOTYPE, Off, 0, IS);
   addSyntheticLocal("$d", STT_NOTYPE, Off + 12, 0, IS);
 }
 
-RelExpr ARMTargetInfo::getThunkExpr(RelExpr Expr, uint32_t RelocType,
-                                    const InputFile *File,
-                                    const SymbolBody &S) const {
+bool ARMTargetInfo::needsThunk(RelExpr Expr, uint32_t RelocType,
   // If S is an undefined weak symbol in an executable we don't need a Thunk.
   // In a DSO calls to undefined symbols, including weak ones get PLT entries
   // which may need a thunk.
   if (S.isUndefined() && !S.isLocal() && S.symbol()->isWeak() &&
       !Config->Shared)
-    return Expr;
+    return false;
   // A state change from ARM to Thumb and vice versa must go through an
   // interworking thunk if the relocation type is not R_ARM_CALL or
   // R_ARM_THM_CALL.
   switch (RelocType) {
   case R_ARM_PC24:
   case R_ARM_PLT32:
   case R_ARM_JUMP24:
     // Source is ARM, all PLT entries are ARM so no interworking required.
     // Otherwise we need to interwork if Symbol has bit 0 set (Thumb).
     if (Expr == R_PC && ((S.getVA<ELF32LE>() & 1) == 1))
-      return R_THUNK_PC;
+      return true;
     break;
   case R_ARM_THM_JUMP19:
   case R_ARM_THM_JUMP24:
     // Source is Thumb, all PLT entries are ARM so interworking is required.
     // Otherwise we need to interwork if Symbol has bit 0 clear (ARM).
-    if (Expr == R_PLT_PC)
-      return R_THUNK_PLT_PC;
-    if ((S.getVA<ELF32LE>() & 1) == 0)
-      return R_THUNK_PC;
+    if (Expr == R_PLT_PC || ((S.getVA<ELF32LE>() & 1) == 0))
+      return true;
     break;
   }
-  return Expr;
+  return false;
 }
 
 void ARMTargetInfo::relocateOne(uint8_t *Loc, uint32_t Type,
                                 uint64_t Val) const {
   switch (Type) {
   case R_ARM_ABS32:
   case R_ARM_BASE_PREL:
   case R_ARM_GLOB_DAT:
void MipsTargetInfo<ELFT>::writePlt(uint8_t *Buf, uint64_t GotEntryAddr,
   write32<E>(Buf + 8, isMipsR6<ELFT>() ? 0x03200009 : 0x03200008);
   write32<E>(Buf + 12, 0x25f80000); // addiu $24, $15, %lo(.got.plt entry)
   writeMipsHi16<E>(Buf, GotEntryAddr);
   writeMipsLo16<E>(Buf + 4, GotEntryAddr);
   writeMipsLo16<E>(Buf + 12, GotEntryAddr);
 }
 
 template <class ELFT>
-RelExpr MipsTargetInfo<ELFT>::getThunkExpr(RelExpr Expr, uint32_t Type,
-                                           const InputFile *File,
-                                           const SymbolBody &S) const {
+bool MipsTargetInfo<ELFT>::needsThunk(RelExpr Expr, uint32_t Type,
   // Any MIPS PIC code function is invoked with its address in register $t9.
   // So if we have a branch instruction from non-PIC code to the PIC one
   // we cannot make the jump directly and need to create a small stubs
   // to save the target function address.
   // See page 3-38 ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
   if (Type != R_MIPS_26)
-    return Expr;
+    return false;
   auto *F = dyn_cast_or_null<ELFFileBase<ELFT>>(File);
   if (!F)
-    return Expr;
+    return false;
   // If current file has PIC code, LA25 stub is not required.
   if (F->getObj().getHeader()->e_flags & EF_MIPS_PIC)
-    return Expr;
+    return false;
   auto *D = dyn_cast<DefinedRegular<ELFT>>(&S);
   // LA25 is required if target file has PIC code
   // or target symbol is a PIC symbol.
-  return D && D->isMipsPIC() ? R_THUNK_ABS : Expr;
+  return D && D->isMipsPIC();
 }
 
 template <class ELFT>
 uint64_t MipsTargetInfo<ELFT>::getImplicitAddend(const uint8_t *Buf,
                                                  uint32_t Type) const {
   const endianness E = ELFT::TargetEndianness;
   switch (Type) {
   default:

ELF/Thunks.h

 #ifndef LLD_ELF_THUNKS_H
 #define LLD_ELF_THUNKS_H
 
 #include "Relocations.h"
 
 namespace lld {
 namespace elf {
 class SymbolBody;
-template <class ELFT> class InputSection;
-
+template <class ELFT> class ThunkSection;
+class OutputSectionBase;
 // Class to describe an instance of a Thunk.
 // A Thunk is a code-sequence inserted by the linker in between a caller and
 // the callee. The relocation to the callee is redirected to the Thunk, which
 // after executing transfers control to the callee. Typical uses of Thunks
 // include transferring control from non-pi to pi and changing state on
 // targets like ARM.
 //
-// Thunks can be created for DefinedRegular and Shared Symbols. The Thunk
-// is stored in a field of the Symbol Destination.
-// Thunks to be written to an InputSection are recorded by the InputSection.
+// Thunks can be created for DefinedRegular, Shared and Undefined Symbols.
+// Thunks are assigned to synthetic ThunkSections
 template <class ELFT> class Thunk {
-  typedef typename ELFT::uint uintX_t;
-
 public:
-  Thunk(const SymbolBody &Destination, const InputSection<ELFT> &Owner);
+  Thunk(const SymbolBody &Destination);
   virtual ~Thunk();
 
   virtual uint32_t size() const { return 0; }
-  virtual void writeTo(uint8_t *Buf) const {}
-  uintX_t getVA() const;
+  virtual void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const {}
 
-protected:
+  // All Thunks must define at least one symbol ThunkSym so that we can
+  // redirect relocations to it.
+  virtual void addSymbols(ThunkSection<ELFT> &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<ELFT> *getTargetInputSection() const { return nullptr; }
+
+  // The alignment requirement for this Thunk, defaults to the size of the
+  // typical code section alignment.
+  virtual uint32_t alignment() const { return 4; }
   const SymbolBody &Destination;
-  const InputSection<ELFT> &Owner;
+  SymbolBody *ThunkSym;
   uint64_t Offset;
 };
 
-// For a Relocation to symbol S from InputSection Src, create a Thunk and
-// update the fields of S and the InputSection that the Thunk body will be
-// written to. At present there are implementations for ARM and Mips Thunks.
-template <class ELFT>
-void addThunk(uint32_t RelocType, SymbolBody &S, InputSection<ELFT> &Src);
+// 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<ELFT> *addThunk(uint32_t RelocType, SymbolBody &S);
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Thunks.cpp

 
 #include "Thunks.h"
 #include "Config.h"
 #include "Error.h"
 #include "InputSection.h"
 #include "Memory.h"
 #include "OutputSections.h"
 #include "Symbols.h"
+#include "SyntheticSections.h"
 #include "Target.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include <cstdint>
 #include <cstring>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 
 namespace lld {
 namespace elf {
 
 namespace {
 
 // Specific ARM Thunk implementations. The naming convention is:
 // Source State, TargetState, Target Requirement, ABS or PI, Range
 template <class ELFT>
 class ARMToThumbV7ABSLongThunk final : public Thunk<ELFT> {
 public:
-  ARMToThumbV7ABSLongThunk(const SymbolBody &Dest,
-                           const InputSection<ELFT> &Owner)
-      : Thunk<ELFT>(Dest, Owner) {}
+  ARMToThumbV7ABSLongThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {}
 
   uint32_t size() const override { return 12; }
-  void writeTo(uint8_t *Buf) const override;
+  void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
+  void addSymbols(ThunkSection<ELFT> &IS) override;
 };
 
 template <class ELFT> class ARMToThumbV7PILongThunk final : public Thunk<ELFT> {
 public:
-  ARMToThumbV7PILongThunk(const SymbolBody &Dest,
-                          const InputSection<ELFT> &Owner)
-      : Thunk<ELFT>(Dest, Owner) {}
+  ARMToThumbV7PILongThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {}
 
   uint32_t size() const override { return 16; }
-  void writeTo(uint8_t *Buf) const override;
+  void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
+  void addSymbols(ThunkSection<ELFT> &IS) override;
 };
 
 template <class ELFT>
 class ThumbToARMV7ABSLongThunk final : public Thunk<ELFT> {
 public:
-  ThumbToARMV7ABSLongThunk(const SymbolBody &Dest,
-                           const InputSection<ELFT> &Owner)
-      : Thunk<ELFT>(Dest, Owner) {}
+  ThumbToARMV7ABSLongThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {}
 
   uint32_t size() const override { return 10; }
-  void writeTo(uint8_t *Buf) const override;
+  void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
+  void addSymbols(ThunkSection<ELFT> &IS) override;
+  uint32_t alignment() const override { return 2; }
 };
 
 template <class ELFT> class ThumbToARMV7PILongThunk final : public Thunk<ELFT> {
 public:
-  ThumbToARMV7PILongThunk(const SymbolBody &Dest,
-                          const InputSection<ELFT> &Owner)
-      : Thunk<ELFT>(Dest, Owner) {}
+  ThumbToARMV7PILongThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {}
 
   uint32_t size() const override { return 12; }
-  void writeTo(uint8_t *Buf) const override;
+  void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
+  void addSymbols(ThunkSection<ELFT> &IS) override;
+  uint32_t alignment() const override { return 2; }
 };
 
 // MIPS LA25 thunk
 template <class ELFT> class MipsThunk final : public Thunk<ELFT> {
 public:
-  MipsThunk(const SymbolBody &Dest, const InputSection<ELFT> &Owner)
-      : Thunk<ELFT>(Dest, Owner) {}
+  MipsThunk(const SymbolBody &Dest) : Thunk<ELFT>(Dest) {}
 
   uint32_t size() const override { return 16; }
-  void writeTo(uint8_t *Buf) const override;
+  void writeTo(uint8_t *Buf, ThunkSection<ELFT> &IS) const override;
+  void addSymbols(ThunkSection<ELFT> &IS) override;
+  InputSection<ELFT> *getTargetInputSection() const override;
 };
 
 } // end anonymous namespace
 
 // ARM Target Thunks
 template <class ELFT> static uint64_t getARMThunkDestVA(const SymbolBody &S) {
   uint64_t V = S.isInPlt() ? S.getPltVA<ELFT>() : S.getVA<ELFT>();
   return SignExtend64<32>(V);
 }
 
 template <class ELFT>
-void ARMToThumbV7ABSLongThunk<ELFT>::writeTo(uint8_t *Buf) const {
+void ARMToThumbV7ABSLongThunk<ELFT>::writeTo(uint8_t *Buf,
+                                             ThunkSection<ELFT> &IS) const {
   const uint8_t Data[] = {
       0x00, 0xc0, 0x00, 0xe3, // movw         ip,:lower16:S
       0x00, 0xc0, 0x40, 0xe3, // movt         ip,:upper16:S
       0x1c, 0xff, 0x2f, 0xe1, // bx   ip
   };
   uint64_t S = getARMThunkDestVA<ELFT>(this->Destination);
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_MOVW_ABS_NC, S);
   Target->relocateOne(Buf + 4, R_ARM_MOVT_ABS, S);
 }
 
 template <class ELFT>
-void ThumbToARMV7ABSLongThunk<ELFT>::writeTo(uint8_t *Buf) const {
+void ARMToThumbV7ABSLongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
+  this->ThunkSym = addSyntheticLocal(
+      Saver.save("__ARMToThumbv7ABSLongThunk_" + this->Destination.getName()),
+      STT_FUNC, this->Offset, size(), &IS);
+  addSyntheticLocal("$a", STT_NOTYPE, this->Offset, 0, &IS);
+}
+
+template <class ELFT>
+void ThumbToARMV7ABSLongThunk<ELFT>::writeTo(uint8_t *Buf,
+                                             ThunkSection<ELFT> &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<ELFT>(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 ARMToThumbV7PILongThunk<ELFT>::writeTo(uint8_t *Buf) const {
+void ThumbToARMV7ABSLongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
+  this->ThunkSym = addSyntheticLocal(
+      Saver.save("__ThumbToARMv7ABSLongThunk_" + this->Destination.getName()),
+      STT_FUNC, this->Offset, size(), &IS);
+  addSyntheticLocal("$t", STT_NOTYPE, this->Offset, 0, &IS);
+}
+
+template <class ELFT>
+void ARMToThumbV7PILongThunk<ELFT>::writeTo(uint8_t *Buf,
+                                            ThunkSection<ELFT> &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<ELFT>(this->Destination);
-  uint64_t P = this->getVA();
+  uint64_t P = this->ThunkSym->template getVA<ELFT>();
   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 ThumbToARMV7PILongThunk<ELFT>::writeTo(uint8_t *Buf) const {
+void ARMToThumbV7PILongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
+  this->ThunkSym = addSyntheticLocal(
+      Saver.save("__ARMToThumbV7PILongThunk_" + this->Destination.getName()),
+      STT_FUNC, this->Offset, size(), &IS);
+  addSyntheticLocal("$a", STT_NOTYPE, this->Offset, 0, &IS);
+}
+
+template <class ELFT>
+void ThumbToARMV7PILongThunk<ELFT>::writeTo(uint8_t *Buf,
+                                            ThunkSection<ELFT> &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<ELFT>(this->Destination);
-  uint64_t P = this->getVA();
+  uint64_t P = this->ThunkSym->template getVA<ELFT>();
   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 ThumbToARMV7PILongThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
+  this->ThunkSym = addSyntheticLocal(
+      Saver.save("__ThumbToARMV7PILongThunk_" + this->Destination.getName()),
+      STT_FUNC, this->Offset, size(), &IS);
+  addSyntheticLocal("$t", STT_NOTYPE, this->Offset, 0, &IS);
+}
+
 // Write MIPS LA25 thunk code to call PIC function from the non-PIC one.
-template <class ELFT> void MipsThunk<ELFT>::writeTo(uint8_t *Buf) const {
+template <class ELFT>
+void MipsThunk<ELFT>::writeTo(uint8_t *Buf, ThunkSection<ELFT> &) const {
   const endianness E = ELFT::TargetEndianness;
 
   uint64_t S = this->Destination.template getVA<ELFT>();
   write32<E>(Buf, 0x3c190000);                // lui   $25, %hi(func)
   write32<E>(Buf + 4, 0x08000000 | (S >> 2)); // j     func
   write32<E>(Buf + 8, 0x27390000);            // addiu $25, $25, %lo(func)
   write32<E>(Buf + 12, 0x00000000);           // nop
   Target->relocateOne(Buf, R_MIPS_HI16, S);
   Target->relocateOne(Buf + 8, R_MIPS_LO16, S);
 }
 
-template <class ELFT>
-Thunk<ELFT>::Thunk(const SymbolBody &D, const InputSection<ELFT> &O)
-    : Destination(D), Owner(O), Offset(O.getThunkOff() + O.getThunksSize()) {}
+template <class ELFT> void MipsThunk<ELFT>::addSymbols(ThunkSection<ELFT> &IS) {
+  this->ThunkSym = addSyntheticLocal(
+      Saver.save("__LA25Thunk_" + this->Destination.getName()), STT_FUNC,
+      this->Offset, size(), &IS);
+}
 
-template <class ELFT> typename ELFT::uint Thunk<ELFT>::getVA() const {
-  return Owner.OutSec->Addr + Owner.OutSecOff + Offset;
+template <class ELFT>
+InputSection<ELFT> *MipsThunk<ELFT>::getTargetInputSection() const {
+  auto *DR = dyn_cast<DefinedRegular<ELFT>>(&this->Destination);
+  return dyn_cast<InputSection<ELFT>>(DR->Section);
 }
 
+template <class ELFT>
+Thunk<ELFT>::Thunk(const SymbolBody &D) : Destination(D), Offset(0) {}
+
 template <class ELFT> Thunk<ELFT>::~Thunk() = default;
 
 // Creates a thunk for Thumb-ARM interworking.
 template <class ELFT>
-static Thunk<ELFT> *createThunkArm(uint32_t Reloc, SymbolBody &S,
-                                   InputSection<ELFT> &IS) {
+static Thunk<ELFT> *addThunkArm(uint32_t Reloc, SymbolBody &S) {
   // ARM relocations need ARM to Thumb interworking Thunks.
   // Thumb relocations need Thumb to ARM relocations.
   // Use position independent Thunks if we require position independent code.
   switch (Reloc) {
   case R_ARM_PC24:
   case R_ARM_PLT32:
   case R_ARM_JUMP24:
     if (Config->Pic)
-      return new (BAlloc) ARMToThumbV7PILongThunk<ELFT>(S, IS);
-    return new (BAlloc) ARMToThumbV7ABSLongThunk<ELFT>(S, IS);
+      return make<ARMToThumbV7PILongThunk<ELFT>>(S);
+    return make<ARMToThumbV7ABSLongThunk<ELFT>>(S);
   case R_ARM_THM_JUMP19:
   case R_ARM_THM_JUMP24:
     if (Config->Pic)
-      return new (BAlloc) ThumbToARMV7PILongThunk<ELFT>(S, IS);
-    return new (BAlloc) ThumbToARMV7ABSLongThunk<ELFT>(S, IS);
+      return make<ThumbToARMV7PILongThunk<ELFT>>(S);
+    return make<ThumbToARMV7ABSLongThunk<ELFT>>(S);
   }
   fatal("unrecognized relocation type");
 }
 
-template <class ELFT>
-static void addThunkARM(uint32_t Reloc, SymbolBody &S, InputSection<ELFT> &IS) {
-  // Only one Thunk supported per symbol.
-  if (S.hasThunk<ELFT>())
-    return;
-
-  // ARM Thunks are added to the same InputSection as the relocation. This
-  // isn't strictly necessary but it makes it more likely that a limited range
-  // branch can reach the Thunk, and it makes Thunks to the PLT section easier
-  Thunk<ELFT> *T = createThunkArm(Reloc, S, IS);
-  IS.addThunk(T);
-  if (auto *Sym = dyn_cast<DefinedRegular<ELFT>>(&S))
-    Sym->ThunkData = T;
-  else if (auto *Sym = dyn_cast<SharedSymbol<ELFT>>(&S))
-    Sym->ThunkData = T;
-  else if (auto *Sym = dyn_cast<Undefined<ELFT>>(&S))
-    Sym->ThunkData = T;
-  else
-    fatal("symbol not DefinedRegular or Shared");
-}
-
-template <class ELFT>
-static void addThunkMips(uint32_t RelocType, SymbolBody &S,
-                         InputSection<ELFT> &IS) {
-  // Only one Thunk supported per symbol.
-  if (S.hasThunk<ELFT>())
-    return;
-
-  // Mips Thunks are added to the InputSection defining S.
-  auto *R = cast<DefinedRegular<ELFT>>(&S);
-  auto *Sec = cast<InputSection<ELFT>>(R->Section);
-  auto *T = new (BAlloc) MipsThunk<ELFT>(S, *Sec);
-  Sec->addThunk(T);
-  R->ThunkData = T;
+template <class ELFT> static Thunk<ELFT> *addThunkMips(SymbolBody &S) {
+  return make<MipsThunk<ELFT>>(S);
 }
 
-template <class ELFT>
-void addThunk(uint32_t RelocType, SymbolBody &S, InputSection<ELFT> &IS) {
+template <class ELFT> Thunk<ELFT> *addThunk(uint32_t RelocType, SymbolBody &S) {
   if (Config->EMachine == EM_ARM)
-    addThunkARM<ELFT>(RelocType, S, IS);
+    return addThunkArm<ELFT>(RelocType, S);
   else if (Config->EMachine == EM_MIPS)
-    addThunkMips<ELFT>(RelocType, S, IS);
+    return addThunkMips<ELFT>(S);
   else
     llvm_unreachable("add Thunk only supported for ARM and Mips");
+  return nullptr;
 }
 
-template void addThunk<ELF32LE>(uint32_t, SymbolBody &,
-                                InputSection<ELF32LE> &);
-template void addThunk<ELF32BE>(uint32_t, SymbolBody &,
-                                InputSection<ELF32BE> &);
-template void addThunk<ELF64LE>(uint32_t, SymbolBody &,
-                                InputSection<ELF64LE> &);
-template void addThunk<ELF64BE>(uint32_t, SymbolBody &,
-                                InputSection<ELF64BE> &);
+template Thunk<ELF32LE> *addThunk<ELF32LE>(uint32_t, SymbolBody &);
+template Thunk<ELF32BE> *addThunk<ELF32BE>(uint32_t, SymbolBody &);
+template Thunk<ELF64LE> *addThunk<ELF64LE>(uint32_t, SymbolBody &);
+template Thunk<ELF64BE> *addThunk<ELF64BE>(uint32_t, SymbolBody &);
 
 template class Thunk<ELF32LE>;
 template class Thunk<ELF32BE>;
 template class Thunk<ELF64LE>;
 template class Thunk<ELF64BE>;
 
 } // end namespace elf
 } // end namespace lld

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // we can correctly decide if a dynamic relocation is needed.
   forEachRelSec(scanRelocations<ELFT>);
 
   if (In<ELFT>::Plt && !In<ELFT>::Plt->empty())
     In<ELFT>::Plt->addSymbols();
   if (In<ELFT>::Iplt && !In<ELFT>::Iplt->empty())
     In<ELFT>::Iplt->addSymbols();
 
+  // Some architectures use small displacements for jump instructions.
+  // It is linker's responsibility to create thunks containing long
+  // jump instructions if jump targets are too far. Create thunks.
+  if (Target->NeedsThunks)
+    createThunks<ELFT>(OutputSections);
+
   // Now that we have defined all possible symbols including linker-
   // synthesized ones. Visit all symbols to give the finishing touches.
   for (Symbol *S : Symtab<ELFT>::X->getSymbols()) {
     SymbolBody *Body = S->body();
 
     if (!includeInSymtab<ELFT>(*Body))
       continue;
     if (In<ELFT>::SymTab)
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // image base and the dynamic section on mips includes the image base.
   if (!Config->Relocatable && !Config->OFormatBinary) {
     Phdrs = Script<ELFT>::X->hasPhdrsCommands() ? Script<ELFT>::X->createPhdrs()
                                                 : createPhdrs();
     addPtArmExid(Phdrs);
     fixHeaders();
   }
 
-  // Some architectures use small displacements for jump instructions.
-  // It is linker's responsibility to create thunks containing long
-  // jump instructions if jump targets are too far. Create thunks.
-  if (Target->NeedsThunks)
-    createThunks<ELFT>(OutputSections);
-
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections.
   for (OutputSectionBase *Sec : OutputSections)
     Sec->finalize();
 
   // Dynamic section must be the last one in this list and dynamic
   // symbol table section (DynSymTab) must be the first one.

test/ELF/arm-thumb-interwork-shared.s

  b.w elsewhere
  b.w weakref
 
 // Check that we generate a thunk for an undefined symbol called via a plt
 // entry.
 
 // CHECK: Disassembly of section .text:
 // CHECK-NEXT: sym1:
-// CHECK:          1000:       00 f0 02 b8     b.w     #4
-// CHECK-NEXT:     1004:       00 f0 06 b8     b.w     #12
+// CHECK-NEXT: 1000: 00 f0 02 b8 b.w #4 <__ThumbToARMV7PILongThunk_elsewhere+0x4>
+// CHECK-NEXT: 1004: 00 f0 06 b8 b.w #12 <__ThumbToARMV7PILongThunk_weakref+0x4>
+// CHECK: __ThumbToARMV7PILongThunk_elsewhere:
 // CHECK-NEXT:     1008:       40 f2 20 0c     movw    r12, #32
 // CHECK-NEXT:     100c:       c0 f2 00 0c     movt    r12, #0
 // CHECK-NEXT:     1010:       fc 44   add     r12, pc
 // CHECK-NEXT:     1012:       60 47   bx      r12
+
+// CHECK: __ThumbToARMV7PILongThunk_weakref:
 // CHECK-NEXT:     1014:       40 f2 24 0c     movw    r12, #36
 // CHECK-NEXT:     1018:       c0 f2 00 0c     movt    r12, #0
 // CHECK-NEXT:     101c:       fc 44   add     r12, pc
 // CHECK-NEXT:     101e:       60 47   bx      r12
 
 // PLT: Disassembly of section .plt:
 // PLT: $a:
 // PLT-NEXT:     1020:       04 e0 2d e5     str     lr, [sp, #-4]!

test/ELF/arm-thumb-interwork-thunk.s

  // There can be more than one thunk associated with a section
  b thumb_callee2
  b thumb_callee3
  // In range ARM targets do not require interworking thunks
  b arm_callee1
  beq arm_callee2
  bne arm_callee3
  bx lr
-// CHECK-ABS-ARM: Disassembly of section .arm_caller:
-// CHECK-ABS-ARM-NEXT: arm_caller:
-// CHECK-ABS-ARM-NEXT: 1300:       3e ff ff fa     blx     #-776 <thumb_callee1>
-// CHECK-ABS-ARM-NEXT: 1304:       3d ff ff fa     blx     #-780 <thumb_callee1>
-// CHECK-ABS-ARM-NEXT: 1308:       06 00 00 ea     b       #24 <arm_caller+0x28>
-// CHECK-ABS-ARM-NEXT: 130c:       05 00 00 ea     b       #20 <arm_caller+0x28>
-// CHECK-ABS-ARM-NEXT: 1310:       07 00 00 ea     b       #28 <arm_caller+0x34>
-// CHECK-ABS-ARM-NEXT: 1314:       09 00 00 ea     b       #36 <arm_caller+0x40>
-// CHECK-ABS-ARM-NEXT: 1318:       78 ff ff ea     b       #-544 <arm_callee1>
-// CHECK-ABS-ARM-NEXT: 131c:       b7 00 00 0a     beq     #732 <arm_callee2>
-// CHECK-ABS-ARM-NEXT: 1320:       b7 00 00 1a     bne     #732 <arm_callee3>
-// CHECK-ABS-ARM-NEXT: 1324:       1e ff 2f e1     bx      lr
+// CHECK-ARM-ABS-ARM: Disassembly of section .arm_caller:
+// CHECK-ARM-ABS-ARM-NEXT: arm_caller:
+// CHECK-ARM-ABS-ARM-NEXT:     1300:       3e ff ff fa     blx     #-776 <thumb_callee1>
+// CHECK-ARM-ABS-ARM-NEXT:     1304:       3d ff ff fa     blx     #-780 <thumb_callee1>
+// CHECK-ARM-ABS-ARM-NEXT:     1308:       06 00 00 ea     b       #24 <__ARMToThumbv7ABSLongThunk_thumb_callee1>
+// CHECK-ARM-ABS-ARM-NEXT:     130c:       05 00 00 ea     b       #20 <__ARMToThumbv7ABSLongThunk_thumb_callee1>
+// CHECK-ARM-ABS-ARM-NEXT:     1310:       07 00 00 ea     b       #28 <__ARMToThumbv7ABSLongThunk_thumb_callee2>
+// CHECK-ARM-ABS-ARM-NEXT:     1314:       09 00 00 ea     b       #36 <__ARMToThumbv7ABSLongThunk_thumb_callee3>
+// CHECK-ARM-ABS-ARM-NEXT:     1318:       78 ff ff ea     b       #-544 <arm_callee1>
+// CHECK-ARM-ABS-ARM-NEXT:     131c:       b7 00 00 0a     beq     #732 <arm_callee2>
+// CHECK-ARM-ABS-ARM-NEXT:     1320:       b7 00 00 1a     bne     #732 <arm_callee3>
+// CHECK-ARM-ABS-ARM-NEXT:     1324:       1e ff 2f e1     bx      lr
+// CHECK-ARM-ABS-ARM: __ARMToThumbv7ABSLongThunk_thumb_callee1:
 // 0x1001 = thumb_callee1
-// CHECK-ABS-ARM-NEXT: 1328:       01 c0 01 e3     movw    r12, #4097
-// CHECK-ABS-ARM-NEXT: 132c:       00 c0 40 e3     movt    r12, #0
-// CHECK-ABS-ARM-NEXT: 1330:       1c ff 2f e1     bx      r12
+// CHECK-ARM-ABS-ARM-NEXT:     1328:       01 c0 01 e3     movw    r12, #4097
+// CHECK-ARM-ABS-ARM-NEXT:     132c:       00 c0 40 e3     movt    r12, #0
+// CHECK-ARM-ABS-ARM-NEXT:     1330:       1c ff 2f e1     bx      r12
 // 0x1501 = thumb_callee2
-// CHECK-ABS-ARM-NEXT: 1334:       01 c5 01 e3     movw    r12, #5377
-// CHECK-ABS-ARM-NEXT: 1338:       00 c0 40 e3     movt    r12, #0
-// CHECK-ABS-ARM-NEXT: 133c:       1c ff 2f e1     bx      r12
+// CHECK-ARM-ABS-ARM: __ARMToThumbv7ABSLongThunk_thumb_callee2:
+// CHECK-ARM-ABS-ARM-NEXT:     1334:       01 c5 01 e3     movw    r12, #5377
+// CHECK-ARM-ABS-ARM-NEXT:     1338:       00 c0 40 e3     movt    r12, #0
+// CHECK-ARM-ABS-ARM-NEXT:     133c:       1c ff 2f e1     bx      r12
 // 0x1503 = thumb_callee3
-// CHECK-ABS-ARM-NEXT: 1340:       03 c5 01 e3     movw    r12, #5379
-// CHECK-ABS-ARM-NEXT: 1344:       00 c0 40 e3     movt    r12, #0
-// CHECK-ABS-ARM-NEXT: 1348:       1c ff 2f e1     bx      r12
+// CHECK-ARM-ABS-ARM: __ARMToThumbv7ABSLongThunk_thumb_callee3:
+// CHECK-ARM-ABS-ARM-NEXT:     1340:       03 c5 01 e3     movw    r12, #5379
+// CHECK-ARM-ABS-ARM-NEXT:     1344:       00 c0 40 e3     movt    r12, #0
+// CHECK-ARM-ABS-ARM-NEXT:     1348:       1c ff 2f e1     bx      r12
 
 // CHECK-PI-ARM: Disassembly of section .arm_caller:
 // CHECK-PI-ARM-NEXT: arm_caller:
-// CHECK-PI-ARM-NEXT: 1300:       3e ff ff fa     blx     #-776 <thumb_callee1>
-// CHECK-PI-ARM-NEXT: 1304:       3d ff ff fa     blx     #-780 <thumb_callee1>
-// 0x1308 + 8 + 0x18 = 0x1328
-// CHECK-PI-ARM-NEXT: 1308:       06 00 00 ea     b       #24 <arm_caller+0x28>
-// 0x130c + 8 + 0x14 = 0x1328
-// CHECK-PI-ARM-NEXT: 130c:       05 00 00 ea     b       #20 <arm_caller+0x28>
-// 0x1310 + 8 + 0x20 = 0x1338
-// CHECK-PI-ARM-NEXT: 1310:       08 00 00 ea     b       #32 <arm_caller+0x38>
-// 0x1314 + 8 + 0x2c = 0x1348
-// CHECK-PI-ARM-NEXT: 1314:       0b 00 00 ea     b       #44 <arm_caller+0x48>
-// CHECK-PI-ARM-NEXT: 1318:       78 ff ff ea     b       #-544 <arm_callee1>
-// CHECK-PI-ARM-NEXT: 131c:       b7 00 00 0a     beq     #732 <arm_callee2>
-// CHECK-PI-ARM-NEXT: 1320:       b7 00 00 1a     bne     #732 <arm_callee3>
-// CHECK-PI-ARM-NEXT: 1324:       1e ff 2f e1     bx      lr
+// CHECK-PI-ARM-NEXT:     1300:       3e ff ff fa     blx     #-776 <thumb_callee1>
+// CHECK-PI-ARM-NEXT:     1304:       3d ff ff fa     blx     #-780 <thumb_callee1>
+// CHECK-PI-ARM-NEXT:     1308:       06 00 00 ea     b       #24 <__ARMToThumbV7PILongThunk_thumb_callee1>
+// CHECK-PI-ARM-NEXT:     130c:       05 00 00 ea     b       #20 <__ARMToThumbV7PILongThunk_thumb_callee1>
+// CHECK-PI-ARM-NEXT:     1310:       08 00 00 ea     b       #32 <__ARMToThumbV7PILongThunk_thumb_callee2>
+// CHECK-PI-ARM-NEXT:     1314:       0b 00 00 ea     b       #44 <__ARMToThumbV7PILongThunk_thumb_callee3>
+// CHECK-PI-ARM-NEXT:     1318:       78 ff ff ea     b       #-544 <arm_callee1>
+// CHECK-PI-ARM-NEXT:     131c:       b7 00 00 0a     beq     #732 <arm_callee2>
+// CHECK-PI-ARM-NEXT:     1320:       b7 00 00 1a     bne     #732 <arm_callee3>
+// CHECK-PI-ARM-NEXT:     1324:       1e ff 2f e1     bx      lr
+// CHECK-PI-ARM: __ARMToThumbV7PILongThunk_thumb_callee1:
 // 0x1330 + 8 - 0x337 = 0x1001 = thumb_callee1
-// CHECK-PI-ARM-NEXT: 1328:       c9 cc 0f e3     movw    r12, #64713
-// CHECK-PI-ARM-NEXT: 132c:       ff cf 4f e3     movt    r12, #65535
-// CHECK-PI-ARM-NEXT: 1330:       0f c0 8c e0     add     r12, r12, pc
-// CHECK-PI-ARM-NEXT: 1334:       1c ff 2f e1     bx      r12
-// 0x1340 + 8 + 0x1b9 = 0x1501
-// CHECK-PI-ARM-NEXT: 1338:       b9 c1 00 e3     movw    r12, #441
-// CHECK-PI-ARM-NEXT: 133c:       00 c0 40 e3     movt    r12, #0
-// CHECK-PI-ARM-NEXT: 1340:       0f c0 8c e0     add     r12, r12, pc
-// CHECK-PI-ARM-NEXT: 1344:       1c ff 2f e1     bx      r12
-// 1350 + 8 + 0x1ab = 0x1503
-// CHECK-PI-ARM-NEXT: 1348:       ab c1 00 e3     movw    r12, #427
-// CHECK-PI-ARM-NEXT: 134c:       00 c0 40 e3     movt    r12, #0
-// CHECK-PI-ARM-NEXT: 1350:       0f c0 8c e0     add     r12, r12, pc
-// CHECK-PI-ARM-NEXT: 1354:       1c ff 2f e1     bx      r12
+// CHECK-PI-ARM-NEXT:     1328:       c9 cc 0f e3     movw    r12, #64713
+// CHECK-PI-ARM-NEXT:     132c:       ff cf 4f e3     movt    r12, #65535
+// CHECK-PI-ARM-NEXT:     1330:       0f c0 8c e0     add     r12, r12, pc
+// CHECK-PI-ARM-NEXT:     1334:       1c ff 2f e1     bx      r12
+// CHECK-PI-ARM: __ARMToThumbV7PILongThunk_thumb_callee2:
+
+// CHECK-PI-ARM-NEXT:     1338:       b9 c1 00 e3     movw    r12, #441
+// CHECK-PI-ARM-NEXT:     133c:       00 c0 40 e3     movt    r12, #0
+// CHECK-PI-ARM-NEXT:     1340:       0f c0 8c e0     add     r12, r12, pc
+// CHECK-PI-ARM-NEXT:     1344:       1c ff 2f e1     bx      r12
+// CHECK-PI-ARM: __ARMToThumbV7PILongThunk_thumb_callee3:
+// 0x1340 + 8 + 0x1b9 = 0x1501
+// CHECK-PI-ARM-NEXT:     1348:       ab c1 00 e3     movw    r12, #427
+// CHECK-PI-ARM-NEXT:     134c:       00 c0 40 e3     movt    r12, #0
+// CHECK-PI-ARM-NEXT:     1350:       0f c0 8c e0     add     r12, r12, pc
+// CHECK-PI-ARM-NEXT:     1354:       1c ff 2f e1     bx      r12
+// 1350 + 8 + 0x1ab = 0x1503
 
 // All PLT entries are ARM, no need for interworking thunks
 // CHECK-PI-ARM-PLT: Disassembly of section .arm_caller:
 // CHECK-PI-ARM-PLT-NEXT: arm_caller:
 // 0x17e4 PLT(thumb_callee1)
 // CHECK-PI-ARM-PLT-NEXT:    1300:       37 01 00 eb     bl      #1244
 // 0x17e4 PLT(thumb_callee1)
 // CHECK-PI-ARM-PLT-NEXT:    1304:       36 01 00 eb     bl      #1240

  b.w arm_callee3
  // Conditional branches also require interworking thunks, they can use the
  // same interworking thunks.
  beq.w arm_callee1
  beq.w arm_callee2
  bne.w arm_callee3
 // CHECK-ABS-THUMB: Disassembly of section .thumb_caller:
 // CHECK-ABS-THUMB-NEXT: thumb_caller:
-// 0x1400 + 4 - 0x304 = 0x1100 = arm_callee1
-// CHECK-ABS-THUMB-NEXT: 1400:       ff f7 7e ee     blx     #-772
-// 0x1404 + 4 - 0x308 = 0x1100 = arm_callee1
-// CHECK-ABS-THUMB-NEXT: 1404:       ff f7 7c ee     blx     #-776
-// 0x1408 + 4 + 0x14 = 0x520
-// CHECK-ABS-THUMB-NEXT: 1408:       00 f0 0a b8     b.w     #20
-// 0x140c + 4 + 0x1a = 0x52a
-// CHECK-ABS-THUMB-NEXT: 140c:       00 f0 0d b8     b.w     #26
-// 0x1410 + 4 + 0x20 = 0x534
-// CHECK-ABS-THUMB-NEXT: 1410:       00 f0 10 b8     b.w     #32
-// 0x1414 + 4 + 8 = 0x520
-// CHECK-ABS-THUMB-NEXT: 1414:       00 f0 04 80     beq.w   #8
-// 0x1418 + 4 + 0xe = 0x52a
-// CHECK-ABS-THUMB-NEXT: 1418:       00 f0 07 80     beq.w   #14
-// 0x141c + 4 + 0x14 = 0x534
-// CHECK-ABS-THUMB-NEXT: 141c:       40 f0 0a 80     bne.w   #20
+// CHECK-ABS-THUMB-NEXT:     1400:       ff f7 7e ee     blx     #-772
+// CHECK-ABS-THUMB-NEXT:     1404:       ff f7 7c ee     blx     #-776
+// CHECK-ABS-THUMB-NEXT:     1408:       00 f0 0a b8     b.w     #20 <__ThumbToARMv7ABSLongThunk_arm_callee1+0x4>
+// CHECK-ABS-THUMB-NEXT:     140c:       00 f0 0d b8     b.w     #26 <__ThumbToARMv7ABSLongThunk_arm_callee2+0x4>
+// CHECK-ABS-THUMB-NEXT:     1410:       00 f0 10 b8     b.w     #32 <__ThumbToARMv7ABSLongThunk_arm_callee3+0x4>
+// CHECK-ABS-THUMB-NEXT:     1414:       00 f0 04 80     beq.w   #8 <__ThumbToARMv7ABSLongThunk_arm_callee1+0x4>
+// CHECK-ABS-THUMB-NEXT:     1418:       00 f0 07 80     beq.w   #14 <__ThumbToARMv7ABSLongThunk_arm_callee2+0x4>
+// CHECK-ABS-THUMB-NEXT:     141c:       40 f0 0a 80     bne.w   #20 <__ThumbToARMv7ABSLongThunk_arm_callee3+0x4>
+// CHECK-ABS-THUMB: __ThumbToARMv7ABSLongThunk_arm_callee1:
 // 0x1100 = arm_callee1
-// CHECK-ABS-THUMB-NEXT: 1420:       41 f2 00 1c     movw    r12, #4352
-// CHECK-ABS-THUMB-NEXT: 1424:       c0 f2 00 0c     movt    r12, #0
-// CHECK-ABS-THUMB-NEXT: 1428:       60 47   bx      r12
+// CHECK-ABS-THUMB-NEXT:     1420:       41 f2 00 1c     movw    r12, #4352
+// CHECK-ABS-THUMB-NEXT:     1424:       c0 f2 00 0c     movt    r12, #0
+// CHECK-ABS-THUMB-NEXT:     1428:       60 47   bx      r12
+// CHECK-ABS-THUMB: __ThumbToARMv7ABSLongThunk_arm_callee2:
 // 0x1600 = arm_callee2
-// CHECK-ABS-THUMB-NEXT: 142a:       41 f2 00 6c     movw    r12, #5632
-// CHECK-ABS-THUMB-NEXT: 142e:       c0 f2 00 0c     movt    r12, #0
-// CHECK-ABS-THUMB-NEXT: 1432:       60 47   bx      r12
+// CHECK-ABS-THUMB-NEXT:     142a:       41 f2 00 6c     movw    r12, #5632
+// CHECK-ABS-THUMB-NEXT:     142e:       c0 f2 00 0c     movt    r12, #0
+// CHECK-ABS-THUMB-NEXT:     1432:       60 47   bx      r12
 // 0x1604 = arm_callee3
-// CHECK-ABS-THUMB-NEXT: 1434:       41 f2 04 6c     movw    r12, #5636
-// CHECK-ABS-THUMB-NEXT: 1438:       c0 f2 00 0c     movt    r12, #0
-// CHECK-ABS-THUMB-NEXT: 143c:       60 47   bx      r12
+// CHECK-ABS-THUMB: __ThumbToARMv7ABSLongThunk_arm_callee3:
+// CHECK-ABS-THUMB-NEXT:     1434:   41 f2 04 6c     movw    r12, #5636
+// CHECK-ABS-THUMB-NEXT:     1438:       c0 f2 00 0c     movt    r12, #0
+// CHECK-ABS-THUMB-NEXT:     143c:       60 47   bx      r12
 
 // CHECK-PI-THUMB: Disassembly of section .thumb_caller:
 // CHECK-PI-THUMB-NEXT: thumb_caller:
-// CHECK-PI-THUMB-NEXT: 1400:       ff f7 7e ee     blx     #-772
-// CHECK-PI-THUMB-NEXT: 1404:       ff f7 7c ee     blx     #-776
-// CHECK-PI-THUMB-NEXT: 1408:       00 f0 0a b8     b.w     #20
-// CHECK-PI-THUMB-NEXT: 140c:       00 f0 0e b8     b.w     #28
-// CHECK-PI-THUMB-NEXT: 1410:       00 f0 12 b8     b.w     #36
-// CHECK-PI-THUMB-NEXT: 1414:       00 f0 04 80     beq.w   #8
-// CHECK-PI-THUMB-NEXT: 1418:       00 f0 08 80     beq.w   #16
-// CHECK-PI-THUMB-NEXT: 141c:       40 f0 0c 80     bne.w   #24
+// CHECK-PI-THUMB-NEXT:     1400:       ff f7 7e ee     blx     #-772
+// CHECK-PI-THUMB-NEXT:     1404:       ff f7 7c ee     blx     #-776
+// CHECK-PI-THUMB-NEXT:     1408:       00 f0 0a b8     b.w     #20 <__ThumbToARMV7PILongThunk_arm_callee1+0x4>
+// CHECK-PI-THUMB-NEXT:     140c:       00 f0 0e b8     b.w     #28 <__ThumbToARMV7PILongThunk_arm_callee2+0x4>
+// CHECK-PI-THUMB-NEXT:     1410:       00 f0 12 b8     b.w     #36 <__ThumbToARMV7PILongThunk_arm_callee3+0x4>
+// CHECK-PI-THUMB-NEXT:     1414:       00 f0 04 80     beq.w   #8 <__ThumbToARMV7PILongThunk_arm_callee1+0x4>
+// CHECK-PI-THUMB-NEXT:     1418:       00 f0 08 80     beq.w   #16 <__ThumbToARMV7PILongThunk_arm_callee2+0x4>
+// CHECK-PI-THUMB-NEXT:     141c:       40 f0 0c 80     bne.w   #24 <__ThumbToARMV7PILongThunk_arm_callee3+0x4>
+// CHECK-PI-THUMB: __ThumbToARMV7PILongThunk_arm_callee1:
 // 0x1428 + 4 - 0x32c = 0x1100 = arm_callee1
-// CHECK-PI-THUMB-NEXT: 1420:       4f f6 d4 4c     movw    r12, #64724
-// CHECK-PI-THUMB-NEXT: 1424:       cf f6 ff 7c     movt    r12, #65535
-// CHECK-PI-THUMB-NEXT: 1428:       fc 44   add     r12, pc
-// CHECK-PI-THUMB-NEXT: 142a:       60 47   bx      r12
+// CHECK-PI-THUMB-NEXT:     1420:       4f f6 d4 4c     movw    r12, #64724
+// CHECK-PI-THUMB-NEXT:     1424:       cf f6 ff 7c     movt    r12, #65535
+// CHECK-PI-THUMB-NEXT:     1428:       fc 44   add     r12, pc
+// CHECK-PI-THUMB-NEXT:     142a:       60 47   bx      r12
+// CHECK-PI-THUMB: __ThumbToARMV7PILongThunk_arm_callee2:
 // 0x1434 + 4 + 0x1c8 = 0x1600 = arm_callee2
-// CHECK-PI-THUMB-NEXT: 142c:       40 f2 c8 1c     movw    r12, #456
-// CHECK-PI-THUMB-NEXT: 1430:       c0 f2 00 0c     movt    r12, #0
-// CHECK-PI-THUMB-NEXT: 1434:       fc 44   add     r12, pc
-// CHECK-PI-THUMB-NEXT: 1436:       60 47   bx      r12
+// CHECK-PI-THUMB-NEXT:     142c:       40 f2 c8 1c     movw    r12, #456
+// CHECK-PI-THUMB-NEXT:     1430:       c0 f2 00 0c     movt    r12, #0
+// CHECK-PI-THUMB-NEXT:     1434:       fc 44   add     r12, pc
+// CHECK-PI-THUMB-NEXT:     1436:       60 47   bx      r12
+// CHECK-PI-THUMB: __ThumbToARMV7PILongThunk_arm_callee3:
 // 0x1440 + 4 + 0x1c0 = 0x1604 = arm_callee3
-// CHECK-PI-THUMB-NEXT: 1438:       40 f2 c0 1c     movw    r12, #448
-// CHECK-PI-THUMB-NEXT: 143c:       c0 f2 00 0c     movt    r12, #0
-// CHECK-PI-THUMB-NEXT: 1440:       fc 44   add     r12, pc
-// CHECK-PI-THUMB-NEXT: 1442:       60 47   bx      r12
+// CHECK-PI-THUMB-NEXT:     1438:       40 f2 c0 1c     movw    r12, #448
+// CHECK-PI-THUMB-NEXT:     143c:       c0 f2 00 0c     movt    r12, #0
+// CHECK-PI-THUMB-NEXT:     1440:       fc 44   add     r12, pc
+// CHECK-PI-THUMB-NEXT:     1442:       60 47   bx      r12
 
 // CHECK-PI-THUMB-PLT: Disassembly of section .arm_caller:
 // CHECK-PI-THUMB-PLT-NEXT: thumb_caller:
 // 0x1400 + 4 + 0x410 = 0x1814 = PLT(arm_callee1)
 // CHECK-PI-THUMB-PLT-NEXT:    1400:    00 f0 08 ea     blx     #1040
 // 0x1404 + 4 + 0x40c = 0x1814 = PLT(arm_callee1)
 // CHECK-PI-THUMB-PLT-NEXT:    1404:    00 f0 06 ea     blx     #1036
 // 0x1408 + 4 + 0x14 = 0x1420 = IWV(PLT(arm_callee1)

test/ELF/mips-npic-call-pic.s

 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-pic.s -o %t-pic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t-npic.o
 # RUN: ld.lld %t-npic.o %t-pic.o %t-sto-pic.o -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck %s
 
 # CHECK:     Disassembly of section .text:
 # CHECK-NEXT: __start:
-# CHECK-NEXT:    20000:       0c 00 80 0e     jal     131128 <foo1b+0x4>
-#                                                            ^-- .pic.foo1a
+# CHECK-NEXT:    20000:       0c 00 80 0c     jal     131120 <__LA25Thunk_foo1a>
 # CHECK-NEXT:    20004:       00 00 00 00     nop
-# CHECK-NEXT:    20008:       0c 00 80 19     jal     131172 <foo2+0x4>
-#                                                            ^-- .pic.foo2
+# CHECK-NEXT:    20008:       0c 00 80 16     jal     131160 <__LA25Thunk_foo2>
 # CHECK-NEXT:    2000c:       00 00 00 00     nop
-# CHECK-NEXT:    20010:       0c 00 80 12     jal     131144 <foo1b+0x14>
-#                                                            ^-- .pic.foo1b
+# CHECK-NEXT:    20010:       0c 00 80 10     jal     131136 <__LA25Thunk_foo1b>
 # CHECK-NEXT:    20014:       00 00 00 00     nop
-# CHECK-NEXT:    20018:       0c 00 80 19     jal     131172 <foo2+0x4>
-#                                                            ^-- .pic.foo2
+# CHECK-NEXT:    20018:       0c 00 80 16     jal     131160 <__LA25Thunk_foo2>
 # CHECK-NEXT:    2001c:       00 00 00 00     nop
-# CHECK-NEXT:    20020:       0c 00 80 25     jal     131220 <fnpic+0x4>
-#                                                            ^-- .pic.fpic
+# CHECK-NEXT:    20020:       0c 00 80 1d     jal     131188 <__LA25Thunk_fpic>
 # CHECK-NEXT:    20024:       00 00 00 00     nop
-# CHECK-NEXT:    20028:       0c 00 80 24     jal     131216 <fnpic>
+# CHECK-NEXT:    20028:       0c 00 80 28     jal     131232 <fnpic>
 # CHECK-NEXT:    2002c:       00 00 00 00     nop
 #
-# CHECK:      foo1a:
-# CHECK-NEXT:    20030:       00 00 00 00     nop
-#
-# CHECK:      foo1b:
-# CHECK-NEXT:    20034:       00 00 00 00     nop
-#
-# CHECK-NEXT:    20038:       3c 19 00 02     lui     $25, 2
-# CHECK-NEXT:    2003c:       08 00 80 0c     j       131120 <foo1a>
-# CHECK-NEXT:    20040:       27 39 00 30     addiu   $25, $25, 48
-# CHECK-NEXT:    20044:       00 00 00 00     nop
-# CHECK-NEXT:    20048:       3c 19 00 02     lui     $25, 2
-# CHECK-NEXT:    2004c:       08 00 80 0d     j       131124 <foo1b>
-# CHECK-NEXT:    20050:       27 39 00 34     addiu   $25, $25, 52
+# CHECK: __LA25Thunk_foo1a:
+# CHECK-NEXT:    20030:       3c 19 00 02     lui     $25, 2
+# CHECK-NEXT:    20034:       08 00 80 14     j       131152 <foo1a>
+# CHECK-NEXT:    20038:       27 39 00 50     addiu   $25, $25, 80
+# CHECK-NEXT:    2003c:       00 00 00 00     nop
+
+# CHECK: __LA25Thunk_foo1b:
+# CHECK-NEXT:    20040:       3c 19 00 02     lui     $25, 2
+# CHECK-NEXT:    20044:       08 00 80 15     j       131156 <foo1b>
+# CHECK-NEXT:    20048:       27 39 00 54     addiu   $25, $25, 84
+# CHECK-NEXT:    2004c:       00 00 00 00     nop
+
+# CHECK: foo1a:
+# CHECK-NEXT:    20050:       00 00 00 00     nop
+
+# CHECK: foo1b:
 # CHECK-NEXT:    20054:       00 00 00 00     nop
-# CHECK-NEXT:    20058:       00 00 00 00     nop
-# CHECK-NEXT:    2005c:       00 00 00 00     nop
-#
-# CHECK:      foo2:
-# CHECK-NEXT:    20060:       00 00 00 00     nop
-#
-# CHECK-NEXT:    20064:       3c 19 00 02     lui     $25, 2
-# CHECK-NEXT:    20068:       08 00 80 18     j       131168 <foo2>
-# CHECK-NEXT:    2006c:       27 39 00 60     addiu   $25, $25, 96
+
+# CHECK: __LA25Thunk_foo2:
+# CHECK-NEXT:    20058:       3c 19 00 02     lui     $25, 2
+# CHECK-NEXT:    2005c:       08 00 80 1c     j       131184 <foo2>
+# CHECK-NEXT:    20060:       27 39 00 70     addiu   $25, $25, 112
+# CHECK-NEXT:    20064:       00 00 00 00     nop
+# CHECK-NEXT:    20068:       00 00 00 00     nop
+# CHECK-NEXT:    2006c:       00 00 00 00     nop
+
+# CHECK: foo2:
 # CHECK-NEXT:    20070:       00 00 00 00     nop
-# CHECK-NEXT:    20074:       00 00 00 00     nop
-# CHECK-NEXT:    20078:       00 00 00 00     nop
-# CHECK-NEXT:    2007c:       00 00 00 00     nop
-#
-# CHECK:       fpic:
-# CHECK-NEXT:    20080:       00 00 00 00     nop
-#
-# CHECK:       fnpic:
+
+# CHECK: __LA25Thunk_fpic:
+# CHECK-NEXT:    20074:       3c 19 00 02     lui     $25, 2
+# CHECK-NEXT:    20078:       08 00 80 24     j       131216 <fpic>
+# CHECK-NEXT:    2007c:       27 39 00 90     addiu   $25, $25, 144
+# CHECK-NEXT:    20080:       00 00 00 00     nop
+# CHECK-NEXT:    20084:       00 00 00 00     nop
+# CHECK-NEXT:    20088:       00 00 00 00     nop
+# CHECK-NEXT:    2008c:       00 00 00 00     nop
+
+# CHECK: fpic:
 # CHECK-NEXT:    20090:       00 00 00 00     nop
-# CHECK-NEXT:    20094:       3c 19 00 02     lui     $25, 2
-# CHECK-NEXT:    20098:       08 00 80 20     j       131200 <fpic>
-# CHECK-NEXT:    2009c:       27 39 00 80     addiu   $25, $25, 128
+# CHECK-NEXT:    20094:       00 00 00 00     nop
+# CHECK-NEXT:    20098:       00 00 00 00     nop
+# CHECK-NEXT:    2009c:       00 00 00 00     nop
+
+# CHECK: fnpic:
+# CHECK-NEXT:    200a0:       00 00 00 00     nop
 
 # Make sure the thunks are created properly no matter how
 # objects are laid out.
 #
 # RUN: ld.lld %t-pic.o %t-npic.o %t-sto-pic.o -o %t.exe
 # RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=REVERSE %s
 
-# REVERSE:      foo1a:
-# REVERSE-NEXT:    20000:       00 00 00 00     nop
-#
-# REVERSE:      foo1b:
-# REVERSE-NEXT:    20004:       00 00 00 00     nop
-# REVERSE-NEXT:    20008:       3c 19 00 02     lui     $25, 2
-# REVERSE-NEXT:    2000c:       08 00 80 00     j       131072 <foo1a>
-# REVERSE-NEXT:    20010:       27 39 00 00     addiu   $25, $25, 0
-# REVERSE-NEXT:    20014:       00 00 00 00     nop
-# REVERSE-NEXT:    20018:       3c 19 00 02     lui     $25, 2
-# REVERSE-NEXT:    2001c:       08 00 80 01     j       131076 <foo1b>
-# REVERSE-NEXT:    20020:       27 39 00 04     addiu   $25, $25, 4
+# REVERSE: Disassembly of section .text:
+# REVERSE-NEXT: __LA25Thunk_foo1a:
+# REVERSE-NEXT:    20000:       3c 19 00 02     lui     $25, 2
+# REVERSE-NEXT:    20004:       08 00 80 08     j       131104 <foo1a>
+# REVERSE-NEXT:    20008:       27 39 00 20     addiu   $25, $25, 32
+# REVERSE-NEXT:    2000c:       00 00 00 00     nop
+# REVERSE: __LA25Thunk_foo1b:
+# REVERSE-NEXT:    20010:       3c 19 00 02     lui     $25, 2
+# REVERSE-NEXT:    20014:       08 00 80 09     j       131108 <foo1b>
+# REVERSE-NEXT:    20018:       27 39 00 24     addiu   $25, $25, 36
+# REVERSE-NEXT:    2001c:       00 00 00 00     nop
+# REVERSE: foo1a:
+# REVERSE-NEXT:    20020:       00 00 00 00     nop
+# REVERSE: foo1b:
 # REVERSE-NEXT:    20024:       00 00 00 00     nop
-# REVERSE-NEXT:    20028:       00 00 00 00     nop
-# REVERSE-NEXT:    2002c:       00 00 00 00     nop
-#
-# REVERSE:      foo2:
-# REVERSE-NEXT:    20030:       00 00 00 00     nop
-# REVERSE-NEXT:    20034:       3c 19 00 02     lui     $25, 2
-# REVERSE-NEXT:    20038:       08 00 80 0c     j       131120 <foo2>
-# REVERSE-NEXT:    2003c:       27 39 00 30     addiu   $25, $25, 48
+# REVERSE: __LA25Thunk_foo2:
+# REVERSE-NEXT:    20028:       3c 19 00 02     lui     $25, 2
+# REVERSE-NEXT:    2002c:       08 00 80 10     j       131136 <foo2>
+# REVERSE-NEXT:    20030:       27 39 00 40     addiu   $25, $25, 64
+# REVERSE-NEXT:    20034:       00 00 00 00     nop
+# REVERSE-NEXT:    20038:       00 00 00 00     nop
+# REVERSE-NEXT:    2003c:       00 00 00 00     nop
+# REVERSE: foo2:
 # REVERSE-NEXT:    20040:       00 00 00 00     nop
 # REVERSE-NEXT:    20044:       00 00 00 00     nop
 # REVERSE-NEXT:    20048:       00 00 00 00     nop
 # REVERSE-NEXT:    2004c:       00 00 00 00     nop
-#
-# REVERSE:      __start:
-# REVERSE-NEXT:    20050:       0c 00 80 02     jal     131080 <foo1b+0x4>
+# REVERSE: __start:
+# REVERSE-NEXT:    20050:       0c 00 80 00     jal     131072 <__LA25Thunk_foo1a>
 # REVERSE-NEXT:    20054:       00 00 00 00     nop
-# REVERSE-NEXT:    20058:       0c 00 80 0d     jal     131124 <foo2+0x4>
+# REVERSE-NEXT:    20058:       0c 00 80 0a     jal     131112 <__LA25Thunk_foo2>
 # REVERSE-NEXT:    2005c:       00 00 00 00     nop
-# REVERSE-NEXT:    20060:       0c 00 80 06     jal     131096 <foo1b+0x14>
+# REVERSE-NEXT:    20060:       0c 00 80 04     jal     131088 <__LA25Thunk_foo1b>
 # REVERSE-NEXT:    20064:       00 00 00 00     nop
-# REVERSE-NEXT:    20068:       0c 00 80 0d     jal     131124 <foo2+0x4>
+# REVERSE-NEXT:    20068:       0c 00 80 0a     jal     131112 <__LA25Thunk_foo2>
 # REVERSE-NEXT:    2006c:       00 00 00 00     nop
-# REVERSE-NEXT:    20070:       0c 00 80 25     jal     131220 <fnpic+0x4>
+# REVERSE-NEXT:    20070:       0c 00 80 20     jal     131200 <__LA25Thunk_fpic>
 # REVERSE-NEXT:    20074:       00 00 00 00     nop
-# REVERSE-NEXT:    20078:       0c 00 80 24     jal     131216 <fnpic>
+# REVERSE-NEXT:    20078:       0c 00 80 28     jal     131232 <fnpic>
 # REVERSE-NEXT:    2007c:       00 00 00 00     nop
-#
-# REVERSE:       fpic:
-# REVERSE-NEXT:    20080:       00 00 00 00     nop
-#
-# REVERSE:       fnpic:
+# REVERSE: __LA25Thunk_fpic:
+# REVERSE-NEXT:    20080:       3c 19 00 02     lui     $25, 2
+# REVERSE-NEXT:    20084:       08 00 80 24     j       131216 <fpic>
+# REVERSE-NEXT:    20088:       27 39 00 90     addiu   $25, $25, 144
+# REVERSE-NEXT:    2008c:       00 00 00 00     nop
+# REVERSE: fpic:
 # REVERSE-NEXT:    20090:       00 00 00 00     nop
-# REVERSE-NEXT:    20094:       3c 19 00 02     lui     $25, 2
-# REVERSE-NEXT:    20098:       08 00 80 20     j       131200 <fpic>
-# REVERSE-NEXT:    2009c:       27 39 00 80     addiu   $25, $25, 128
+# REVERSE-NEXT:    20094:       00 00 00 00     nop
+# REVERSE-NEXT:    20098:       00 00 00 00     nop
+# REVERSE-NEXT:    2009c:       00 00 00 00     nop
+# REVERSE: fnpic:
+# REVERSE-NEXT:    200a0:       00 00 00 00     nop
 
   .text
   .globl __start
 __start:
   jal foo1a
   jal foo2
   jal foo1b
   jal foo2
   jal fpic
   jal fnpic