[PPC64] Position-dependent long-branch thunks.

[sfertile]

Summary

This adds a new '.branch_lt' synthetic section, which is used to store the target addresses for the thunks.
The thunk itself is almost exactly the same as the position-independent long-branch thunks except the target address goes into the new section and no dynamic relocation is needed.

[sfertile]

ping

[sfertile]

Abandoned in favor of [[ https://reviews.llvm.org/D53408 | [PPC64] Long branch thunks. ]]

ELF/InputSection.cpp

if (!SymVA)
       return 0;
 
     // PPC64 V2 ABI describes two entry points to a function. The global entry
     // point sets up the TOC base pointer. When calling a local function, the
     // call should branch to the local entry point rather than the global entry
     // point. Section 3.4.1 describes using the 3 most significant bits of the
     // st_other field to find out how many instructions there are between the
     // local and global entry point.
-    uint8_t StOther = (Sym.StOther >> 5) & 7;
-    if (StOther == 0 || StOther == 1)
-      return SymVA - P;
-
-    return SymVA - P + (1LL << StOther);
+    uint32_t LocalEntryOffset =
+        (Config->EMachine == EM_PPC64) ? getPPC64LocalEntryOffset(Sym) : 0;
+    return (SymVA + LocalEntryOffset) - P;
   }
   case R_PPC_TOC:
     return getPPC64TocBase() + A;
   case R_RELAX_GOT_PC:
     return Sym.getVA(A) - P;
   case R_RELAX_TLS_GD_TO_LE:
   case R_RELAX_TLS_IE_TO_LE:
   case R_RELAX_TLS_LD_TO_LE:

ELF/Symbols.h

public:
   uint64_t getGotVA() const;
   uint64_t getGotPltOffset() const;
   uint64_t getGotPltVA() const;
   uint64_t getPltVA() const;
   uint64_t getPltOffset() const;
   uint64_t getSize() const;
   uint64_t getLongBranchGotPltOffset() const;
   uint64_t getLongBranchGotPltVA() const;
+  uint64_t getLongBranchTableVA() const;
+
   OutputSection *getOutputSection() const;
 
 protected:
   Symbol(Kind K, InputFile *File, StringRefZ Name, uint8_t Binding,
          uint8_t StOther, uint8_t Type)
       : File(File), NameData(Name.Data), NameSize(Name.Size), Binding(Binding),
         Type(Type), StOther(StOther), SymbolKind(K), NeedsPltAddr(false),
         IsInIplt(false), IsInIgot(false), IsPreemptible(false),
void replaceSymbol(Symbol *S, ArgT &&... Arg) {
 
   // Print out a log message if --trace-symbol was specified.
   // This is for debugging.
   if (S->Traced)
     printTraceSymbol(S);
 }
 
 void warnUnorderableSymbol(const Symbol *Sym);
+
+// Functions in the PPC64 V2 abi can have 2 entry points, one global and
+// and one local. This calculates the offset from the global entry-point to the
+// local entry-point. If the function has a single entry point, the offset is 0.
+uint32_t getPPC64LocalEntryOffset(const Symbol &Func);
 } // namespace elf
 
 std::string toString(const elf::Symbol &B);
 } // namespace lld
 
 #endif

ELF/Symbols.cpp

uint64_t Symbol::getLongBranchGotPltOffset() const {
   return (Target->GotPltHeaderEntriesNum + LongBranchTargetIndex) *
          Target->GotPltEntrySize;
 }
 
 uint64_t Symbol::getLongBranchGotPltVA() const {
   return InX::GotPlt->getVA() + getLongBranchGotPltOffset();
 }
 
