[ELF2] getLocalRelTarget can ask the Target for symbolless relocations

[hfinkel]

Summary

R_PPC64_TOC does not have an associated symbol, but does have a non-zero VA that target-specific code must compute using some non-trivial rule. We currently handle this as a special case in PPC64TargetInfo::relocateOne, where we know to write this special address, but does not work when creating shared libraries. The special TOC address needs to be the subject of a R_PPC64_RELATIVE relocation, and so we also need to know how to encode this special address in the addend of that relocation.

Thus, some target-specific logic is necessary when creating R_PPC64_RELATIVE as well. It looks like the best way to solve this problem is to simply have getLocalRelTarget ask the target for the address of special symbolless relocations. This allows us to remove the special case in PPC64TargetInfo::relocateOne (simplifying code there), and naturally allows the existing logic to do the right thing when creating associated R_PPC64_RELATIVE relocations for shared libraries.

[ruiu]

ELF/OutputSections.cpp

437–438

Update the comment to mention that we usually return 0 but may be different on PPC64.

But, actually, does this happen on non-PPC64 platform? If there's no other platform that we have to take care of this case, this is probably over-designed. We can define a function like getPPC64TocDefault() and use that function here if it's on PPC64.

ELF/Target.cpp

436

Remove this blank line.

[ruiu]

ELF/OutputSections.cpp

437–438

So this can be as easy as

// R_PPC64_TOC is special as that has no corresponding symbol.
// getPPCTocBase will take care of the details for PPC.
if (Config->EMachine == EM_PPC64 && Type == R_PPC64_TOC)
  return getPPCTocBase();

[hfinkel]

ELF/OutputSections.cpp

437–438

I took a quick look at the other ABIs (ARM, MIPS, etc.) and did not see any other similar-looking relocations. This may be a PPC64-specific "feature". I can move the function for determining the TOC address into this file and call it here.

[ruiu]

ELF/OutputSections.cpp

437–438

Sounds good to me.

[hfinkel]

Updated per reviewer comments (I left the getPPC64TocBase function in Target.cpp, since it is still needed there anyway; I just made it non-static).

[ruiu]

LGTM

ELF/OutputSections.cpp

439

Ah, this is even better. Thank you for making this change.

[hfinkel]

r250555, thanks!

ELF/InputSection.cpp

