[lld] [ELF] Support for general dynamic TLS relocations on X86_64

[rafaelauler]

Summary

This patch adds support for the general dynamic TLS access model for X86_64 (see www.akkadia.org/drepper/tls.pdf).

To properly support TLS, the patch also changes the tls_get_addr atom to be a shared library atom instead of a regularly defined atom (the previous lld approach). This closely models the reality of a function that will be resolved at runtime by the dynamic linker and loader itself (ld.so). I was tempted to force LLD to link against ld.so itself to resolve these symbols, but since GNU ld does not need the ld.so library to resolve this symbol, I decided to mimic its behavior and keep hardwired a definition of tls_get_addr in the lld code.

This patch also moves some important logic that previously was only available to the MIPS lld backend to be used to all ELF backends. This logic, which now lives in the DefaultLayout class, will monitor which external (shared lib) symbols are really imported by the current module and will only populate the dynamic symbol table with used symbols, as opposed to the previous approach of dumping all shared lib symbols in the dynamic symbol table. This is important to this patch to avoid __tls_get_addr from getting injected into all dynamic symbol tables.

By solving the previous problem of always adding __tls_get_addr, now the produced symbol tables are slightly smaller. But this impacted several tests that relied on hardwired/predefined sizes of the symbol table, requiring this patch to update such tests.

[Bigcheese]

lgtm with the change.

lib/ReaderWriter/ELF/Atoms.h

652–657

Not sure this is needed. TLSGETADDRAtom can just directly derive from SharedLibraryAtom.

[rafaelauler]

Thanks for putting in time to see this. I agree with the changes and I updated my patch. I don't have commit access, could you please commit it?

[kledzik]

One area of linking not fleshed out in lld is the "canBeNullAtBuildtime" attribute for UndefinedSymbols. That was intended to model ELF weak undefines. Is that how tls_get_addr works with gnu ld? If so, then getting canBeNullAtBuildtime to work in general could solve this specific issue without needing to special case tls_get_addr.

[rafaelauler]

__tls_get_addr is a regular, non-weak versioned symbol from the dynamic linker and loader. For example:

$ readelf -a /lib64/ld-linux-x86-64.so.2
...

21: 0000000000013340    55 FUNC    GLOBAL DEFAULT   11 __tls_get_addr@@GLIBC_2.3

...

The only difference to a regular lib is that you don't need to pass "-lsomelibname" to link against it but, rather, it is an implicit library that is always present. Another difference is that you don't need to put a DT_NEEDED tag to request the "ld.so" library: it will already be loaded because it is the dynamic linker and loader.

Since we can't rely on a ld.so to link against, but we must implicitly provide this symbol, I put this as an explicit atom. Since it will come from a lib at runtime, I modelled this as a subclass of SharedLibraryAtom.

[rafaelauler]

For example, if you strace the GNU ld when linking a TLS library, it will never open "ld.so". This suggests that the ELF linker should be self-contained with respect to the symbols of ld.so, providing hardwired definitions of them.

[kledzik]

I guess I was not clear. I did not mean where does the *definition* of tls_get_addr come from. I was asking where does the *undefine* for tls_get_addr come from? If that undefine is "weak", that tells the linker that if no definition is found, to assume it was in some DSO. Seems like that is what you are special casing tls_get_addr to do.

[rafaelauler]

Sorry, my bad, I mixed up definitions. You are right, that would work well. However, usually compilers generate an undefine for __tls_get_addr that is just a regular, non-weak undefine. For example:

$ clang -c -o test.o -x c - <<< '__thread int my_tls_number = 0; int mynum() { return my_tls_number; }'
$ readelf -a test.o
...

12: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND __tls_get_addr

...

[joerg]

I'm not sure this patch is the right direction. Essentially, for statically linked binaries, libc is responsible for providing the symbol. For dynamically linked binaries, libc or libdl may provide a definition, but it is a symbol that is explicitly known. This leads back to the main issue that lld deals badly with symbols that are known to be defined somewhere, but not necessarily explicitly. IMO it would be better to address that issue first.

[shankarke]

lib/ReaderWriter/ELF/DynamicLibraryWriter.h

70 ↗