+uint64_t Symbol::getLongBranchTableVA() const {
+  assert(isLongBranchTarget());
+  return InX::LongBranchTarget->getVA() + LongBranchTargetIndex * 8;
+}
+
 uint64_t Symbol::getSize() const {
   if (const auto *DR = dyn_cast<Defined>(this))
     return DR->Size;
   return cast<SharedSymbol>(this)->Size;
 }
 
 OutputSection *Symbol::getOutputSection() const {
   if (auto *S = dyn_cast<Defined>(this)) {
void elf::warnUnorderableSymbol(const Symbol *Sym) {
   else if (D && !D->Section)
     Warn(": unable to order absolute symbol: ");
   else if (D && isa<OutputSection>(D->Section))
     Warn(": unable to order synthetic symbol: ");
   else if (D && !D->Section->Repl->Live)
     Warn(": unable to order discarded symbol: ");
 }
 
+uint32_t lld::elf::getPPC64LocalEntryOffset(const Symbol &Func) {
+  assert(Config->EMachine == EM_PPC64);
+
+  uint8_t LocalEntryShift = (Func.StOther >> 5);
+  assert(LocalEntryShift != 7); // Reserved value.
+
+  // 0 or 1 indicates the function has a single entry point.
+  if (LocalEntryShift == 0 || LocalEntryShift == 1)
+    return 0;
+
+  return 1 << LocalEntryShift;
+}
+
 // Returns a symbol for an error message.
 std::string lld::toString(const Symbol &B) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangleItanium(B.getName()))
       return *S;
   return B.getName();
 }

ELF/SyntheticSections.h

public:
   void postThunkContents() override;
 
 private:
   std::vector<const Symbol *> Entries;
   int LongBranchTargets = 0;
   bool PostThunk = false;
 };
 
+class LongBranchTargetSection final : public SyntheticSection {
+public:
+  LongBranchTargetSection();
+  void addEntry(Symbol &Sym);
+  size_t getSize() const override;
+  void writeTo(uint8_t *Buf) override;
+  bool empty() const override;
+  void postThunkContents(void) override { PostThunk = true; }
+
+private:
+  std::vector<const Symbol *> Entries;
+  bool PostThunk = false;
+};
+
 // The IgotPltSection is a Got associated with the PltSection for GNU Ifunc
 // Symbols that will be relocated by Target->IRelativeRel.
 // On most Targets the IgotPltSection will immediately follow the GotPltSection
 // on ARM the IgotPltSection will immediately follow the GotSection.
 class IgotPltSection final : public SyntheticSection {
 public:
   IgotPltSection();
   void addEntry(Symbol &Sym);
struct InX {
   static PltSection *Iplt;
   static RelocationBaseSection *RelaDyn;
   static RelrBaseSection *RelrDyn;
   static RelocationBaseSection *RelaPlt;
   static RelocationBaseSection *RelaIplt;
   static StringTableSection *ShStrTab;
   static StringTableSection *StrTab;
   static SymbolTableBaseSection *SymTab;
+  static LongBranchTargetSection *LongBranchTarget;
 };
 
 template <class ELFT> struct In {
   static VersionDefinitionSection<ELFT> *VerDef;
   static VersionTableSection<ELFT> *VerSym;
   static VersionNeedSection<ELFT> *VerNeed;
 };
 
 template <class ELFT> VersionDefinitionSection<ELFT> *In<ELFT>::VerDef;
 template <class ELFT> VersionTableSection<ELFT> *In<ELFT>::VerSym;
 template <class ELFT> VersionNeedSection<ELFT> *In<ELFT>::VerNeed;
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/SyntheticSections.cpp

 
 void IgotPltSection::writeTo(uint8_t *Buf) {
   for (const Symbol *B : Entries) {
     Target->writeIgotPlt(Buf, *B);
     Buf += Config->Wordsize;
   }
 }
 
+LongBranchTargetSection::LongBranchTargetSection()
+    : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS, 8, ".branch_lt") {}
+
+void LongBranchTargetSection::addEntry(Symbol &Sym) {
+  assert(!Sym.isLongBranchTarget());
+  Sym.LongBranchTargetIndex = Entries.size();
+  Entries.push_back(&Sym);
+}
+
+size_t LongBranchTargetSection::getSize() const { return Entries.size() * 8; }
+
+void LongBranchTargetSection::writeTo(uint8_t *Buf) {
+  for (const Symbol *Sym : Entries) {
+    assert(Sym->getVA());
+    write64(Buf, Sym->getVA() + getPPC64LocalEntryOffset(*Sym));
+    Buf += 8;
+  }
+}
+
+bool LongBranchTargetSection::empty() const {
+  return PostThunk && Entries.size() == 0;
+}
+
 StringTableSection::StringTableSection(StringRef Name, bool Dynamic)
     : SyntheticSection(Dynamic ? (uint64_t)SHF_ALLOC : 0, SHT_STRTAB, 1, Name),
       Dynamic(Dynamic) {
   // ELF string tables start with a NUL byte.
   addString("");
 }
 
 // Adds a string to the string table. If HashIt is true we hash and check for

 PltSection *InX::Iplt;
 RelocationBaseSection *InX::RelaDyn;
 RelrBaseSection *InX::RelrDyn;
 RelocationBaseSection *InX::RelaPlt;
 RelocationBaseSection *InX::RelaIplt;
 StringTableSection *InX::ShStrTab;
 StringTableSection *InX::StrTab;
 SymbolTableBaseSection *InX::SymTab;