void InputSection<ELFT>::relocate(
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(IsMips64EL);
     uint32_t Type = RI.getType(IsMips64EL);
 
     // Handle relocations for local symbols -- they never get
     // resolved so we don't allocate a SymbolBody.
     const Elf_Shdr *SymTab = File.getSymbolTable();
     if (SymIndex < SymTab->sh_info) {
-      uintX_t SymVA = getLocalRelTarget(File, RI);
+      uintX_t SymVA = getLocalRelTarget(File, RI, Type);
       relocateOne(Buf, BufEnd, RI, Type, BaseAddr, SymVA);
       continue;
     }
 
     SymbolBody &Body = *File.getSymbolBody(SymIndex)->repl();
     uintX_t SymVA = getSymVA<ELFT>(Body);
     if (Target->relocNeedsPlt(Type, Body)) {
       SymVA = Out<ELFT>::Plt->getEntryAddr(Body);

ELF/OutputSections.h

 template <class ELFT> class ELFSymbolBody;
 
 template <class ELFT>
 typename llvm::object::ELFFile<ELFT>::uintX_t getSymVA(const SymbolBody &S);
 
 template <class ELFT>
 typename llvm::object::ELFFile<ELFT>::uintX_t
 getLocalRelTarget(const ObjectFile<ELFT> &File,
-                  const typename llvm::object::ELFFile<ELFT>::Elf_Rel &Sym);
+                  const typename llvm::object::ELFFile<ELFT>::Elf_Rel &Sym,
+                  uint32_t Type);
 bool canBePreempted(const SymbolBody *Body, bool NeedsGot);
 template <class ELFT> bool includeInSymtab(const SymbolBody &B);
 
 bool includeInDynamicSymtab(const SymbolBody &B);
 
 template <class ELFT>
 bool shouldKeepInSymtab(
     const ObjectFile<ELFT> &File, StringRef Name,

ELF/OutputSections.cpp

for (const DynamicReloc<ELFT> &Rel : Relocs) {
     bool NeedsGot = Body && Target->relocNeedsGot(Type, *Body);
     bool CanBePreempted = canBePreempted(Body, NeedsGot);
     uintX_t Addend = 0;
     if (!CanBePreempted) {
       if (IsRela) {
         if (Body)
           Addend += getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body));
         else
-          Addend += getLocalRelTarget(File, RI);
+          Addend += getLocalRelTarget(File, RI, Type);
       }
       P->setSymbolAndType(0, Target->getRelativeReloc(), IsMips64EL);
     }
 
     if (NeedsGot) {
       P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
       if (CanBePreempted)
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
   llvm_unreachable("Invalid symbol kind");
 }
 
 // Returns a VA which a relocatin RI refers to. Used only for local symbols.
 // For non-local symbols, use getSymVA instead.
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t
 lld::elf2::getLocalRelTarget(const ObjectFile<ELFT> &File,
-                             const typename ELFFile<ELFT>::Elf_Rel &RI) {
+                             const typename ELFFile<ELFT>::Elf_Rel &RI,
+                             uint32_t Type) {
+  // PPC64 has a special relocation representing the TOC base pointer
+  // that does not have a corresponding symbol.
+  if (Config->EMachine == EM_PPC64 && Type == R_PPC64_TOC)
+    return getPPC64TocBase();
+
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   const Elf_Sym *Sym =
       File.getObj().getRelocationSymbol(&RI, File.getSymbolTable());
 
-  // For certain special relocations, such as R_PPC64_TOC, there's no
-  // corresponding symbol. Just return 0 in that case.
   if (!Sym)
-    return 0;
+    error("Unsupported relocation without symbol");
 
   // According to the ELF spec reference to a local symbol from outside
   // the group are not allowed. Unfortunately .eh_frame breaks that rule
   // and must be treated specially. For now we just replace the symbol with
   // 0.
   InputSection<ELFT> *Section = File.getSection(*Sym);
   if (Section == &InputSection<ELFT>::Discarded)
     return 0;

 
 template ELFFile<ELF32LE>::uintX_t getSymVA<ELF32LE>(const SymbolBody &);
 template ELFFile<ELF32BE>::uintX_t getSymVA<ELF32BE>(const SymbolBody &);
 template ELFFile<ELF64LE>::uintX_t getSymVA<ELF64LE>(const SymbolBody &);
 template ELFFile<ELF64BE>::uintX_t getSymVA<ELF64BE>(const SymbolBody &);
 
 template ELFFile<ELF32LE>::uintX_t
 getLocalRelTarget(const ObjectFile<ELF32LE> &,
-                  const ELFFile<ELF32LE>::Elf_Rel &);
+                  const ELFFile<ELF32LE>::Elf_Rel &, uint32_t);
 
 template ELFFile<ELF32BE>::uintX_t
 getLocalRelTarget(const ObjectFile<ELF32BE> &,
-                  const ELFFile<ELF32BE>::Elf_Rel &);
+                  const ELFFile<ELF32BE>::Elf_Rel &, uint32_t);
 
 template ELFFile<ELF64LE>::uintX_t
 getLocalRelTarget(const ObjectFile<ELF64LE> &,
-                  const ELFFile<ELF64LE>::Elf_Rel &);
+                  const ELFFile<ELF64LE>::Elf_Rel &, uint32_t);
 
 template ELFFile<ELF64BE>::uintX_t
 getLocalRelTarget(const ObjectFile<ELF64BE> &,
-                  const ELFFile<ELF64BE>::Elf_Rel &);
+                  const ELFFile<ELF64BE>::Elf_Rel &, uint32_t);
 
 template bool includeInSymtab<ELF32LE>(const SymbolBody &);
 template bool includeInSymtab<ELF32BE>(const SymbolBody &);
 template bool includeInSymtab<ELF64LE>(const SymbolBody &);
 template bool includeInSymtab<ELF64BE>(const SymbolBody &);
 
 template bool shouldKeepInSymtab<ELF32LE>(const ObjectFile<ELF32LE> &,
                                           StringRef,

ELF/Target.h

protected:
 
   unsigned PCRelReloc;
   unsigned GotRefReloc;
   unsigned GotReloc;
   unsigned RelativeReloc;
   unsigned PltEntrySize = 8;
 };
 
+uint64_t getPPC64TocBase();
+
 extern std::unique_ptr<TargetInfo> Target;
 TargetInfo *createTarget();
 }
 }
 
 #endif

ELF/Target.cpp

PPC64TargetInfo::PPC64TargetInfo() {
   //   in separate 256 Mbyte portions of the address space, to give the
   //   operating system full paging flexibility in the 64-bit address space.
   //
   // And because the lowest non-zero 256M boundary is 0x10000000, PPC64 linkers
   // use 0x10000000 as the starting address.
   VAStart = 0x10000000;
 }
 
-static uint64_t getPPC64TocBase() {
+uint64_t getPPC64TocBase() {
   // The TOC consists of sections .got, .toc, .tocbss, .plt in that
   // order. The TOC starts where the first of these sections starts.
 
   // FIXME: This obviously does not do the right thing when there is no .got
   // section, but there is a .toc or .tocbss section.
   uint64_t TocVA = Out<ELF64BE>::Got->getVA();
   if (!TocVA)
     TocVA = Out<ELF64BE>::Plt->getVA();
bool PPC64TargetInfo::isRelRelative(uint32_t Type) const {
   case R_PPC64_ADDR64:
     return false;
   }
 }
 
 void PPC64TargetInfo::relocateOne(uint8_t *Buf, uint8_t *BufEnd,
                                   const void *RelP, uint32_t Type,
                                   uint64_t BaseAddr, uint64_t SA) const {
   typedef ELFFile<ELF64BE>::Elf_Rela Elf_Rela;
   auto &Rel = *reinterpret_cast<const Elf_Rela *>(RelP);
 
   uint8_t *L = Buf + Rel.r_offset;
   uint64_t P = BaseAddr + Rel.r_offset;
   uint64_t TB = getPPC64TocBase();
 
-  if (Type == R_PPC64_TOC) {
-    write64be(L, TB);
-    return;
-  }
-
   // For a TOC-relative relocation, adjust the addend and proceed in terms of
   // the corresponding ADDR16 relocation type.
   switch (Type) {
   case R_PPC64_TOC16:       Type = R_PPC64_ADDR16;       SA -= TB; break;
   case R_PPC64_TOC16_DS:    Type = R_PPC64_ADDR16_DS;    SA -= TB; break;
   case R_PPC64_TOC16_LO:    Type = R_PPC64_ADDR16_LO;    SA -= TB; break;
   case R_PPC64_TOC16_LO_DS: Type = R_PPC64_ADDR16_LO_DS; SA -= TB; break;
   case R_PPC64_TOC16_HI:    Type = R_PPC64_ADDR16_HI;    SA -= TB; break;
case R_PPC64_REL32:
     if (!isInt<32>(SA - P))
       error("Relocation R_PPC64_REL32 overflow");
     write32be(L, SA - P);
     break;
   case R_PPC64_REL64:
     write64be(L, SA - P);
     break;
   case R_PPC64_ADDR64:
+  case R_PPC64_TOC:
     write64be(L, SA);
     break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 PPCTargetInfo::PPCTargetInfo() {

test/elf2/ppc64-shared-rel-toc.s

+// RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
+// RUN: ld.lld2 -shared %t.o -o %t.so
+// RUN: llvm-readobj -t -r -dyn-symbols %t.so | FileCheck %s
+// REQUIRES: ppc
+
+// When we create the TOC reference in the shared library, make sure that the
+// R_PPC64_RELATIVE relocation uses the correct (non-zero) offset.
+
+        .globl  foo
+        .align  2
+        .type   foo,@function
+        .section        .opd,"aw",@progbits
+foo:                                    # @foo
+        .align  3
+        .quad   .Lfunc_begin0
+        .quad   .TOC.@tocbase
+        .quad   0
+        .text
+.Lfunc_begin0:
+        blr
+
+// CHECK: 0x20090 R_PPC64_RELATIVE - 0x10000
+// CHECK: 0x20098 R_PPC64_RELATIVE - 0x8000
+
+// CHECK: Name: foo (20)
+// CHECK-NEXT: Value: 0x20090
+