(On Diff #14126)

Why do we want to add this atom ? This should be an undefined symbol with fPIC.

lib/ReaderWriter/ELF/ExecutableWriter.h

69–71

as my previous comment, we should not add this atom by default.

[rafaelauler]

Hi Joerg,

I see, I agree that this does not mix well with static linking, I was very much glibc-focused. In fact, this is a preliminary patch that addresses only the first TLS general dynamic use case, I would work in the static cases later. To address both dynamic and static cases, I think that Kledzik's suggestion of putting weak symbols to work will fit in perfectly: if the linker doesn't find any objects defining tl_get_addr at build time, it will leave to the dynamic linker at runtime. What do you think?

[rafaelauler]

Hi Shankar,

Thanks for putting in time to review this. I agree that we should not add this atom in dynamic libraries, I did this to replace the previous code that would always add a definition of tls_get_addr regardless the output type, but removing this atom would still work well. However, I am not sure if I fully understood your last comment -- I cannot see why we should remove this atom from ExecutableWriter, since, to complete linking an executable, all symbols must be resolved and we cannot finish it with undefined references.

Best regards,
Rafael Auler

[rafaelauler]

Addressed Shankar's first comment and removed atom adding logic from DynamicLibraryWriter.

[kledzik]

to complete linking an executable, all symbols must be resolved and we cannot finish it with undefined references

The way linking should work is that if any UndefinedAtoms remain, if all of them are marked canBeNullAtBuildtime, the LinkingContext should instantiate SharedLibraryAtoms to resolve those. canBeNullAtBuildtime is something only ELF supports, so the LinkingContext needs to called to do this.

With the functionality in place, the trick is to create the UndefinedAtoms for tls_get_addr as canBeNullAtBuildtime.

[rafaelauler]

Sounds reasonable. Since the undefined references for __tls_get_addr are usually not weak by themselves, should we add a special case to the reader to convert them to weak undefines?

[shankarke]

canBeNullAtBuildTime is associated with a weak symbol while __tls_get_addr is not a weak symbo in the writer, which changes the symbol semantics.

The reason I was mentioning about removing the __tls_get_addr atom for the executable is for the code was not PIC.

[kledzik]

should we add a special case to the reader to convert them to weak undefines?

That is what I was thinking. But you should investigate how this works with the gnu linker. Does the linker really hard code "__tls_get_addr" to be special? Or does it always implicitly link with ld.so?

canBeNullAtBuildTime is associated with a weak symbol while __tls_get_addr is not a weak symbo in the writer, which changes the symbol semantics.

I'm not sure what you are saying here. If "tls_get_adder" was a weak *undefined* symbol in the .o file, everything would work correctly. Static linking ignores the canBeNullAtBuildTime aspect of UndefinedAtoms, so either it is defined in an archive, or you get a linker error. For dynamic executables, if it "tls_get_adder" not defined anywhere, the linker notices the canBeNullAtBuildTime and conjures up a SharedLibraryAtom for it.

[rafaelauler]

I'm sorry, I think I was influenced by the previous lld code that always defined _tls_get_addr to be a regular symbol, I'm checking here and I think we don't need to define an atom for __tls_get_addr at all.

What happens is that the linker command line that clang uses eventually includes a linker script that foces it to link against ld.so.... so no need to explictly define this atom.

I will continue to investigate, though, to see if there are cases where we do need to special case tls_get_addr. Does anyone know why tls_get_addr was explictly defined as an atom in previous lld code in the first place?

[rafaelauler]

This new version of the patch completely removes the special case for the "tls_get_addr" atom/symbol, since it will be provided by input libraries (usually ld.so). However, some tests depended on tls_get_addr being always defined, independent of inputs. To avoid breaking these tests, this patch adds "--defsym=tls_get_addr=0" to the linker command line in these tests. This patch also updates a "TODO" file that asked to remove tls_get_addr from the output.

[rafaelauler]

I have a few minor updates to this patch.

1. I enhanced the test case to also check whether the PLT32 relocation against tls_get_addr is being properly generated in a shared lib, if it uses TLS.
2. When I removed the tlsgetaddr atom, the PLT32 relocation against tls_get_addr stopped being generated. I fixed this in a logic in the X86_64RelocationPass.cpp that would only add a PLT relocation if the symbol came from a SharedLib. I changed this to add whenever it comes from a SharedLIb <or> if it is undefined, because we can't leave a PLT32 unresolved if the target is not defined.
3. I removed the logic that checks whether the symbol comes from the dynamic linker and, if so, do not add it to DT_NEEDED. This logic is quite expensive (needs to strcmp every symbol that is being added to the dynamic symbol table) and I am not sure if this is necessary, I only did it to mimic gnu ld.

If you want to accept this patch, could you please commit it? I don't have commit access.

[rafaelauler]

Committed as r218633.

include/lld/ReaderWriter/ELFLinkingContext.h

public:
 
   // By default, the linker would merge sections that are read only with
   // segments that have read and execute permissions. When the user specifies a
   // flag --rosegment, a separate segment needs to be created.
   bool mergeRODataToTextSegment() const { return _mergeRODataToTextSegment; }
 
   void setCreateSeparateROSegment() { _mergeRODataToTextSegment = false; }
 
-  bool hasCoalescedSharedLibPair(StringRef name) const {
-    return _sharedLibCoalescedSymbols.count(name) != 0;
+  bool isDynamicallyExportedSymbol(StringRef name) const {
+    return _dynamicallyExportedSymbols.count(name) != 0;
   }
 
 private:
   ELFLinkingContext() LLVM_DELETED_FUNCTION;
 
 protected:
   ELFLinkingContext(llvm::Triple, std::unique_ptr<TargetHandlerBase>);
 
protected:
   StringRef _dynamicLinkerPath;
   StringRefVector _initFunctions;
   StringRefVector _finiFunctions;
   StringRef _sysrootPath;
   StringRef _soname;
   StringRefVector _rpathList;
   StringRefVector _rpathLinkList;
   std::map<std::string, uint64_t> _absoluteSymbols;
-  llvm::StringSet<> _sharedLibCoalescedSymbols;
+  llvm::StringSet<> _dynamicallyExportedSymbols;
 };
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h

: DynamicLibraryWriter<ELFT>(context, layout),
       _gotFile(new GOTFile(context)), _context(context),
       _AArch64Layout(layout) {}
 
 template <class ELFT>
 bool AArch64DynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GLOBAL_OFFSET_TABLEAtom(*_gotFile));
-  _gotFile->addAtom(*new (_gotFile->_alloc) TLSGETADDRAtom(*_gotFile));
   _gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
   return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h

AArch64ExecutableWriter<ELFT>::AArch64ExecutableWriter(
     : ExecutableWriter<ELFT>(context, layout), _gotFile(new GOTFile(context)),
       _context(context), _AArch64Layout(layout) {}
 
 template <class ELFT>
 bool AArch64ExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GLOBAL_OFFSET_TABLEAtom(*_gotFile));
