[lld] [ELF/AArch64] Fix R_AARCH64_ABS64 in Shared mode

[zatrazz]

Summary

This patch fixes the R_AARCH64_ABS64 relocation when used in shared mode,
where it requires a dynamic R_AARCH64_RELATIVE relocation. To correct set
the addend on the dynamic relocation (since it will be used by the dynamic
linker), a new TargetInfo specific hook was created (getDynRelativeAddend)
to get the correct addend based on relocation type.

It also lead to some cleanup on powerpc backend by moving the specific
TOC base addend on the target specific code.

The patch fixes the issues when creating shared library code against
{init,fini}_array, where it issues R_AARCH64_ABS64 relocation against
local symbols.

[ruiu]

ELF/Writer.cpp

314–322

Instead of handling a local symbol as a special case, do you think you can create a new instance of SymbolBody here for local symbols and pass it to addReloc?

[zatrazz]

ELF/Writer.cpp

314–322

I tried to add a local symbol table in InputSectionBase, but it ended up begin disruptive in the sense it required a lot of code modification to handle it. However I think it is possible to create a local SymbolBody, although I see such modification to be an forward change.

[ruiu]

ELF/OutputSections.cpp

256–258

Can you add {} after if and else if?

264–265

Please use actual types instead of auto.

ELF/Target.cpp

1061–1066

I skimmed through the relocation handling of PPC, but I couldn't find the location for this particular code. Can you describe it for me? (And adding a comment would be appreciated.)

[zatrazz]

ELF/Target.cpp

1061–1066

I have added it on development phase, but seems ppc already handle that in elf2::getLocalRelTarget. I will remove it.

[zatrazz]

Fixed patch based on previous comments.

[ruiu]

ELF/Target.h

57 ↗

(On Diff #48303)

You defined this function but this function is an identity function in all subclasses. If you no longer need it, please remove.

[zatrazz]

Updated patch based on previous comment.

[ruiu]

LGTM

ELF/OutputSections.h

 }
 
 template <class ELFT, bool IsRela>
 typename llvm::object::ELFFile<ELFT>::uintX_t
 getLocalRelTarget(const ObjectFile<ELFT> &File,
                   const llvm::object::Elf_Rel_Impl<ELFT, IsRela> &Rel,
                   typename llvm::object::ELFFile<ELFT>::uintX_t Addend);
 
+template <class ELFT>
+typename llvm::object::ELFFile<ELFT>::uintX_t
+getLocalTarget(const ObjectFile<ELFT> &File,
+               const typename llvm::object::ELFFile<ELFT>::Elf_Sym &Sym,
+               typename llvm::object::ELFFile<ELFT>::uintX_t Addend);
+
 bool canBePreempted(const SymbolBody *Body, bool NeedsGot);
 
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
 // input sections, others are created by the linker.
 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
 template <class ELFT> class OutputSectionBase {
enum OffsetKind {
     Off_Bss,       // The bss entry of Sym (copy reloc).
     Off_Sec,       // The final position of the given input section and offset.
     Off_LTlsIndex, // The local tls index.
     Off_GTlsIndex, // The global tls index of Sym.
     Off_GTlsOffset // The global tls offset of Sym.
   } OKind;
 
   SymbolBody *Sym = nullptr;
+  uint32_t SymIndex = 0;
   InputSectionBase<ELFT> *OffsetSec = nullptr;
   uintX_t OffsetInSec = 0;
   bool UseSymVA = false;
   InputSectionBase<ELFT> *TargetSec = nullptr;
   uintX_t OffsetInTargetSec = 0;
   uintX_t Addend = 0;
 
   DynamicReloc(uint32_t Type, OffsetKind OKind, SymbolBody *Sym)
       : Type(Type), OKind(OKind), Sym(Sym) {}
 
   DynamicReloc(uint32_t Type, OffsetKind OKind, bool UseSymVA, SymbolBody *Sym)
       : Type(Type), OKind(OKind), Sym(Sym), UseSymVA(UseSymVA) {}
 
   DynamicReloc(uint32_t Type, InputSectionBase<ELFT> *OffsetSec,
                uintX_t OffsetInSec, bool UseSymVA, SymbolBody *Sym,
                uintX_t Addend)
       : Type(Type), OKind(Off_Sec), Sym(Sym), OffsetSec(OffsetSec),
         OffsetInSec(OffsetInSec), UseSymVA(UseSymVA), Addend(Addend) {}
 
   DynamicReloc(uint32_t Type, InputSectionBase<ELFT> *OffsetSec,
+               uintX_t OffsetInSec, bool UseSymVA, uint32_t SymIndex,
+               uintX_t Addend)
+      : Type(Type), OKind(Off_Sec), SymIndex(SymIndex), OffsetSec(OffsetSec),
+        OffsetInSec(OffsetInSec), UseSymVA(UseSymVA), Addend(Addend) {}
+
+  DynamicReloc(uint32_t Type, InputSectionBase<ELFT> *OffsetSec,
                uintX_t OffsetInSec, InputSectionBase<ELFT> *TargetSec,
                uintX_t OffsetInTargetSec, uintX_t Addend)
       : Type(Type), OKind(Off_Sec), OffsetSec(OffsetSec),
         OffsetInSec(OffsetInSec), TargetSec(TargetSec),
         OffsetInTargetSec(OffsetInTargetSec), Addend(Addend) {}
 
   uintX_t getOffset() const;
 };
private:
   SymbolTable<ELFT> &Table;
 
   // A vector of symbols and their string table offsets.
   std::vector<std::pair<SymbolBody *, size_t>> Symbols;
 };
 
 template <class ELFT>
 class RelocationSection final : public OutputSectionBase<ELFT> {
+  typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
 public:
   RelocationSection(StringRef Name, bool IsRela);
   void addReloc(const DynamicReloc<ELFT> &Reloc);
   unsigned getRelocOffset();

ELF/OutputSections.cpp

 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
   for (const DynamicReloc<ELFT> &Rel : Relocs) {
     auto *P = reinterpret_cast<Elf_Rel *>(Buf);
     Buf += IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
     SymbolBody *Sym = Rel.Sym;
 
     if (IsRela) {
       uintX_t VA = 0;
-      if (Rel.UseSymVA)
+      if (Rel.UseSymVA) {
         VA = Sym->getVA<ELFT>();
-      else if (Rel.TargetSec)
+      } else if (Rel.TargetSec) {
         VA = Rel.TargetSec->getOffset(Rel.OffsetInTargetSec) +
              Rel.TargetSec->OutSec->getVA();
+      } else if (!Sym && Rel.OffsetSec) {
+        // Sym equal to nullptr means the dynamic relocation is against a
+        // local symbol represented by Rel.SymIndex.
+        ObjectFile<ELFT> *File = Rel.OffsetSec->getFile();
+        const Elf_Sym *LocalSym = File->getLocalSymbol(Rel.SymIndex);
+        VA = getLocalTarget(*File, *LocalSym, 0);
+      }
       reinterpret_cast<Elf_Rela *>(P)->r_addend = Rel.Addend + VA;
     }
 
     P->r_offset = Rel.getOffset();
     uint32_t SymIdx = (!Rel.UseSymVA && Sym) ? Sym->DynsymIndex : 0;
     P->setSymbolAndType(SymIdx, Rel.Type, Config->Mips64EL);
   }
 }

 // Returns a VA which a relocatin RI refers to. Used only for local symbols.
 // For non-local symbols, use SymbolBody::getVA instead.
 template <class ELFT, bool IsRela>
 typename ELFFile<ELFT>::uintX_t
 elf2::getLocalRelTarget(const ObjectFile<ELFT> &File,
                         const Elf_Rel_Impl<ELFT, IsRela> &RI,
                         typename ELFFile<ELFT>::uintX_t Addend) {
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
-  typedef typename ELFFile<ELFT>::uintX_t uintX_t;
 
   // PPC64 has a special relocation representing the TOC base pointer
   // that does not have a corresponding symbol.
   if (Config->EMachine == EM_PPC64 && RI.getType(false) == R_PPC64_TOC)
     return getPPC64TocBase() + Addend;
 
   const Elf_Sym *Sym =
       File.getObj().getRelocationSymbol(&RI, File.getSymbolTable());
 
   if (!Sym)
     fatal("Unsupported relocation without symbol");
 
-  InputSectionBase<ELFT> *Section = File.getSection(*Sym);
+  return getLocalTarget(File, *Sym, Addend);
+}
+
+template <class ELFT>
+typename ELFFile<ELFT>::uintX_t
+elf2::getLocalTarget(const ObjectFile<ELFT> &File,
+                     const typename ELFFile<ELFT>::Elf_Sym &Sym,
+                     typename ELFFile<ELFT>::uintX_t Addend) {
+  typedef typename ELFFile<ELFT>::uintX_t uintX_t;
 
-  if (Sym->getType() == STT_TLS)
-    return (Section->OutSec->getVA() + Section->getOffset(*Sym) + Addend) -
+  InputSectionBase<ELFT> *Section = File.getSection(Sym);
+  if (!Section)
+    return Addend;
+
+  if (Sym.getType() == STT_TLS)
+    return (Section->OutSec->getVA() + Section->getOffset(Sym) + Addend) -
            Out<ELFT>::TlsPhdr->p_vaddr;
 
   // 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.
   if (Section == &InputSection<ELFT>::Discarded || !Section->isLive())
     return Addend;
 
-  uintX_t Offset = Sym->st_value;
-  if (Sym->getType() == STT_SECTION) {
+  uintX_t Offset = Sym.st_value;
+  if (Sym.getType() == STT_SECTION) {
     Offset += Addend;
     Addend = 0;
   }
   return Section->OutSec->getVA() + Section->getOffset(Offset) + Addend;
 }
 
 // Returns true if a symbol can be replaced at load-time by a symbol
 // with the same name defined in other ELF executable or DSO.
template uint32_t getLocalRelTarget(const ObjectFile<ELF32BE> &,
                                     const ELFFile<ELF32BE>::Elf_Rela &,
                                     uint32_t);
 template uint64_t getLocalRelTarget(const ObjectFile<ELF64LE> &,
                                     const ELFFile<ELF64LE>::Elf_Rela &,
                                     uint64_t);
 template uint64_t getLocalRelTarget(const ObjectFile<ELF64BE> &,
                                     const ELFFile<ELF64BE>::Elf_Rela &,
                                     uint64_t);
+
+template uint32_t getLocalTarget(const ObjectFile<ELF32LE> &,
+                                 const ELFFile<ELF32LE>::Elf_Sym &Sym,
+                                 uint32_t);
+template uint32_t getLocalTarget(const ObjectFile<ELF32BE> &,
+                                 const ELFFile<ELF32BE>::Elf_Sym &Sym,
+                                 uint32_t);
+template uint64_t getLocalTarget(const ObjectFile<ELF64LE> &,
+                                 const ELFFile<ELF64LE>::Elf_Sym &Sym,
+                                 uint64_t);
+template uint64_t getLocalTarget(const ObjectFile<ELF64BE> &,
+                                 const ELFFile<ELF64BE>::Elf_Sym &Sym,
+                                 uint64_t);
 }
 }

ELF/Target.cpp

public:
   unsigned getDynRel(unsigned Type) const override;
   bool isTlsGlobalDynamicRel(unsigned Type) const override;
   void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZero(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   unsigned getTlsGotRel(unsigned Type) const override;
   bool isTlsDynRel(unsigned Type, const SymbolBody &S) const override;
+  bool needsDynRelative(unsigned Type) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsGot(uint32_t Type, SymbolBody &S) const override;
   PltNeed needsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA, uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   unsigned relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                     uint64_t SA, const SymbolBody *S) const override;

 TargetInfo::PltNeed PPC64TargetInfo::needsPlt(uint32_t Type,
                                               const SymbolBody &S) const {
   // These are function calls that need to be redirected through a PLT stub.
   if (Type == R_PPC64_REL24 && canBePreempted(&S, false))
     return Plt_Explicit;
   return Plt_No;
 }
 
 bool PPC64TargetInfo::isRelRelative(uint32_t Type) const {
   switch (Type) {
   default:
     return true;
   case R_PPC64_ADDR64:
   case R_PPC64_TOC:
     return false;
   }
 }
 
 void PPC64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                   uint64_t P, uint64_t SA, uint64_t ZA,
                                   uint8_t *PairedLoc) const {
   uint64_t TB = getPPC64TocBase();
case R_PPC64_TOC:
     break;
   default:
     fatal("unrecognized reloc " + Twine(Type));
   }
 }
 
 AArch64TargetInfo::AArch64TargetInfo() {
   CopyRel = R_AARCH64_COPY;
+  RelativeRel = R_AARCH64_RELATIVE;
   IRelativeRel = R_AARCH64_IRELATIVE;
   GotRel = R_AARCH64_GLOB_DAT;
   PltRel = R_AARCH64_JUMP_SLOT;
   TlsGotRel = R_AARCH64_TLS_TPREL64;
   TlsModuleIndexRel = R_AARCH64_TLS_DTPMOD64;
   TlsOffsetRel = R_AARCH64_TLS_DTPREL64;
   UseLazyBinding = true;
   PltEntrySize = 16;
bool AArch64TargetInfo::isTlsDynRel(unsigned Type, const SymbolBody &S) const {
   return Type == R_AARCH64_TLSDESC_ADR_PAGE21 ||
          Type == R_AARCH64_TLSDESC_LD64_LO12_NC ||
          Type == R_AARCH64_TLSDESC_ADD_LO12_NC ||
          Type == R_AARCH64_TLSDESC_CALL ||
          Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 ||
          Type == R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC;
 }
 
+bool AArch64TargetInfo::needsDynRelative(unsigned Type) const {
+  return Config->Shared && Type == R_AARCH64_ABS64;
+}
+
 bool AArch64TargetInfo::needsCopyRel(uint32_t Type, const SymbolBody &S) const {
   if (Config->Shared)
     return false;
   switch (Type) {
   default:
     return false;
   case R_AARCH64_ABS16:
   case R_AARCH64_ABS32:

ELF/Writer.cpp

if (Body && Body->isUndefined() && !Body->isWeak())
         S->File->IsUsed = true;
 
     if (Body)
       Body = Body->repl();
 
     if (handleTlsRelocation<ELFT>(Type, Body, C, RI))
       continue;
 
-    if (Target->needsDynRelative(Type))
+    if (Target->needsDynRelative(Type)) {
+      // If Body is null it means the relocation is against a local symbol
+      // and thus we need to pass the local symbol index instead.
+      if (Body)
         Out<ELFT>::RelaDyn->addReloc({Target->RelativeRel, &C, RI.r_offset, true,
                                       Body, getAddend<ELFT>(RI)});
+      else
+        Out<ELFT>::RelaDyn->addReloc({Target->RelativeRel, &C, RI.r_offset, false,
+                                      SymIndex, getAddend<ELFT>(RI)});
+    }
 
     // MIPS has a special rule to create GOTs for local symbols.
     if (Config->EMachine == EM_MIPS && !canBePreempted(Body, true) &&
         (Type == R_MIPS_GOT16 || Type == R_MIPS_CALL16)) {
       // FIXME (simon): Do not add so many redundant entries.
       Out<ELFT>::Got->addMipsLocalEntry();
       continue;
     }

test/ELF/aarch64-abs64-dyn.s

+// REQUIRES: aarch64
+// RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux %s -o %t.o
+
+// Creates a R_AARCH64_ABS64 relocation against _foo. It will be used on a
+// shared object to check for a dynamic relocation creation.
+.globl _foo
+_foo:
+   ret
+_foo_init_array:
+  .xword _foo
+
+// RUN: ld.lld -shared -o %t.so %t.o
+// RUN: llvm-readobj -symbols -dyn-relocations %t.so | FileCheck %s
+
+// CHECK:       Dynamic Relocations {
+// CHECK-NEXT:      {{.*}} R_AARCH64_RELATIVE - [[FOO_ADDR:[0-9xa-f]+]]
+
+// CHECK:       Symbols [
+// CHECK:         Symbol {
+// CHECK:           Name: _foo
+// CHECK:           Value: [[FOO_ADDR]]