[ELF/AArch64] Fix export TLS dynamic symbol

[zatrazz]

Summary

This patch fixes the TLS dynamic variable exportation from .got.plt segments,
created by General-dynamic relocations (TLSDESC). Current code only export
symbols in dynamic table from .got sections.

[ruiu]

lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.cpp

37

Why std::for_each? Can you use regular for loop instead?

[ruiu]

lib/ReaderWriter/ELF/AArch64/AArch64SectionChunks.h

35–47

I don't think these classes are needed. You can just pass "order" argument when you create an instance of AArch64GOTBaseSection.

[zatrazz]

I will repost it with requested changes.

lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.cpp

if (this->_ctx.isDynamic())
     gotFile->addAtom(*new (gotFile->allocator()) DynamicAtom(*gotFile));
   result.push_back(std::move(gotFile));
 }
 
 void AArch64ExecutableWriter::buildDynamicSymbolTable(const File &file) {
   for (auto sec : this->_layout.sections()) {
     if (auto section = dyn_cast<AtomSection<ELF64LE>>(sec)) {
       for (const auto &atom : section->atoms()) {
-        if (_targetLayout.getGOTSection().hasGlobalGOTEntry(atom->_atom)) {
+        auto gotSections = _targetLayout.getGOTSections();
+        std::for_each(gotSections.begin(), gotSections.end(), [&](AArch64GOTBaseSection *gotSection) {
+          if (gotSection->hasGlobalGOTEntry(atom->_atom)) {
             this->_dynamicSymbolTable->addSymbol(atom->_atom, section->ordinal(),
                                                atom->_virtualAddr, atom);
-          continue;
           }
+        });
       }
     }
   }
 
   ExecutableWriter<ELF64LE>::buildDynamicSymbolTable(file);
 }
 
 } // namespace elf
 } // namespace lld
 

lib/ReaderWriter/ELF/AArch64/AArch64RelocationPass.cpp