-  _gotFile->addAtom(*new (_gotFile->_alloc) TLSGETADDRAtom(*_gotFile));
   if (_context.isDynamic())
     _gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
   return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/Atoms.h

 private:
 
   const DynamicFile<ELFT> &_owningFile;
   StringRef _symbolName;
   StringRef _loadName;
   const Elf_Sym *_symbol;
 };
 
 class SimpleELFDefinedAtom : public SimpleDefinedAtom {
 public:
   SimpleELFDefinedAtom(const File &f) : SimpleDefinedAtom(f) {}
 
   void addReferenceELF(Reference::KindArch arch, uint16_t kindValue,
                        uint64_t off, const Atom *target,
                        Reference::Addend addend) {
     this->addReference(Reference::KindNamespace::ELF, arch, kindValue, off,
                        target, addend);
   }
 
   void addReferenceELF_Hexagon(uint16_t relocType, uint64_t off, const Atom *t,
                                Reference::Addend a) {
     this->addReferenceELF(Reference::KindArch::Hexagon, relocType, off, t, a);
public:
   Alignment alignment() const override {
     // Needs 8 byte alignment
     return Alignment(3);
   }
 
   ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
 };
 
-class TLSGETADDRAtom : public SimpleELFDefinedAtom {
+class TLSGETADDRAtom : public SharedLibraryAtom {
 public:
-  TLSGETADDRAtom(const File &f) : SimpleELFDefinedAtom(f) {}
+  TLSGETADDRAtom(const File &f) : SharedLibraryAtom(), _owningFile(f) {}
 
-  StringRef name() const override { return "__tls_get_addr"; }
-
-  Scope scope() const override { return scopeGlobal; }
+  const File &file() const override { return _owningFile; }
 
-  Merge merge() const override { return mergeAsWeak; }
+  StringRef name() const override { return "__tls_get_addr"; }
 
-  SectionChoice sectionChoice() const override { return sectionCustomRequired; }
+  StringRef loadName() const override {
+    return "_ld_so";
+  }
 
-  StringRef customSectionName() const override { return ".text"; }
+  bool canBeNullAtRuntime() const override { return true; }
 
-  ContentType contentType() const override { return typeCode; }
+  Type type() const override {
+    return Type::Code;
+  }
 
   uint64_t size() const override { return 0; }
-
-  ContentPermissions permissions() const override { return permR_X; }
-
-  Alignment alignment() const override { return Alignment(0); }
-
-  ArrayRef<uint8_t> rawContent() const override { return ArrayRef<uint8_t>(); }
+private:
+  const File &_owningFile;
 };
 
 class DYNAMICAtom : public SimpleELFDefinedAtom {
 public:
   DYNAMICAtom(const File &f) : SimpleELFDefinedAtom(f) {}
 
   StringRef name() const override { return "_DYNAMIC"; }
 

lib/ReaderWriter/ELF/DefaultLayout.h

 #include "SectionChunks.h"
 #include "SegmentChunks.h"
 
 #include "lld/Core/Instrumentation.h"
 #include "lld/Core/STDExtras.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Format.h"
public:
 
   uint64_t getTLSSize() const {
     for (const auto &phdr : *_programHeader)
       if (phdr->p_type == llvm::ELF::PT_TLS)
         return phdr->p_memsz;
     return 0;
   }
 
+  bool isReferencedByDefinedAtom(const SharedLibraryAtom *sla) const {
+    return _referencedDynAtoms.count(sla);
+  }
+
 protected:
   /// \brief Allocate a new section.
   virtual AtomSection<ELFT> *createSection(
       StringRef name, int32_t contentType,
       DefinedAtom::ContentPermissions contentPermissions,
       SectionOrder sectionOrder);
 
 protected:
   llvm::BumpPtrAllocator _allocator;
   SectionMapT _sectionMap;
   MergedSectionMapT _mergedSectionMap;
   AdditionalSegmentMapT _additionalSegmentMap;
   SegmentMapT _segmentMap;
   std::vector<Chunk<ELFT> *> _sections;
   std::vector<Segment<ELFT> *> _segments;
   std::vector<MergedSections<ELFT> *> _mergedSections;
   ELFHeader<ELFT> *_elfHeader;
   ProgramHeader<ELFT> *_programHeader;
   LLD_UNIQUE_BUMP_PTR(RelocationTable<ELFT>) _dynamicRelocationTable;
   LLD_UNIQUE_BUMP_PTR(RelocationTable<ELFT>) _pltRelocationTable;
   std::vector<lld::AtomLayout *> _absoluteAtoms;
+  llvm::DenseSet<const SharedLibraryAtom *> _referencedDynAtoms;
   const ELFLinkingContext &_context;
 };
 
 /// \brief Handle linker scripts. TargetLayouts would derive
 /// from this class to override some of the functionalities.
 template<class ELFT>
 class ScriptLayout: public DefaultLayout<ELFT> {
 public:
if (const DefinedAtom *definedAtom = dyn_cast<DefinedAtom>(atom)) {
     const DefinedAtom::ContentPermissions permissions =
         definedAtom->permissions();
     const DefinedAtom::ContentType contentType = definedAtom->contentType();
 
     StringRef sectionName = getSectionName(definedAtom);
     AtomSection<ELFT> *section =
         getSection(sectionName, contentType, permissions);
     // Add runtime relocations to the .rela section.
-    for (const auto &reloc : *definedAtom)
+    for (const auto &reloc : *definedAtom) {
       if (_context.isDynamicRelocation(*definedAtom, *reloc))
         getDynamicRelocationTable()->addRelocation(*definedAtom, *reloc);
       else if (_context.isPLTRelocation(*definedAtom, *reloc))
         getPLTRelocationTable()->addRelocation(*definedAtom, *reloc);
+      if (const auto *sla = dyn_cast<SharedLibraryAtom>(reloc->target()))
+        _referencedDynAtoms.insert(sla);
+    }
     return section->appendAtom(atom);
   } else if (const AbsoluteAtom *absoluteAtom = dyn_cast<AbsoluteAtom>(atom)) {
     // Absolute atoms are not part of any section, they are global for the whole
     // link
     _absoluteAtoms.push_back(new (_allocator)
         lld::AtomLayout(absoluteAtom, 0, absoluteAtom->value()));
     return *_absoluteAtoms.back();
   } else {

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

if (!da && !ua) {
     ua = dyn_cast<UndefinedAtom>(existingAtom);
   }
 
   if (da && ua && da->scope() == Atom::scopeGlobal &&
       isa<SharedLibraryFile>(ua->file()))
     // If strong defined atom coalesces away an atom declared
     // in the shared object the strong atom needs to be dynamically exported.
     // Save its name.
-    _sharedLibCoalescedSymbols.insert(ua->name());
+    _dynamicallyExportedSymbols.insert(ua->name());
 }
 
 } // end namespace lld

lib/ReaderWriter/ELF/ExecutableWriter.h

 //===----------------------------------------------------------------------===//
 //  ExecutableWriter Class
 //===----------------------------------------------------------------------===//
 template<class ELFT>
 class ExecutableWriter : public OutputELFWriter<ELFT> {
 public:
   ExecutableWriter(const ELFLinkingContext &context, TargetLayout<ELFT> &layout)
       : OutputELFWriter<ELFT>(context, layout),
-        _runtimeFile(new CRuntimeFile<ELFT>(context)) {}
+        _runtimeFile(new CRuntimeFile<ELFT>(context)),
+        _dynamicInterpreterFile(new SimpleFile(context.getInterpreter()))  {}
 
 protected:
   virtual void addDefaultAtoms();
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &);
   virtual void finalizeDefaultAtomValues();
   virtual void createDefaultSections();
   LLD_UNIQUE_BUMP_PTR(InterpSection<ELFT>) _interpSection;
   std::unique_ptr<CRuntimeFile<ELFT> > _runtimeFile;
+  std::unique_ptr<SimpleFile> _dynamicInterpreterFile;
 };
 
 //===----------------------------------------------------------------------===//
 //  ExecutableWriter
 //===----------------------------------------------------------------------===//
 
 /// \brief Add absolute symbols by default. These are linker added
 /// absolute symbols
if (this->_context.isRelaOutputFormat()) {
     _runtimeFile->addAbsoluteAtom("__rela_iplt_start");
     _runtimeFile->addAbsoluteAtom("__rela_iplt_end");
   } else {
     _runtimeFile->addAbsoluteAtom("__rel_iplt_start");
     _runtimeFile->addAbsoluteAtom("__rel_iplt_end");
   }
   _runtimeFile->addAbsoluteAtom("__fini_array_start");
   _runtimeFile->addAbsoluteAtom("__fini_array_end");
+  if (this->_context.isDynamic())
+    _dynamicInterpreterFile->addAtom(
+        *new (this->_alloc) TLSGETADDRAtom(*_dynamicInterpreterFile));
 }
 
 /// \brief Hook in lld to add CRuntime file
 template <class ELFT>
 bool ExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File> > &result) {
   // Add the default atoms as defined by executables
   ExecutableWriter<ELFT>::addDefaultAtoms();
   OutputELFWriter<ELFT>::createImplicitFiles(result);
   result.push_back(std::move(_runtimeFile));
+  result.push_back(std::move(_dynamicInterpreterFile));
   return true;
 }
 
 template <class ELFT> void ExecutableWriter<ELFT>::createDefaultSections() {
   OutputELFWriter<ELFT>::createDefaultSections();
   if (this->_context.isDynamic()) {
     _interpSection.reset(new (this->_alloc) InterpSection<ELFT>(
         this->_context, ".interp", DefaultLayout<ELFT>::ORDER_INTERP,

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

public:
   }
 
   ErrorOr<const lld::AtomLayout &> addAtom(const Atom *atom) override {
     // Maintain:
     // 1. Set of shared library atoms referenced by regular defined atoms.
     // 2. Set of shared library atoms have corresponding R_MIPS_COPY copies.
     if (const auto *da = dyn_cast<DefinedAtom>(atom))
       for (const Reference *ref : *da) {
-        if (const auto *sla = dyn_cast<SharedLibraryAtom>(ref->target()))
-          _referencedDynAtoms.insert(sla);
-
         if (ref->kindNamespace() == lld::Reference::KindNamespace::ELF) {
           assert(ref->kindArch() == Reference::KindArch::Mips);
           if (ref->kindValue() == llvm::ELF::R_MIPS_COPY)
             _copiedDynSymNames.insert(atom->name());
         }
       }
 
     return TargetLayout<ELFType>::addAtom(atom);
   }
 
-  bool isReferencedByDefinedAtom(const SharedLibraryAtom *sla) const {
-    return _referencedDynAtoms.count(sla);
-  }
-
   bool isCopied(const SharedLibraryAtom *sla) const {
     return _copiedDynSymNames.count(sla->name());
   }
 
   /// \brief GP offset relative to .got section.
   uint64_t getGPOffset() const { return 0x7FF0; }
 
   /// \brief Get '_gp' symbol atom layout.
public:
   }
 
 private:
   llvm::BumpPtrAllocator _alloc;
   MipsGOTSection<ELFType> *_gotSection;
   MipsPLTSection<ELFType> *_pltSection;
   llvm::Optional<AtomLayout *> _gpAtom;
   llvm::Optional<AtomLayout *> _gpDispAtom;
-  llvm::DenseSet<const SharedLibraryAtom *> _referencedDynAtoms;
   llvm::StringSet<> _copiedDynSymNames;
 };
 
 /// \brief Mips Runtime file.
 template <class ELFType>
 class MipsRuntimeFile final : public CRuntimeFile<ELFType> {
 public:
   MipsRuntimeFile(const MipsLinkingContext &ctx)

lib/ReaderWriter/ELF/OutputELFWriter.h

protected:
   virtual LLD_UNIQUE_BUMP_PTR(DynamicTable<ELFT>) createDynamicTable();
 
   /// \brief create dynamic symbol table.
   virtual LLD_UNIQUE_BUMP_PTR(DynamicSymbolTable<ELFT>)
       createDynamicSymbolTable();
 
   /// \brief Create entry in the dynamic symbols table for this atom.
   virtual bool isDynSymEntryRequired(const SharedLibraryAtom *sla) const {
-    return true;
+    return _layout.isReferencedByDefinedAtom(sla);
   }
 
   /// \brief Create DT_NEEDED dynamic tage for the shared library.
   virtual bool isNeededTagRequired(const SharedLibraryAtom *sla) const {
+    // No need to mark dynamic interpreter's own atoms as needed
+    if (sla->loadName() == "_ld_so")
+      return false;
     return true;
   }
 
   llvm::BumpPtrAllocator _alloc;
 
   const ELFLinkingContext &_context;
   TargetHandler<ELFT> &_targetHandler;
 

 template <class ELFT>
 void OutputELFWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
   ScopedTask task(getDefaultDomain(), "buildDynamicSymbolTable");
   for (auto sec : this->_layout.sections())
     if (auto section = dyn_cast<AtomSection<ELFT>>(sec))
       for (const auto &atom : section->atoms()) {
         const DefinedAtom *da = dyn_cast<const DefinedAtom>(atom->_atom);
         if (da && (da->dynamicExport() == DefinedAtom::dynamicExportAlways ||
-                   _context.hasCoalescedSharedLibPair(da->name())))
+                   _context.isDynamicallyExportedSymbol(da->name())))
           _dynamicSymbolTable->addSymbol(atom->_atom, section->ordinal(),
                                          atom->_virtualAddr, atom);
       }
   for (const auto &sla : file.sharedLibrary()) {
     if (isDynSymEntryRequired(sla))
       _dynamicSymbolTable->addSymbol(sla, ELF::SHN_UNDEF);
     if (isNeededTagRequired(sla))
       _soNeeded.insert(sla->loadName());

lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h

: DynamicLibraryWriter<ELFT>(context, layout),
       _gotFile(new GOTFile(context)), _context(context), _x86_64Layout(layout) {
 }
 
 template <class ELFT>
 bool X86_64DynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GLOBAL_OFFSET_TABLEAtom(*_gotFile));
-  _gotFile->addAtom(*new (_gotFile->_alloc) TLSGETADDRAtom(*_gotFile));
   _gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
   return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h

X86_64ExecutableWriter<ELFT>::X86_64ExecutableWriter(
     : ExecutableWriter<ELFT>(context, layout), _gotFile(new GOTFile(context)),
       _context(context), _x86_64Layout(layout) {}
 
 template <class ELFT>
 bool X86_64ExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GLOBAL_OFFSET_TABLEAtom(*_gotFile));
-  _gotFile->addAtom(*new (_gotFile->_alloc) TLSGETADDRAtom(*_gotFile));
   if (_context.isDynamic())
     _gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
   return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.h

bool isDynamicRelocation(const DefinedAtom &,
                            const Reference &r) const override {
     if (r.kindNamespace() != Reference::KindNamespace::ELF)
       return false;
     assert(r.kindArch() == Reference::KindArch::x86_64);
     switch (r.kindValue()) {
     case llvm::ELF::R_X86_64_RELATIVE:
     case llvm::ELF::R_X86_64_GLOB_DAT:
     case llvm::ELF::R_X86_64_COPY:
+    case llvm::ELF::R_X86_64_DTPMOD64:
+    case llvm::ELF::R_X86_64_DTPOFF64:
       return true;
     default:
       return false;
     }
   }
 
   virtual bool isPLTRelocation(const DefinedAtom &,
                                const Reference &r) const override {

lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.cpp

if (ref.kindValue() == R_X86_64_TPOFF32 ||
       int32_t result = (int32_t)(targetVAddress - _tlsSize);
       *reinterpret_cast<llvm::support::little32_t *>(location) = result;
     } else {
       int64_t result = (int64_t)(targetVAddress - _tlsSize);
       *reinterpret_cast<llvm::support::little64_t *>(location) = result;
     }
     break;
   }
+  case R_X86_64_TLSGD: {
+    relocPC32(location, relocVAddress, targetVAddress, ref.addend());
+    break;
+  }
   case R_X86_64_TLSLD: {
     // Rewrite to move %fs:0 into %rax. Technically we should verify that the
     // next relocation is a PC32 to __tls_get_addr...
     static uint8_t instr[] = { 0x66, 0x66, 0x66, 0x64, 0x48, 0x8b, 0x04, 0x25,
                                0x00, 0x00, 0x00, 0x00 };
     std::memcpy(location - 3, instr, sizeof(instr));
     break;
   }
case LLD_R_X86_64_GOTRELINDEX: {
     }
     break;
   }
   // Runtime only relocations. Ignore here.
   case R_X86_64_RELATIVE:
   case R_X86_64_IRELATIVE:
   case R_X86_64_JUMP_SLOT:
   case R_X86_64_GLOB_DAT:
+  case R_X86_64_DTPMOD64:
+  case R_X86_64_DTPOFF64:
     break;
   default: {
     std::string str;
     llvm::raw_string_ostream s(str);
     s << "Unhandled relocation: " << atom._atom->file().path() << ":"
       << atom._atom->name() << "@" << ref.offsetInAtom() << " "
       << "#" << ref.kindValue();
     s.flush();
     llvm_unreachable(str.c_str());
   }
   }
 
   return std::error_code();
 }

lib/ReaderWriter/ELF/X86_64/X86_64RelocationPass.cpp

 
 // .plt values (other entries)
 const uint8_t x86_64PltAtomContent[16] = {
   0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmpq *gotatom(%rip)
   0x68, 0x00, 0x00, 0x00, 0x00,       // pushq reloc-index
   0xe9, 0x00, 0x00, 0x00, 0x00        // jmpq plt[-1]
 };
 
+// TLS GD Entry
+static const uint8_t x86_64GotTlsGdAtomContent[] = {
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
 /// \brief Atoms that are used by X86_64 dynamic linking
 class X86_64GOTAtom : public GOTAtom {
 public:
   X86_64GOTAtom(const File &f, StringRef secName) : GOTAtom(f, secName) {}
 
   ArrayRef<uint8_t> rawContent() const override {
     return ArrayRef<uint8_t>(x86_64GotAtomContent, 8);
   }
 };
 
+/// \brief X86_64 GOT TLS GD entry.
+class GOTTLSGdAtom : public X86_64GOTAtom {
+public:
+  GOTTLSGdAtom(const File &f, StringRef secName) : X86_64GOTAtom(f, secName) {}
+
+  ArrayRef<uint8_t> rawContent() const override {
+    return llvm::makeArrayRef(x86_64GotTlsGdAtomContent);
+  }
+};
+
 class X86_64PLT0Atom : public PLT0Atom {
 public:
   X86_64PLT0Atom(const File &f) : PLT0Atom(f) {
 #ifndef NDEBUG
     _name = ".PLT0";
 #endif
   }
   ArrayRef<uint8_t> rawContent() const override {
void handleReference(const DefinedAtom &atom, const Reference &ref) {
     case R_X86_64_GOTPC32:
     case R_X86_64_GOTPCREL:
     case R_X86_64_GOTOFF64:
       static_cast<Derived *>(this)->handleGOT(ref);
       break;
     case R_X86_64_GOTTPOFF: // GOT Thread Pointer Offset
       static_cast<Derived *>(this)->handleGOTTPOFF(ref);
       break;
+    case R_X86_64_TLSGD:
+      static_cast<Derived *>(this)->handleTLSGd(ref);
+      break;
     }
   }
 
 protected:
   /// \brief get the PLT entry for a given IFUNC Atom.
   ///
   /// If the entry does not exist. Both the GOT and PLT entry is created.
   const PLTAtom *getIFUNCPLTEntry(const DefinedAtom *da) {
#endif
 
   /// \brief Create a TPOFF64 GOT entry and change the relocation to a PC32 to
   /// the GOT.
   void handleGOTTPOFF(const Reference &ref) {
     const_cast<Reference &>(ref).setTarget(getGOTTPOFF(ref.target()));
     const_cast<Reference &>(ref).setKindValue(R_X86_64_PC32);
   }
 
+  /// \brief Create a TLS GOT entry with DTPMOD64/DTPOFF64 dynamic relocations.
+  void handleTLSGd(const Reference &ref) {
+    const_cast<Reference &>(ref).setTarget(getTLSGdGOTEntry(ref.target()));
+  }
+
   /// \brief Create a GOT entry containing 0.
   const GOTAtom *getNullGOT() {
     if (!_null) {
       _null = new (_file._alloc) X86_64GOTAtom(_file, ".got.plt");
 #ifndef NDEBUG
       _null->_name = "__got_null";
 #endif
     }

 #endif
       _gotMap[da] = g;
       _gotVector.push_back(g);
       return g;
     }
     return got->second;
   }
 
+  const GOTAtom *getTLSGdGOTEntry(const Atom *a) {
+    auto got = _gotTLSGdMap.find(a);
+    if (got != _gotTLSGdMap.end())
+      return got->second;
+
+    auto ga = new (_file._alloc) GOTTLSGdAtom(_file, ".got");
+    _gotTLSGdMap[a] = ga;
+
+    _tlsGotVector.push_back(ga);
+    ga->addReferenceELF_x86_64(R_X86_64_DTPMOD64, 0, a, 0);
+    ga->addReferenceELF_x86_64(R_X86_64_DTPOFF64, 8, a, 0);
+
+    return ga;
+  }
+
 public:
   RelocationPass(const ELFLinkingContext &ctx)
       : _file(ctx), _ctx(ctx), _null(nullptr), _PLT0(nullptr), _got0(nullptr),
         _got1(nullptr) {}
 
   /// \brief Do the pass.
   ///
   /// The goal here is to first process each reference individually. Each call
if (_PLT0) {
       _got1->setOrdinal(ordinal++);
       mf->addAtom(*_got0);
       mf->addAtom(*_got1);
     }
     for (auto &got : _gotVector) {
       got->setOrdinal(ordinal++);
       mf->addAtom(*got);
     }
+    for (auto &got : _tlsGotVector) {
+      got->setOrdinal(ordinal++);
+      mf->addAtom(*got);
+    }
     for (auto obj : _objectVector) {
       obj->setOrdinal(ordinal++);
       mf->addAtom(*obj);
     }
   }
 
 protected:
   /// \brief Owner of all the Atoms created by this pass.
   ELFPassFile _file;
   const ELFLinkingContext &_ctx;
 
   /// \brief Map Atoms to their GOT entries.
   llvm::DenseMap<const Atom *, GOTAtom *> _gotMap;
 
   /// \brief Map Atoms to their PLT entries.
   llvm::DenseMap<const Atom *, PLTAtom *> _pltMap;
 
+  /// \brief Map Atoms to TLS GD GOT entries.
+  llvm::DenseMap<const Atom *, GOTAtom *> _gotTLSGdMap;
+
   /// \brief Map Atoms to their Object entries.
   llvm::DenseMap<const Atom *, ObjectAtom *> _objectMap;
 
   /// \brief the list of GOT/PLT atoms
   std::vector<GOTAtom *> _gotVector;
   std::vector<PLTAtom *> _pltVector;
   std::vector<ObjectAtom *> _objectVector;
 
+  /// \brief the list of TLS GOT atoms.
+  std::vector<GOTAtom *> _tlsGotVector;
+
   /// \brief GOT entry that is always 0. Used for undefined weaks.
   GOTAtom *_null;
 
   /// \brief The got and plt entries for .PLT0. This is used to call into the
   /// dynamic linker for symbol resolution.
   /// @{
   PLT0Atom *_PLT0;
   GOTAtom *_got0;

test/elf/X86_64/Inputs/generaltls-so.o.yaml

+---
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  OSABI:           ELFOSABI_GNU
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000010
+    Content:         554889E566488D3D00000000666648E8000000008B005DC3
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x0000000000000008
+    Info:            .text
+    Relocations:
+      - Offset:          0x0000000000000008
+        Symbol:          mynumber
+        Type:            R_X86_64_TLSGD
+        Addend:          -4
+      - Offset:          0x0000000000000010
+        Symbol:          __tls_get_addr
+        Type:            R_X86_64_PLT32
+        Addend:          -4
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         ''
+  - Name:            .tdata
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC, SHF_TLS ]
+    AddressAlign:    0x0000000000000004
+    Content:         '21000000'
+Symbols:
+  Local:
+    - Name:            .text
+      Type:            STT_SECTION
+      Section:         .text
+    - Name:            .data
+      Type:            STT_SECTION
+      Section:         .data
+    - Name:            .bss
+      Type:            STT_SECTION
+      Section:         .bss
+    - Name:            .tdata
+      Type:            STT_SECTION
+      Section:         .tdata
+  Global:
+    - Name:            getnumber
+      Type:            STT_FUNC
+      Section:         .text
+      Size:            0x0000000000000018
+    - Name:            mynumber
+      Type:            STT_TLS
+      Section:         .tdata
+      Size:            0x0000000000000004
+    - Name:            _GLOBAL_OFFSET_TABLE_
+    - Name:            __tls_get_addr
+...

test/elf/X86_64/general-dynamic-tls.test

+# This test exercises a simple general dynamic TLS access model in X86_64.
+#
+# It is composed of two parts: a program and a shared library. The shared
+# library uses TLS, but the program does not.
+#
+# The shared library should import __tls_get_addr, since it uses the general
+# dynamic TLS access mode (see www.akkadia.org/drepper/tls.pdf). Notice that
+# once we support TLS strength reduction, this test should be updated, since
+# this can be converted into a local dynamic TLS model.
+
+# Prepare inputs
+#RUN: yaml2obj -format=elf %p/Inputs/generaltls-so.o.yaml -o=%t.o.so
+#RUN: lld -flavor gnu  -target x86_64 -shared %t.o.so -o %T/libgeneraltls.so
+#RUN: yaml2obj -format=elf %s -o=%t.o
+
+# Link
+#RUN: lld -flavor gnu  -target x86_64 -e main %t.o -L%T -lgeneraltls -o %t1
+
+# Check
+#RUN: llvm-readobj -dyn-symbols %t1 | FileCheck -check-prefix CHECKPROG %s
+#RUN: llvm-readobj -relocations -dyn-symbols %T/libgeneraltls.so | FileCheck \
+#RUN:     -check-prefix CHECKDSO %s
+
+# Test case generated with the following code:
+#
+# DSO: (file %p/Inputs/generaltls-so.o.yaml)
+#
+# __thread int mynumber=33;
+#
+# int getnumber() {
+#     return mynumber;
+# }
+#
+# Program: (this file). Note: The printf() relocation was removed to simplify
+# this test and allow us to test this without libc.
+#
+# #include <stdio.h>
+# int getnumber();
+#
+# int main() {
+#     printf("getnumber() = %d\n", getnumber());
+#     return 0;
+# }
+#
+---
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  OSABI:           ELFOSABI_GNU
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000010
+    Content:         554889E54883EC10C745FC00000000B000E80000000048BF000000000000000089C6B000E80000000031F68945F889F04883C4105DC3
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x0000000000000008
+    Info:            .text
+    Relocations:
+      - Offset:          0x0000000000000012
+        Symbol:          getnumber
+        Type:            R_X86_64_PC32
+        Addend:          -4
+      - Offset:          0x0000000000000018
+        Symbol:          .rodata.str1.1
+        Type:            R_X86_64_64
+        Addend:          0
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         ''
+  - Name:            .rodata.str1.1
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_MERGE, SHF_STRINGS ]
+    AddressAlign:    0x0000000000000001
+    Content:         6765746E756D6265722829203D2025640A00
+Symbols:
+  Local:
+    - Name:            .text
+      Type:            STT_SECTION
+      Section:         .text
+    - Name:            .data
+      Type:            STT_SECTION
+      Section:         .data
+    - Name:            .bss
+      Type:            STT_SECTION
+      Section:         .bss
+    - Name:            .rodata.str1.1
+      Type:            STT_SECTION
+      Section:         .rodata.str1.1
+  Global:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Size:            0x0000000000000036
+    - Name:            getnumber
+
+# Program should import the function defined in the shared library
+#CHECKPROG: getnumber@
+# Program should not import __tls_get_addr, since it does not directly use TLS
+#CHECKPROG-NOT: __tls_get_addr@
+
+# Check for the presence of X86_64 TLS relocations in the shared library
+#CHECKDSO: R_X86_64_DTPMOD64
+#CHECKDSO: R_X86_64_DTPOFF64
+
+# The shared library should import __tls_get_addr, since it uses the general
+# dynamic TLS access mode.
+#CHECKDSO:          Name: __tls_get_addr@
+#CHECKDSO-NEXT:     Value: 0x0
+#CHECKDSO-NEXT:     Size: 0
+#CHECKDSO-NEXT:     Binding: Global
+#CHECKDSO-NEXT:     Type: None
+#CHECKDSO-NEXT:     Other: 0
+#CHECKDSO-NEXT:     Section: Undefined
+

test/elf/X86_64/omagic.test

 OMAGICSECTIONS:  }
 OMAGICSECTIONS:  Section {
 OMAGICSECTIONS:    Name: .symtab
 OMAGICSECTIONS:    Type: SHT_SYMTAB (0x2)
 OMAGICSECTIONS:    Flags [ (0x0)
 OMAGICSECTIONS:    ]
 OMAGICSECTIONS:    Address: 0x0
 OMAGICSECTIONS:    Offset: 0x1E8
-OMAGICSECTIONS:    Size: 528
+OMAGICSECTIONS:    Size: 504
 OMAGICSECTIONS:    Link: 13
 OMAGICSECTIONS:    Info: 2
 OMAGICSECTIONS:    AddressAlignment: 8
 OMAGICSECTIONS:    EntrySize: 24
 OMAGICSECTIONS:  }
 OMAGICSECTIONS:  Section {
 OMAGICSECTIONS:    Name: .strtab
 OMAGICSECTIONS:    Type: SHT_STRTAB (0x3)
 OMAGICSECTIONS:    Flags [ (0x0)
 OMAGICSECTIONS:    ]
 OMAGICSECTIONS:    Address: 0x0
-OMAGICSECTIONS:    Offset: 0x3F8
-OMAGICSECTIONS:    Size: 246
+OMAGICSECTIONS:    Offset: 0x3E0
+OMAGICSECTIONS:    Size: 231
 OMAGICSECTIONS:    Link: 0
 OMAGICSECTIONS:    Info: 0
 OMAGICSECTIONS:    AddressAlignment: 1
 OMAGICSECTIONS:    EntrySize: 0
 OMAGICSECTIONS:  }
 OMAGICSECTIONS:  ]
 
 OMAGICPROGRAMHEADERS: ProgramHeaders [

test/elf/X86_64/undef.test

 # This tests the functionality that an undefined symbol thats defined in the
 # commmand line pulls in the required object file from the archive library
 # which is usually the usecase for it
 RUN: lld -flavor gnu -target x86_64 -u fn %p/Inputs/libfn.a -o %t --noinhibit-exec
 RUN: llvm-readobj -symbols %t | FileCheck -check-prefix=SYMFROMARCHIVE %s
 RUN: lld -flavor gnu -target x86_64 %p/Inputs/libfn.a -o %t --noinhibit-exec
 RUN: llvm-readobj -symbols %t | FileCheck %s
 
 SYMFROMARCHIVE:  Symbol {
-SYMFROMARCHIVE:    Name: fn (16)
+SYMFROMARCHIVE:    Name: fn ({{[0-9]+}}
 SYMFROMARCHIVE:    Size: 11
 SYMFROMARCHIVE:    Binding: Global (0x1)
 SYMFROMARCHIVE:    Type: Function (0x2)
 SYMFROMARCHIVE:    Other: 0
 SYMFROMARCHIVE:    Section: .text
 SYMFROMARCHIVE:  }
 
 CHECK-NOT: Name: fn

test/elf/X86_64/underscore-end.test

 # This tests verifies that the value of _end symbol is point to the right value
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/nmagic.o  \
 RUN: --noinhibit-exec -o %t --nmagic
 RUN: llvm-readobj -symbols %t | FileCheck -check-prefix=NMAGICABSSYMBOLS %s
 RUN: lld -flavor gnu -target x86_64-linux %p/Inputs/nmagic.o  \
 RUN: --noinhibit-exec -o %t --omagic
 RUN: llvm-readobj -symbols %t | FileCheck -check-prefix=OMAGICABSSYMBOLS %s
 
 NMAGICABSSYMBOLS:  Symbol {
-NMAGICABSSYMBOLS:    Name: __bss_start (51)
+NMAGICABSSYMBOLS:    Name: __bss_start ({{[0-9]+}}
 NMAGICABSSYMBOLS:    Value: 0x40100C
 NMAGICABSSYMBOLS:    Size: 0
 NMAGICABSSYMBOLS:    Binding: Global (0x1)
 NMAGICABSSYMBOLS:    Type: Object (0x1)
 NMAGICABSSYMBOLS:    Other: 0
 NMAGICABSSYMBOLS:    Section: Absolute (0xFFF1)
 NMAGICABSSYMBOLS:  }
 NMAGICABSSYMBOLS:  Symbol {
-NMAGICABSSYMBOLS:    Name: __bss_end (63)
+NMAGICABSSYMBOLS:    Name: __bss_end ({{[0-9]+}}
 NMAGICABSSYMBOLS:    Value: 0x40100C
 NMAGICABSSYMBOLS:    Size: 0
 NMAGICABSSYMBOLS:    Binding: Global (0x1)
 NMAGICABSSYMBOLS:    Type: Object (0x1)
 NMAGICABSSYMBOLS:    Other: 0
 NMAGICABSSYMBOLS:    Section: Absolute (0xFFF1)
 NMAGICABSSYMBOLS:  }
 NMAGICABSSYMBOLS:  Symbol {
-NMAGICABSSYMBOLS:    Name: _end (73)
+NMAGICABSSYMBOLS:    Name: _end ({{[0-9]+}}
 NMAGICABSSYMBOLS:    Value: 0x40100C
 NMAGICABSSYMBOLS:    Size: 0
 NMAGICABSSYMBOLS:    Binding: Global (0x1)
 NMAGICABSSYMBOLS:    Type: Object (0x1)
 NMAGICABSSYMBOLS:    Other: 0
 NMAGICABSSYMBOLS:    Section: Absolute (0xFFF1)
 NMAGICABSSYMBOLS:  }
 NMAGICABSSYMBOLS:  Symbol {
-NMAGICABSSYMBOLS:    Name: end (78)
+NMAGICABSSYMBOLS:    Name: end ({{[0-9]+}}
 NMAGICABSSYMBOLS:    Value: 0x40100C
 NMAGICABSSYMBOLS:    Size: 0
 NMAGICABSSYMBOLS:    Binding: Global (0x1)
 NMAGICABSSYMBOLS:    Type: Object (0x1)
 NMAGICABSSYMBOLS:    Other: 0
 NMAGICABSSYMBOLS:    Section: Absolute (0xFFF1)
 NMAGICABSSYMBOLS:  }
 
 OMAGICABSSYMBOLS:  Symbol {
-OMAGICABSSYMBOLS:    Name: __bss_start (51)
+OMAGICABSSYMBOLS:    Name: __bss_start ({{[0-9]+}})
 OMAGICABSSYMBOLS:    Value: 0x400144
 OMAGICABSSYMBOLS:    Size: 0
 OMAGICABSSYMBOLS:    Binding: Global (0x1)
 OMAGICABSSYMBOLS:    Type: Object (0x1)
 OMAGICABSSYMBOLS:    Other: 0
 OMAGICABSSYMBOLS:    Section: Absolute (0xFFF1)
 OMAGICABSSYMBOLS:  }
 OMAGICABSSYMBOLS:  Symbol {
-OMAGICABSSYMBOLS:    Name: __bss_end (63)
+OMAGICABSSYMBOLS:    Name: __bss_end ({{[0-9]+}}
 OMAGICABSSYMBOLS:    Value: 0x400144
 OMAGICABSSYMBOLS:    Size: 0
 OMAGICABSSYMBOLS:    Binding: Global (0x1)
 OMAGICABSSYMBOLS:    Type: Object (0x1)
 OMAGICABSSYMBOLS:    Other: 0
 OMAGICABSSYMBOLS:    Section: Absolute (0xFFF1)
 OMAGICABSSYMBOLS:  }
 OMAGICABSSYMBOLS:  Symbol {
-OMAGICABSSYMBOLS:    Name: _end (73)
+OMAGICABSSYMBOLS:    Name: _end ({{[0-9]+}}
 OMAGICABSSYMBOLS:    Value: 0x400144
 OMAGICABSSYMBOLS:    Size: 0
 OMAGICABSSYMBOLS:    Binding: Global (0x1)
 OMAGICABSSYMBOLS:    Type: Object (0x1)
 OMAGICABSSYMBOLS:    Other: 0
 OMAGICABSSYMBOLS:    Section: Absolute (0xFFF1)
 OMAGICABSSYMBOLS:  }
 OMAGICABSSYMBOLS:  Symbol {
-OMAGICABSSYMBOLS:    Name: end (78)
+OMAGICABSSYMBOLS:    Name: end ({{[0-9]+}}
 OMAGICABSSYMBOLS:    Value: 0x400144
 OMAGICABSSYMBOLS:    Size: 0
 OMAGICABSSYMBOLS:    Binding: Global (0x1)
 OMAGICABSSYMBOLS:    Type: Object (0x1)
 OMAGICABSSYMBOLS:    Other: 0
 OMAGICABSSYMBOLS:    Section: Absolute (0xFFF1)
 OMAGICABSSYMBOLS:  }

test/elf/undef-from-main-dso.test

 CHECK:         Name: x@ ({{[0-9]+}}
 CHECK-NEXT:    Value: 0x{{[1-9A-F][0-9A-F]*}}
 CHECK-NEXT:    Size: 8
 CHECK-NEXT:    Binding: Global (0x1)
 CHECK-NEXT:    Type: Object (0x1)
 CHECK-NEXT:    Other: 0
 CHECK-NEXT:    Section: .bss
 
-CHECK:         Name: x@ ({{[0-9]+}}