+LongBranchTargetSection *InX::LongBranchTarget;
 
 template GdbIndexSection *GdbIndexSection::create<ELF32LE>();
 template GdbIndexSection *GdbIndexSection::create<ELF32BE>();
 template GdbIndexSection *GdbIndexSection::create<ELF64LE>();
 template GdbIndexSection *GdbIndexSection::create<ELF64BE>();
 
 template void elf::splitSections<ELF32LE>();
 template void elf::splitSections<ELF32BE>();

ELF/Thunks.cpp

 // have plt stubs), the local entry point is used as the branch target.
 class PPC64PILongBranchThunk final : public Thunk {
 public:
   PPC64PILongBranchThunk(Symbol &Dest) : Thunk(Dest) {
     assert(!Dest.IsPreemptible);
     if (!Dest.isLongBranchTarget()) {
       InX::GotPlt->addLongBranch(Dest);
 
-      uint32_t LocalEntryOffset = 0;
-      uint8_t Shift = (Dest.StOther >> 5) & 7;
-      if (Shift > 1)
-        LocalEntryOffset = 1 << Shift;
-
+      uint32_t LocalEntryOffset = getPPC64LocalEntryOffset(Dest);
       InX::RelaDyn->addReloc({Target->RelativeRel, InX::GotPlt,
                               Dest.getLongBranchGotPltOffset(), true, &Dest,
                               LocalEntryOffset});
     }
   }
   uint32_t size() override { return 16; }
   void writeTo(uint8_t *Buf) override;
   void addSymbols(ThunkSection &IS) override;
 };
 
+// Long branch thunks when linking position dependent code. The branch target
+// address (local entry point of the callee) is placed into the the '.branch_lt'
+// section. No dynamic relocations are needed, since the branch target is a link
+// time constant.
+class PPC64LongBranchThunk final : public Thunk {
+public:
+  PPC64LongBranchThunk(Symbol &Dest) : Thunk(Dest) {
+    if (!Dest.isLongBranchTarget())
+      InX::LongBranchTarget->addEntry(Dest);
+  }
+
+  uint32_t size() override { return 16; }
+  void writeTo(uint8_t *Buf) override;
+  void addSymbols(ThunkSection &IS) override;
+};
+
 } // end anonymous namespace
 
 Defined *Thunk::addSymbol(StringRef Name, uint8_t Type, uint64_t Value,
                           InputSectionBase &Section) {
   Defined *D = addSyntheticLocal(Name, Type, Value, /*Size=*/0, Section);
   Syms.push_back(D);
   return D;
 }
void PPC64PILongBranchThunk::writeTo(uint8_t *Buf) {
   writePPCLoadAndBranch(Buf, Offset);
 }
 
 void PPC64PILongBranchThunk::addSymbols(ThunkSection &IS) {
   addSymbol(Saver.save("__long_branch_" + Destination.getName()), STT_FUNC, 0,
             IS);
 }
 
+void PPC64LongBranchThunk::writeTo(uint8_t *Buf) {
+  int64_t Off = Destination.getLongBranchTableVA() - getPPC64TocBase();
+  writePPCLoadAndBranch(Buf, Off);
+}
+
+void PPC64LongBranchThunk::addSymbols(ThunkSection & IS) {
+  addSymbol(Saver.save("__long_branch_" + Destination.getName()), STT_FUNC, 0,
+            IS);
+}
+
 Thunk::Thunk(Symbol &D) : Destination(D), Offset(0) {}
 
 Thunk::~Thunk() = default;
 
 static Thunk *addThunkAArch64(RelType Type, Symbol &S) {
   if (Type != R_AARCH64_CALL26 && Type != R_AARCH64_JUMP26)
     fatal("unrecognized relocation type");
   if (Config->Pic)

 
 static Thunk *addThunkPPC64(RelType Type, Symbol &S) {
   if (Type == R_PPC64_REL24) {
     if (S.isInPlt())
       return make<PPC64PltCallStub>(S);
 
    if (Config->Pic)
      return make<PPC64PILongBranchThunk>(S);
-   else
-     fatal("Position dependant long_branch thunks not implemented yet!");
+   return make<PPC64LongBranchThunk>(S);
   }
   fatal("unexpected relocation type");
 }
 
 Thunk *addThunk(RelType Type, Symbol &S) {
   if (Config->EMachine == EM_AARCH64)
     return addThunkAArch64(Type, S);
 

ELF/Writer.cpp

template <class ELFT> static void createSyntheticSections() {
   if (Config->EMachine == EM_MIPS) {
     InX::MipsGot = make<MipsGotSection>();
     Add(InX::MipsGot);
   } else {
     InX::Got = make<GotSection>();
     Add(InX::Got);
   }
 
+  // If we are linking position-independent code then long branch targets
+  // go into the GotPlt, otherwise they go into the LongBranchTarget section.
+  if (Config->EMachine == EM_PPC64 && !Config->Pic) {
+    InX::LongBranchTarget = make<LongBranchTargetSection>();
+    Add(InX::LongBranchTarget);
+  }
+
   InX::GotPlt = make<GotPltSection>();
   Add(InX::GotPlt);
   InX::IgotPlt = make<IgotPltSection>();
   Add(InX::IgotPlt);
 
   if (Config->GdbIndex) {
     InX::GdbIndex = GdbIndexSection::create<ELFT>();
     Add(InX::GdbIndex);
do {
         InX::MipsGot->updateAllocSize();
       Changed |= InX::RelaDyn->updateAllocSize();
       if (InX::RelrDyn)
         Changed |= InX::RelrDyn->updateAllocSize();
     } while (Changed);
   }
 
   // createThunks may have added local symbols to the static symbol table
-  applySynthetic({InX::GotPlt, InX::SymTab},
-                 [](SyntheticSection *SS) { SS->postThunkContents(); });
+  applySynthetic({InX::LongBranchTarget, InX::GotPlt, InX::SymTab},
+                 [](SyntheticSection *SS) { if (SS) SS->postThunkContents(); });
+
 
   // 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 (OutputSection *Sec : OutputSections)
     Sec->finalize<ELFT>();
 }
 

test/ELF/basic64be.s

 # CHECK-NEXT:     ABIVersion: 0
 # CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Type: Executable (0x2)
 # CHECK-NEXT:   Machine: EM_PPC64 (0x15)
 # CHECK-NEXT:   Version: 1
 # CHECK-NEXT:   Entry: 0x10010000
 # CHECK-NEXT:   ProgramHeaderOffset: 0x40
-# CHECK-NEXT:   SectionHeaderOffset: 0x11050
+# CHECK-NEXT:   SectionHeaderOffset: 0x20058
 # CHECK-NEXT:   Flags [ (0x2)
 # CHECK-NEXT:     0x2
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   HeaderSize: 64
 # CHECK-NEXT:   ProgramHeaderEntrySize: 56
 # CHECK-NEXT:   ProgramHeaderCount: 4
 # CHECK-NEXT:   SectionHeaderEntrySize: 64
-# CHECK-NEXT:   SectionHeaderCount: 6
-# CHECK-NEXT:   StringTableSectionIndex: 4
+# CHECK-NEXT:   SectionHeaderCount: 7
+# CHECK-NEXT:   StringTableSectionIndex: 5
 # CHECK-NEXT: }
 # CHECK-NEXT: Sections [
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 0
 # CHECK-NEXT:     Name:  (0)
 # CHECK-NEXT:     Type: SHT_NULL (0x0)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]

 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 4
 # CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:     SectionData (
 # CHECK-NEXT:       0000: 38000001 3860002A 44000002           |8...8`.*D...|
 # CHECK-NEXT:     )
 # CHECK-NEXT:   }
-# CHECK-NEXT:   Section {
-# CHECK-NEXT:     Index: 2
-# CHECK-NEXT:     Name: .comment (7)
+# CHECK-NEXT:  Section {
+# CHECK-NEXT:    Index: 2
+# CHECK-NEXT:    Name: .branch_lt (7)
+# CHECK-NEXT:    Type: SHT_PROGBITS (0x1)
+# CHECK-NEXT:    Flags [ (0x3)
+# CHECK-NEXT:      SHF_ALLOC (0x2)
+# CHECK-NEXT:      SHF_WRITE (0x1)
+# CHECK-NEXT:    ]
+# CHECK-NEXT:    Address: 0x10020000
+# CHECK-NEXT:    Offset: 0x20000
+# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Link: 0
+# CHECK-NEXT:    Info: 0
+# CHECK-NEXT:    AddressAlignment: 8
+# CHECK-NEXT:    EntrySize: 0
+# CHECK-NEXT:    SectionData (
+# CHECK-NEXT:    )
+# CHECK-NEXT:  }
+# CHECK-NEXT:   Section {
+# CHECK-NEXT:     Index: 3
+# CHECK-NEXT:     Name: .comment (18)
 # CHECK-NEXT:     Type: SHT_PROGBITS (0x1)
 # CHECK-NEXT:     Flags [ (0x30)
 # CHECK-NEXT:       SHF_MERGE (0x10)
 # CHECK-NEXT:       SHF_STRINGS (0x20)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
-# CHECK-NEXT:     Offset: 0x11000
+# CHECK-NEXT:     Offset: 0x20000
 # CHECK-NEXT:     Size: 8
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
 # CHECK-NEXT:     EntrySize: 1
 # CHECK-NEXT:     SectionData (
 # CHECK-NEXT:       0000: 4C4C4420 312E3000                    |LLD 1.0.|
 # CHECK-NEXT:     )
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
-# CHECK-NEXT:     Index: 3
-# CHECK-NEXT:     Name: .symtab (16)
+# CHECK-NEXT:     Index: 4
+# CHECK-NEXT:     Name: .symtab (27)
 # CHECK-NEXT:     Type: SHT_SYMTAB (0x2)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
-# CHECK-NEXT:     Offset: 0x11008
+# CHECK-NEXT:     Offset: 0x20008
 # CHECK-NEXT:     Size: 24
-# CHECK-NEXT:     Link: 5
+# CHECK-NEXT:     Link: 6
 # CHECK-NEXT:     Info: 1
 # CHECK-NEXT:     AddressAlignment: 8
 # CHECK-NEXT:     EntrySize: 24
 # CHECK-NEXT:     SectionData (
 # CHECK-NEXT:       0000: 00000000 00000000 00000000 00000000  |................|
 # CHECK-NEXT:       0010: 00000000 00000000                    |........|
 # CHECK-NEXT:     )
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
-# CHECK-NEXT:     Index: 4
-# CHECK-NEXT:     Name: .shstrtab (24)
+# CHECK-NEXT:     Index: 5
+# CHECK-NEXT:     Name: .shstrtab (35)
 # CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
-# CHECK-NEXT:     Offset: 0x11020
-# CHECK-NEXT:     Size: 42
+# CHECK-NEXT:     Offset: 0x20020
+# CHECK-NEXT:     Size: 53
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
 # CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:     SectionData (
-# CHECK-NEXT:       0000: 002E7465 7874002E 636F6D6D 656E7400  |..text..comment.|
-# CHECK-NEXT:       0010: 2E73796D 74616200 2E736873 74727461  |.symtab..shstrta|
-# CHECK-NEXT:       0020: 62002E73 74727461 6200               |b..strtab.|
+# CHECK-NEXT:      0000: 002E7465 7874002E 6272616E 63685F6C  |..text..branch_l|
+# CHECK-NEXT:      0010: 74002E63 6F6D6D65 6E74002E 73796D74  |t..comment..symt|
+# CHECK-NEXT:      0020: 6162002E 73687374 72746162 002E7374  |ab..shstrtab..st|
+# CHECK-NEXT:      0030: 72746162 00                          |rtab.|
 # CHECK-NEXT:     )
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
-# CHECK-NEXT:     Index: 5
-# CHECK-NEXT:     Name: .strtab (34)
+# CHECK-NEXT:     Index: 6
+# CHECK-NEXT:     Name: .strtab (45)
 # CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
-# CHECK-NEXT:     Offset: 0x1104A
+# CHECK-NEXT:     Offset: 0x20055
 # CHECK-NEXT:     Size: 1
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
 # CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:     SectionData (
 # CHECK-NEXT:       0000: 00                                   |.|
 # CHECK-NEXT:     )
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: ProgramHeaders [
 # CHECK-NEXT:   ProgramHeader {
 # CHECK-NEXT:     Type: PT_PHDR (0x6)
 # CHECK-NEXT:     Offset: 0x40
 # CHECK-NEXT:     VirtualAddress: 0x10000040
 # CHECK-NEXT:     PhysicalAddress: 0x10000040
-# CHECK-NEXT:     FileSize: 224
-# CHECK-NEXT:     MemSize: 224
+# CHECK-NEXT:     FileSize: 280
+# CHECK-NEXT:     MemSize: 280
 # CHECK-NEXT:     Flags [ (0x4)
 # CHECK-NEXT:       PF_R (0x4)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Alignment: 8
 # CHECK-NEXT:   }
 # CHECK-NEXT:   ProgramHeader {
 # CHECK-NEXT:     Type: PT_LOAD (0x1)
 # CHECK-NEXT:     Offset: 0x0
 # CHECK-NEXT:     VirtualAddress: 0x10000000
 # CHECK-NEXT:     PhysicalAddress: 0x10000000
-# CHECK-NEXT:     FileSize: 288
-# CHECK-NEXT:     MemSize: 288
+# CHECK-NEXT:     FileSize: 344
+# CHECK-NEXT:     MemSize: 344
 # CHECK-NEXT:     Flags [ (0x4)
 # CHECK-NEXT:       PF_R (0x4)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Alignment: 65536
 # CHECK-NEXT:   }
 # CHECK-NEXT:   ProgramHeader {
 # CHECK-NEXT:     Type: PT_LOAD (0x1)
 # CHECK-NEXT:     Offset: 0x10000

test/ELF/ppc64-long_branch.s

+# REQUIRES: ppc
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
+# RUN: ld.lld %t.o -o %t
+# RUN: llvm-objdump -d -start-address=0x10010000 -stop-address=0x10010014  %t | FileCheck %s -check-prefix=CALLEE_DUMP
+# RUN: llvm-objdump -d -start-address=0x12010020 -stop-address=0x12010068  %t | FileCheck %s -check-prefix=CALLER_DUMP
+# RUN: llvm-readelf --sections %t | FileCheck %s -check-prefix=SECTIONS
+# RUN: llvm-objdump -D  -start-address=0x12020008 -stop-address=0x12020018 %t | FileCheck %s -check-prefix=BRANCHLT
+
+  .text
+  .abiversion 2
+  .globl  callee
+  .p2align  4
+  .type callee,@function
+callee:
+.Lfunc_gep0:
+  addis 2, 12, .TOC.-.Lfunc_gep0@ha
+  addi 2, 2, .TOC.-.Lfunc_gep0@l
+.Lfunc_lep0:
+  .localentry callee, .Lfunc_lep0-.Lfunc_gep0
+        addis 4, 2, a@toc@ha
+        lwz   3, a@toc@l(4)
+        blr
+
+.space 0x2000000
+
+  .globl  caller
+  .p2align  4
+  .type caller,@function
+caller:
+.Lfunc_begin1:
+.Lfunc_gep1:
+  addis 2, 12, .TOC.-.Lfunc_gep1@ha
+  addi 2, 2, .TOC.-.Lfunc_gep1@l
+.Lfunc_lep1:
+  .localentry caller, .Lfunc_lep1-.Lfunc_gep1
+        mflr 0
+        std  0, 16(1)
+        stdu 1, -32(1)
+        bl callee
+        addi 1, 1, 32
+        ld   0, 16(1)
+        mtlr 0
+
+        addis 4, 2, b@toc@ha
+        lwz   4, b@toc@l(4)
+        add   3, 3, 4
+        blr
+
+
+  .data
+  .type a,@object               # @a
+  .globl  a
+  .p2align  2
+a:
+  .long 11
+  .size a, 4
+
+  .type b,@object
+  .globl  b
+  .p2align  2
+b:
+  .long 33                      # 0x21
+  .size b, 4
+
+# Verify address of the callee
+# CALLEE_DUMP: callee:
+# CALLEE_DUMP:   10010000:  {{.*}}  addis 2, 12, 515
+# CALLEE_DUMP:   10010004:  {{.*}}  addi 2, 2, -32768
+# CALLEE_DUMP:   10010008:  {{.*}}  addis 4, 2, -1
+# CALLEE_DUMP:   1001000c:  {{.*}}  lwz 3, -32768(4)
+# CALLEE_DUMP:   10010010:  {{.*}}  blr
+
+# Verify the thunks contents.
+# Offset from TOC to .branch_lt[0] :  (0x12020008 - 0x12038000) = 0xfffe8008.
+# 0xfffe8008  = (-1 << 16) + (-32760).
+# CALLER_DUMP: __long_branch_callee:
+# CALLER_DUMP:   12010058:  {{.*}}  addis 12, 2, -1
+# CALLER_DUMP:   1201005c:  {{.*}}  ld 12, -32760(12)
+# CALLER_DUMP:   12010060:  {{.*}}  mtctr 12
+# CALLER_DUMP:   12010064:  {{.*}}  bctr
+
+# .branch_lt is at address 0x12020008 and has a single entry.
+# .got section is at address 0x12030000 so TOC is 0x12038000
+# No .plt section should be emitted.
+#            [Nr] Name           Type          Address          Off     Size
+# SECTIONS:  [ 3] .branch_lt   PROGBITS     0000000012020008 2020008 000008
+# SECTIONS:  [ 4] .got         PROGBITS     0000000012030000 2030000 000008
+# SECTIONS-NOT: .plt
+
+# .branch_lt contains 1 entry: the local entry point of callee
+# BRANCHLT: Disassembly of section .branch_lt:
+# BRANCHLT: .branch_lt:
+# BRANCHLT: 12020008:       08 00 01 10
+# BRANCHLT: 1202000c:       00 00 00 00
+