#endif
     _gotMap[da] = ga;
     _pltMap[da] = pa;
     _tlsdescVector.push_back(ga);
     _pltVector.push_back(pa);
     return ga;
   }
 
   std::error_code handleTLSDESC(const Reference &ref) {
-    if (isa<DefinedAtom>(ref.target())) {
+    if (isa<DefinedAtom>(ref.target()) ||
+        isa<SharedLibraryAtom>(ref.target())) {
       const_cast<Reference &>(ref).setTarget(getTLSDESCPLTEntry(ref.target()));
     }
     return std::error_code();
   }
 
   /// \brief Create a GOT entry containing 0.
   const GOTAtom *getNullGOT() {
     if (!_null) {

lib/ReaderWriter/ELF/AArch64/AArch64SectionChunks.h

 #ifndef LLD_READER_WRITER_ELF_AARCH64_AARCH64_SECTION_CHUNKS_H
 #define LLD_READER_WRITER_ELF_AARCH64_AARCH64_SECTION_CHUNKS_H
 
 #include "TargetLayout.h"
 
 namespace lld {
 namespace elf {
 
-class AArch64GOTSection : public AtomSection<ELF64LE> {
+
+class AArch64GOTBaseSection : public AtomSection<ELF64LE> {
 public:
-  AArch64GOTSection(const ELFLinkingContext &ctx);
+  AArch64GOTBaseSection(const ELFLinkingContext &ctx, StringRef name,
+    int32_t order);
 
   bool hasGlobalGOTEntry(const Atom *a) const {
     return _tlsMap.count(a);
   }
 
   const AtomLayout *appendAtom(const Atom *atom) override;
 
 private:
   /// \brief Map TLS Atoms to their GOT entry index.
   llvm::DenseMap<const Atom *, std::size_t> _tlsMap;
 };
 
+class AArch64GOTSection : public AArch64GOTBaseSection {
+public:
+  AArch64GOTSection(const ELFLinkingContext &ctx)
+    : AArch64GOTBaseSection(ctx, ".got", TargetLayout<ELF64LE>::ORDER_GOT) {}
+};
+
+class AArch64GOTPLTSection : public AArch64GOTBaseSection {
+public:
+  AArch64GOTPLTSection(const ELFLinkingContext &ctx)
+    : AArch64GOTBaseSection(ctx, ".got",
+                            TargetLayout<ELF64LE>::ORDER_GOT_PLT) {}
+};
+
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/AArch64/AArch64SectionChunks.cpp

 //===- lib/ReaderWriter/ELF/AArch64/AArch64SectionChunks.cpp --------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64SectionChunks.h"
 #include "TargetLayout.h"
 
 namespace lld {
 namespace elf {
 
-AArch64GOTSection::AArch64GOTSection(const ELFLinkingContext &ctx)
-  : AtomSection<ELF64LE>(ctx, ".got", DefinedAtom::typeGOT, DefinedAtom::permRW_,
-    TargetLayout<ELF64LE>::ORDER_GOT)
-{
+AArch64GOTBaseSection::AArch64GOTBaseSection(const ELFLinkingContext &ctx,
+  StringRef name, int32_t order)
+  : AtomSection<ELF64LE>(ctx, name, DefinedAtom::typeGOT, DefinedAtom::permRW_,
+    order) {
   this->_alignment = 8;
 }
 
-const AtomLayout *AArch64GOTSection::appendAtom(const Atom *atom) {
+const AtomLayout *AArch64GOTBaseSection::appendAtom(const Atom *atom) {
   const DefinedAtom *da = dyn_cast<DefinedAtom>(atom);
 
   for (const auto &r : *da) {
     if (r->kindNamespace() != Reference::KindNamespace::ELF)
       continue;
     assert(r->kindArch() == Reference::KindArch::AArch64);
     if ((r->kindValue() == R_AARCH64_TLS_TPREL64) ||
         (r->kindValue() == R_AARCH64_TLSDESC))
       _tlsMap[r->target()] = _tlsMap.size();
   }
 
   return AtomSection<ELF64LE>::appendAtom(atom);
 }
 
 } // elf
 } // lld

lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.h

 #include "ELFReader.h"
 #include "TargetLayout.h"
 #include "lld/Core/Simple.h"
 
 namespace lld {
 namespace elf {
 
 class AArch64LinkingContext;
-class AArch64GOTSection;
+class AArch64GOTBaseSection;
 
 class AArch64TargetLayout final : public TargetLayout<ELF64LE> {
   typedef llvm::object::Elf_Shdr_Impl<ELF64LE> Elf_Shdr;
 
 public:
   AArch64TargetLayout(ELFLinkingContext &ctx);
 
   AtomSection<ELF64LE> *
   createSection(StringRef name, int32_t type,
                 DefinedAtom::ContentPermissions permissions,
                 TargetLayout<ELF64LE>::SectionOrder order) override;
 
-  const AArch64GOTSection &getGOTSection() const { return *_gotSection; }
+  const std::vector<AArch64GOTBaseSection *> &getGOTSections() const {
+    return _gotSections;
+  }
 
   uint64_t getTPOffset() {
     std::call_once(_tpOffOnce, [this]() {
       for (const auto &phdr : *_programHeader) {
         if (phdr->p_type == llvm::ELF::PT_TLS) {
           _tpOff = llvm::RoundUpToAlignment(TCB_SIZE, phdr->p_align);
           break;
         }
       }
       assert(_tpOff != 0 && "TLS segment not found");
     });
     return _tpOff;
   }
 
 private:
   enum {
     TCB_SIZE = 16,
   };
 
 private:
-  AArch64GOTSection *_gotSection;
+  std::vector<AArch64GOTBaseSection *> _gotSections;
   uint64_t _tpOff = 0;
   std::once_flag _tpOffOnce;
 };
 
 class AArch64TargetHandler final : public TargetHandler {
 public:
   AArch64TargetHandler(AArch64LinkingContext &ctx);
 

lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp

 #include "AArch64LinkingContext.h"
 #include "AArch64TargetHandler.h"
 #include "AArch64SectionChunks.h"
 
 using namespace lld;
 using namespace elf;
 
 AArch64TargetLayout::AArch64TargetLayout(ELFLinkingContext &ctx) :
-  TargetLayout(ctx),
-  _gotSection(new (this->_allocator) AArch64GOTSection(ctx)) {}
+  TargetLayout(ctx) {}
 
 AtomSection<ELF64LE> *AArch64TargetLayout::createSection(
     StringRef name, int32_t type, DefinedAtom::ContentPermissions permissions,
     TargetLayout<ELF64LE>::SectionOrder order) {
-  if (type == DefinedAtom::typeGOT && name == ".got")
-    return _gotSection;
+  if (type == DefinedAtom::typeGOT && name == ".got") {
+    auto section = new (this->_allocator) AArch64GOTSection(this->_ctx);
+    _gotSections.push_back(section);
+    return section;
+  } else if (type == DefinedAtom::typeGOT && name == ".got.plt") {
+    auto section = new (this->_allocator) AArch64GOTPLTSection(this->_ctx);
+    _gotSections.push_back(section);
+    return section;
+  }
   return TargetLayout<ELF64LE>::createSection(name, type, permissions, order);
 }
 
 
 AArch64TargetHandler::AArch64TargetHandler(AArch64LinkingContext &ctx)
     : _ctx(ctx), _targetLayout(new AArch64TargetLayout(ctx)),
       _relocationHandler(new AArch64TargetRelocationHandler(*_targetLayout)) {}
 

test/elf/AArch64/general-dyn-tls-0.test

 #RUN: yaml2obj -format=elf %p/Inputs/general-dyn-tls-0.yaml -o=%t-t1.o
 #RUN: yaml2obj -format=elf %s -o %t-t0.o
 #RUN: lld -flavor gnu -target arm64 --noinhibit-exec -o %t.exe %t-t0.o %t-t1.o
 #RUN: llvm-readobj -relocations %t.exe | FileCheck %s -check-prefix=CHECKRELOCATION
 #RUN: llvm-objdump -s -t %t.exe        | FileCheck %s
 
 #CHECKRELOCATION: Relocations [
 #CHECKRELOCATION:  .rela.dyn {
-#CHECKRELOCATION:    0x401090 R_AARCH64_TLSDESC - 0x0
+#CHECKRELOCATION:    0x401090 R_AARCH64_TLSDESC var 0x0
 #CHECKRELOCATION: }
 
 #CHECK: Contents of section .text:
-#CHECK:      400230 a8c31fb8 40018052 0b000094 000000b0  ....@..R........
+#CHECK:      400250 a8c31fb8 40018052 0b000094 000000b0  ....@..R........
 #                                              \_        adrp    x0, 401000 <_DYNAMIC> (R_AARCH64_TLSDESC_ADR_PAGE21)
-#CHECK-NEXT: 400240 014840f9 00400291 20003fd6 49d03bd5  .H@..@.. .?.I.;.
+#CHECK-NEXT: 400260 014840f9 00400291 20003fd6 49d03bd5  .H@..@.. .?.I.;.
 #                   \_       |        |                  ldr     x1, [x0,#144]         (R_AARCH64_TLSDESC_LD64_LO12_NC)
 #                            \_       |                  add     x0, x0, #0x90         (R_AARCH64_TLSDESC_ADD_LO12_NC)
 #                                     \_                 blr     x1                    (R_AARCH64_TLSDESC_CALL)
 
 ---
 FileHeader:      
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB