[ELF] - Create _DYNAMIC symbol for dynamic output

[grimar]

Summary

lld needs to provide _DYNAMIC symbol when creating a shared library
both bfd and gold do that.

This should fix the https://llvm.org/bugs/show_bug.cgi?id=26732

[emaste]

I'm seeing strange test failures in my self-hosted lld testrun with this patch applied.

Test process is:

1. cd 1st stage build dir, configured with FreeBSD host compiler (Clang 3.4.1) and ld.bfd (2.17.50)
2. ninja lld
3. ninja check-lld
4. cd 2nd stage build dir, configured with FreeBSD host compiler (Clang 3.4.1) and ld.lld from (2)
5. ninja lld
6. ninja check-lld

(3) passes, (6) fails in strange ways, for example:

********************
FAIL: lld :: COFF/entrylib.ll (33 of 1003)
******************** TEST 'lld :: COFF/entrylib.ll' FAILED ********************
Script:
--
llvm-as -o /tank/emaste/src/llvm/build-lld-selfhost2/tools/lld/test/COFF/Output/entrylib.ll.tmp.obj /tank/emaste/src/llvm/tools/lld/test/COFF/entrylib.ll
rm -f /tank/emaste/src/llvm/build-lld-selfhost2/tools/lld/test/COFF/Output/entrylib.ll.tmp.lib
llvm-ar cru /tank/emaste/src/llvm/build-lld-selfhost2/tools/lld/test/COFF/Output/entrylib.ll.tmp.lib /tank/emaste/src/llvm/build-lld-selfhost2/tools/lld/test/COFF/Output/entrylib.ll.tmp.obj
/tank/emaste/src/llvm/build-lld-selfhost2/./bin/lld-link /out:/tank/emaste/src/llvm/build-lld-selfhost2/tools/lld/test/COFF/Output/entrylib.ll.tmp.exe /entry:main /tank/emaste/src/llvm/build-lld-selfhost2/tools/lld/test/COFF/Output/entrylib.ll.tmp.lib
--
Exit Code: 134

Command Output (stderr):
--
warning: /machine is not specified. x64 is assumed.
Assertion failed: (Str && "StringRef cannot be built from a NULL argument"), function StringRef, file ../include/llvm/ADT/StringRef.h, line 73.
#0 0x0000000000f3fd8e llvm::sys::PrintStackTrace(llvm::raw_ostream&) (/tank/emaste/src/llvm/build-lld-selfhost2/bin/lld+0xf3fd8e)
#1 0x0000000000f40199 PrintStackTraceSignalHandler(void*) (/tank/emaste/src/llvm/build-lld-selfhost2/bin/lld+0xf40199)
#2 0x0000000000f3ca97 llvm::sys::RunSignalHandlers(void) (/tank/emaste/src/llvm/build-lld-selfhost2/bin/lld+0xf3ca97)
#3 0x0000000000f405cc SignalHandler(int) (/tank/emaste/src/llvm/build-lld-selfhost2/bin/lld+0xf405cc)
#4 0x00000008046f695a handle_signal /tank/emaste/src/git-stable-10/lib/libthr/thread/thr_sig.c:249:0
#5 0x00000008046f6158 thr_sighandler /tank/emaste/src/git-stable-10/lib/libthr/thread/thr_sig.c:189:0
/tank/emaste/src/llvm/build-lld-selfhost2/tools/lld/test/COFF/Output/entrylib.ll.script: line 4: 85785 Abort trap              (core dumped) /tank/emaste/src/llvm/build-lld-selfhost2/./bin/lld-link /out:/tank/emaste/src/llvm/build-lld-selfhost2/tools/lld/test/COFF/Output/entrylib.ll.tmp.exe /entry:main /tank/emaste/src/llvm/build-lld-selfhost2/tools/lld/test/COFF/Output/entrylib.ll.tmp.lib

--

[ruiu]

The code looks good, but please take a look at the test failure that Ed reported.

[grimar]

In D17607#361776, @emaste wrote:

I'm seeing strange test failures in my self-hosted lld testrun with this patch applied.

Hello Ed,

I just checked twice that able to self host with this patch. I am using the latest source code available for llvm,clang and lld.

Stage 1 (output to /home/umb/LLVM/build):
At first I configured the build using:
-DCMAKE_BUILD_TYPE=Release -DLLVM_PARALLEL_COMPILE_JOBS=8 -DLLVM_ENABLE_THREADS=true
It shows:

• The C compiler identification is GNU 4.9.2
• The CXX compiler identification is GNU 4.9.2

...
ninja lld, ninja check-lld works fine here.

Stage 2 (output to /home/umb/LLVM/selfhost):
Then I am configuring it for self-hosting using the binaries from stage 1:
-DCMAKE_CXX_FLAGS="-std=c++11 -fuse-ld=lld -Wl,--gc-sections" -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS=-fuse-ld=lld -DCMAKE_C_COMPILER=/home/umb/LLVM/build/bin/clang -DLLVM_PARALLEL_COMPILE_JOBS=8 -DLLVM_ENABLE_THREADS=true -DCMAKE_CXX_COMPILER=/home/umb/LLVM/build/bin/clang++
It shows:

• The C compiler identification is Clang 3.9.0
• The CXX compiler identification is Clang 3.9.0

and uses lld from stage 1 for linkage.
...
I have no troubles with ninja check-lld at this stage either:

umb@ubuntu:~/LLVM/selfhost$ ninja check-lld
[1/1] Running lld test suite
-- Testing: 1105 tests, 8 threads --
Testing: 0 .. 10.. 20.. 30.. 40.. 50.. 60.. 70.. 80.. 90.. 
Testing Time: 4.64s
  Expected Passes    : 1094
  Expected Failures  : 1
  Unsupported Tests  : 10
umb@ubuntu:~/LLVM/selfhost$

I looked at differences of bfd/gold/lld output and found the next:

gold output:

Num:    Value          Size Type    Bind   Vis      Ndx Name
1: 00000000000011e0   176 OBJECT  LOCAL  HIDDEN     5 _DYNAMIC

bfd output:

6: 00000000002001a8     0 OBJECT  LOCAL  DEFAULT    5 _DYNAMIC

lld output:

1: 0000000000001000     0 NOTYPE  LOCAL  HIDDEN     5 _DYNAMIC

It seems nobody remembers why _DYNAMIC was made as object in binutils:
https://sourceware.org/ml/binutils/2002-03/msg00360.html
I am not sure if we should make it STT_OBJECT as there are seems to be no
real reasons for that.

Also there is no reason to make it hidden as bfd does not do that. Making
it default simplies the code a bit.

About why it is no able to selfhost for you - I have no ideas now, any suggestions are welcome.

[grimar]

At the same time I am not sure should _DYNAMIC have default visibility ? There is no real need in that either as it is used only for linking dynamic linker.
So gold behavior is also fine here.

[emaste]

I tried repeating the test with a new checkout, and it seems the first failure occurs with llvm-tblgen:

FAILED: cd /tank/emaste/src/llvm-lld/build-lld/include/llvm/IR && /tank/emaste/src/llvm-lld/build-lld/bin/llvm-tblgen -gen-attrs -I /tank/emaste/src/llvm-lld/include/llvm/IR -I /tank/emaste/src/llvm-lld/lib/Target -I /tank/emaste/src/llvm-lld/include /tank/emaste/src/llvm-lld/include/llvm/IR/Attributes.td -o /tank/emaste/src/llvm-lld/build-lld/include/llvm/IR/Attributes.inc.tmp
Assertion failed: (hasOptions() && "No options specified!"), function ParseCommandLineOptions, file ../lib/Support/CommandLine.cpp, line 816.
ninja: build stopped: subcommand failed.

A FreeBSD/llvm-tblgen issue was reported in PR 25539, but I have not been able to reproduce previously (prior to trying this patch).

[emaste]

I now see what change this patch introduces:

@@ -1,5 +1,5 @@
 
-build-unpatched-lld/bin/llvm-tblgen:     file format elf64-x86-64-freebsd
+build-lld/bin/llvm-tblgen:     file format elf64-x86-64-freebsd
 
 Disassembly of section .text:
 
@@ -79,7 +79,7 @@
 
 #ifdef GCRT
        atexit(_mcleanup);
-   9c05b:      b8 00 00 00 00          mov    $0x0,%eax
+   9c05b:      b8 10 01 54 00          mov    $0x540110,%eax
    9c060:      48 85 c0                test   %rax,%rax
    9c063:      74 0a                   je     9c06f <_start+0x6f>
        monstartup(&eprol, &etext);
@@ -95,7 +95,7 @@
        size_t array_size, n;
 
        if (&_DYNAMIC != NULL)
-   9c074:      b8 00 00 00 00          mov    $0x0,%eax
+   9c074:      b8 10 01 54 00          mov    $0x540110,%eax
    9c079:      48 85 c0                test   %rax,%rax
    9c07c:      0f 85 df 00 00 00       jne    9c161 <_start+0x161>
                return;

That is, the patch fixes _DYNAMIC and it's now being set properly. So there's probably not a bug in this patch, but rather by fixing this we expose a different bug that affects FreeBSD.

[grimar]

In D17607#362988, @emaste wrote:

That is, the patch fixes _DYNAMIC and it's now being set properly. So there's probably not a bug in this patch, but rather by fixing this we expose a different bug that affects FreeBSD.

So I am not sure what will be correct then: can we commit this even if it is introduces such regression issues on BSD ? Or we need to fix them first ?
(Selfhosting under Ubuntu works fine with this.)

[emaste]

can we commit this even if it is introduces such regression issues on BSD

I think we should; I think it must have somehow been working by accident before (without _DYNAMIC). We just need to find and fix the real bug that this now exposes. @davide, what do you think?

[• rafael]

I will try to reproduce the issue.

[• rafael]

It should be safe to land this now.

[• rafael]

lgtm

[emaste]

Thanks @rafael, looks good here now.

ELF/SymbolTable.h

public:
   const std::vector<std::unique_ptr<SharedFile<ELFT>>> &getSharedFiles() const {
     return SharedFiles;
   }
 
   SymbolBody *addUndefined(StringRef Name);
   SymbolBody *addUndefinedOpt(StringRef Name);
   SymbolBody *addAbsolute(StringRef Name, Elf_Sym &ESym);
   SymbolBody *addSynthetic(StringRef Name, OutputSectionBase<ELFT> &Section,
-                           uintX_t Value);
+                           uintX_t Value, uint8_t Visibility);
   SymbolBody *addIgnored(StringRef Name);
 
   void scanShlibUndefined();
   SymbolBody *find(StringRef Name);
   void wrap(StringRef Name);
   ELFFileBase<ELFT> *findFile(SymbolBody *B);
 
 private:

ELF/SymbolTable.cpp

SymbolBody *SymbolTable<ELFT>::addAbsolute(StringRef Name, Elf_Sym &ESym) {
   // Pass nullptr because absolute symbols have no corresponding input sections.
   auto *Sym = new (Alloc) DefinedRegular<ELFT>(Name, ESym, nullptr);
   resolve(Sym);
   return Sym;
 }
 
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addSynthetic(StringRef Name,
-                                            OutputSectionBase<ELFT> &Section,
-                                            uintX_t Value) {
-  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, Value, Section);
+                                            OutputSectionBase<ELFT> &Sec,
+                                            uintX_t Val, uint8_t Visibility) {
+  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, Val, Sec, Visibility);
   resolve(Sym);
   return Sym;
 }
 
 // Add Name as an "ignored" symbol. An ignored symbol is a regular
 // linker-synthesized defined symbol, but it is not recorded to the output
 // file's symbol table. Such symbols are useful for some linker-defined symbols.
 template <class ELFT>

ELF/Symbols.h

 // DefinedSynthetic is a class to represent linker-generated ELF symbols.
 // The difference from the regular symbol is that DefinedSynthetic symbols
 // don't belong to any input files or sections. Thus, its constructor
 // takes an output section to calculate output VA, etc.
 template <class ELFT> class DefinedSynthetic : public Defined {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
-  DefinedSynthetic(StringRef N, uintX_t Value,
-                   OutputSectionBase<ELFT> &Section);
+  DefinedSynthetic(StringRef N, uintX_t Value, OutputSectionBase<ELFT> &Section,
+                   uint8_t Visibility);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedSyntheticKind;
   }
 
   uintX_t Value;
   const OutputSectionBase<ELFT> &Section;
 };

ELF/Symbols.cpp

 UndefinedElf<ELFT>::UndefinedElf(StringRef N, const Elf_Sym &Sym)
     : Undefined(SymbolBody::UndefinedElfKind, N,
                 Sym.getBinding() == llvm::ELF::STB_WEAK, Sym.getVisibility(),
                 Sym.getType() == llvm::ELF::STT_TLS),
       Sym(Sym) {}
 
 template <typename ELFT>
 DefinedSynthetic<ELFT>::DefinedSynthetic(StringRef N, uintX_t Value,
-                                         OutputSectionBase<ELFT> &Section)
-    : Defined(SymbolBody::DefinedSyntheticKind, N, false, STV_DEFAULT,
+                                         OutputSectionBase<ELFT> &Section,
+                                         uint8_t Visibility)
+    : Defined(SymbolBody::DefinedSyntheticKind, N, false, Visibility,
               /*IsTls*/ false, /*IsFunction*/ false),
       Value(Value), Section(Section) {}
 
 DefinedCommon::DefinedCommon(StringRef N, uint64_t Size, uint64_t Alignment,
                              bool IsWeak, uint8_t Visibility)
     : Defined(SymbolBody::DefinedCommonKind, N, IsWeak, Visibility,
               /*IsTls*/ false, /*IsFunction*/ false) {
   MaxAlignment = Alignment;

ELF/Writer.cpp

template <class ELFT> bool Writer<ELFT>::createSections() {
   sortCtorsDtors(Factory.lookup(".dtors", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC));
 
   // The linker needs to define SECNAME_start, SECNAME_end and SECNAME_stop
   // symbols for sections, so that the runtime can get the start and end
   // addresses of each section by section name. Add such symbols.
   addStartEndSymbols();
   for (OutputSectionBase<ELFT> *Sec : RegularSections)
     addStartStopSymbols(Sec);
+  if (isOutputDynamic())
+    Symtab.addSynthetic("_DYNAMIC", *Out<ELFT>::Dynamic, 0, STV_HIDDEN);
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
 
   // Scan relocations. This must be done after every symbol is declared so that
   // we can correctly decide if a dynamic relocation is needed.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
     for (InputSectionBase<ELFT> *C : F->getSections()) {

 }
 
 // The linker is expected to define SECNAME_start and SECNAME_end
 // symbols for a few sections. This function defines them.
 template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
   auto Define = [&](StringRef Start, StringRef End,
                     OutputSectionBase<ELFT> *OS) {
     if (OS) {
-      Symtab.addSynthetic(Start, *OS, 0);
-      Symtab.addSynthetic(End, *OS, OS->getSize());
+      Symtab.addSynthetic(Start, *OS, 0, STV_DEFAULT);
+      Symtab.addSynthetic(End, *OS, OS->getSize(), STV_DEFAULT);
     } else {
       Symtab.addIgnored(Start);
       Symtab.addIgnored(End);
     }
   };
 
   Define("__preinit_array_start", "__preinit_array_end",
          Out<ELFT>::Dynamic->PreInitArraySec);
void Writer<ELFT>::addStartStopSymbols(OutputSectionBase<ELFT> *Sec) {
   StringRef S = Sec->getName();
   if (!isValidCIdentifier(S))
     return;
   StringSaver Saver(Alloc);
   StringRef Start = Saver.save("__start_" + S);
   StringRef Stop = Saver.save("__stop_" + S);
   if (SymbolBody *B = Symtab.find(Start))
     if (B->isUndefined())
-      Symtab.addSynthetic(Start, *Sec, 0);
+      Symtab.addSynthetic(Start, *Sec, 0, STV_DEFAULT);
   if (SymbolBody *B = Symtab.find(Stop))
     if (B->isUndefined())
-      Symtab.addSynthetic(Stop, *Sec, Sec->getSize());
+      Symtab.addSynthetic(Stop, *Sec, Sec->getSize(), STV_DEFAULT);
 }
 
 template <class ELFT> static bool needsPtLoad(OutputSectionBase<ELFT> *Sec) {
   if (!(Sec->getFlags() & SHF_ALLOC))
     return false;
 
   // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is
   // responsible for allocating space for them, not the PT_LOAD that

test/ELF/basic-ppc.s

 // CHECK-NEXT:     ABIVersion: 0
 // CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Type: SharedObject (0x3)
 // CHECK-NEXT:   Machine: EM_PPC (0x14)
 // CHECK-NEXT:   Version: 1
 // CHECK-NEXT:   Entry: 0x0
 // CHECK-NEXT:   ProgramHeaderOffset: 0x34
-// CHECK-NEXT:   SectionHeaderOffset: 0x2084
+// CHECK-NEXT:   SectionHeaderOffset: 0x209C
 // CHECK-NEXT:   Flags [ (0x0)
 // CHECK-NEXT:   ]
 // CHECK-NEXT:   HeaderSize: 52
 // CHECK-NEXT:   ProgramHeaderEntrySize: 32
 // CHECK-NEXT:   ProgramHeaderCount: 7
 // CHECK-NEXT:   SectionHeaderEntrySize: 40
 // CHECK-NEXT:   SectionHeaderCount: 9
 // CHECK-NEXT:   StringTableSectionIndex: 7

 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 6
 // CHECK-NEXT:     Name: .symtab (38)
 // CHECK-NEXT:     Type: SHT_SYMTAB (0x2)
 // CHECK-NEXT:     Flags [ (0x0)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x0
 // CHECK-NEXT:     Offset: 0x2030
-// CHECK-NEXT:     Size: 16
+// CHECK-NEXT:     Size: 32
 // CHECK-NEXT:     Link: 8
 // CHECK-NEXT:     Info: 1
 // CHECK-NEXT:     AddressAlignment: 4
 // CHECK-NEXT:     EntrySize: 16
 // CHECK-NEXT:     SectionData (
 // CHECK-NEXT:       0000: 00000000 00000000 00000000 00000000  |................|
+// CHECK-NEXT:       0010: 00000001 00002000 00000000 00020005  |...... .........|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 7
 // CHECK-NEXT:     Name: .shstrtab (46)
 // CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 // CHECK-NEXT:     Flags [ (0x0)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x0
-// CHECK-NEXT:     Offset: 0x2040
+// CHECK-NEXT:     Offset: 0x2050
 // CHECK-NEXT:     Size: 64
 // CHECK-NEXT:     Link: 0
 // CHECK-NEXT:     Info: 0
 // CHECK-NEXT:     AddressAlignment: 1
 // CHECK-NEXT:     EntrySize: 0
 // CHECK-NEXT:     SectionData (
 // CHECK-NEXT:       0000: 002E6479 6E73796D 002E6861 7368002E  |..dynsym..hash..|
 // CHECK-NEXT:       0010: 64796E73 7472002E 74657874 002E6479  |dynstr..text..dy|
 // CHECK-NEXT:       0020: 6E616D69 63002E73 796D7461 62002E73  |namic..symtab..s|
 // CHECK-NEXT:       0030: 68737472 74616200 2E737472 74616200  |hstrtab..strtab.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index: 8
 // CHECK-NEXT:     Name: .strtab (56)
 // CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 // CHECK-NEXT:     Flags [ (0x0)
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: 0x0
-// CHECK-NEXT:     Offset: 0x2080
+// CHECK-NEXT:     Offset: 0x2090
 // 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:       0000: 005F4459 4E414D49 4300               |._DYNAMIC.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 // CHECK-NEXT: ProgramHeaders [
 // CHECK-NEXT:   ProgramHeader {
 // CHECK-NEXT:     Type: PT_PHDR (0x6)
 // CHECK-NEXT:     Offset: 0x34
 // CHECK-NEXT:     VirtualAddress: 0x34

test/ELF/comdat.s

 // READ-NEXT:     Value
 // READ-NEXT:     Size: 0
 // READ-NEXT:     Binding: Local
 // READ-NEXT:     Type: None
 // READ-NEXT:     Other: 0
 // READ-NEXT:     Section: .text
 // READ-NEXT:   }
 // READ-NEXT:   Symbol {
+// READ-NEXT:     Name: _DYNAMIC
+// READ-NEXT:     Value: 0x2000
+// READ-NEXT:     Size: 0
+// READ-NEXT:     Binding: Local
+// READ-NEXT:     Type: None
+// READ-NEXT:     Other: 2
+// READ-NEXT:     Section: .dynamic
+// READ-NEXT:   }
+// READ-NEXT:   Symbol {
 // READ-NEXT:     Name: abc
 // READ-NEXT:     Value: 0x0
 // READ-NEXT:     Size: 0
 // READ-NEXT:     Binding: Global
 // READ-NEXT:     Type: None
 // READ-NEXT:     Other: 0
 // READ-NEXT:     Section: Undefined
 // READ-NEXT:   }
 // READ-NEXT: ]

test/ELF/discard-merge-locals.s

 // CHECK-NEXT:     Name:  (0)
 // CHECK-NEXT:     Value: 0x0
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: Undefined
 // CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: _DYNAMIC
+// CHECK-NEXT:     Value: 0x2000
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 2
+// CHECK-NEXT:     Section: .dynamic
+// CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/discard-merge-unnamed.s

 // RUN: ld.lld %p/Inputs/discard-merge-unnamed.o -o %t2 -shared
 // RUN: llvm-readobj -t %t2 | FileCheck %s
 
 // Test that the unnamed symbol is SHF_MERGE is omitted.
 
 // CHECK:      Symbols [
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name:  (0)
 // CHECK-NEXT:     Value: 0x0
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: Undefined
 // CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: _DYNAMIC
+// CHECK-NEXT:     Value: 0x2000
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 2
+// CHECK-NEXT:     Section: .dynamic
+// CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/discard-none.s

 // CHECK-NEXT:     Offset:
 // CHECK-NEXT:     Size:
 // CHECK-NEXT:     Link:
 // CHECK-NEXT:     Info:
 // CHECK-NEXT:     AddressAlignment:
 // CHECK-NEXT:     EntrySize:
 // CHECK-NEXT:     SectionData (
 // CHECK-NEXT:       0000: 002E4C6D 796F7468 65727661 72002E4C  |..Lmyothervar..L|
-// CHECK-NEXT:       0010: 6D797661 7200                        |myvar.|
+// CHECK-NEXT:       0010: 6D797661 72005F44 594E414D 494300    |myvar._DYNAMIC.|
 // CHECK-NEXT:     )
 // CHECK-NEXT:   }
 
 // CHECK:   Symbol {
 // CHECK-NEXT:     Name:
 // CHECK-NEXT:     Value: 0x0
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local

test/ELF/dynamic.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-freebsd %s -o %t.o
+
+## Check that _DYNAMIC symbol is created when creating dynamic output,
+## and has hidden visibility and address equal to .dynamic section.
+# RUN: ld.lld -shared %t.o -o %t.so
+# RUN: llvm-readobj -sections -symbols %t.so | FileCheck %s
+# CHECK:      Section {
+# CHECK:        Index: 5
+# CHECK:        Name: .dynamic
+# CHECK-NEXT:   Type: SHT_DYNAMIC
+# CHECK-NEXT:   Flags [
+# CHECK-NEXT:     SHF_ALLOC
+# CHECK-NEXT:     SHF_WRITE
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Address: 0x[[ADDR:.*]]
+# CHECK-NEXT:   Offset: 0x1000
+# CHECK-NEXT:   Size:
+# CHECK-NEXT:   Link:
+# CHECK-NEXT:   Info:
+# CHECK-NEXT:   AddressAlignment:
+# CHECK-NEXT:   EntrySize:
+# CHECK-NEXT: }
+# CHECK:      Symbols [
+# CHECK:        Symbol {
+# CHECK:          Name: _DYNAMIC
+# CHECK-NEXT:     Value: 0x[[ADDR]]
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: None
+# CHECK-NEXT:     Other: 2
+# CHECK-NEXT:     Section: .dynamic
+# CHECK-NEXT:   }
+
+# RUN: ld.lld %t.o -o %t.o
+# RUN: llvm-readobj -sections -symbols %t.o | FileCheck -check-prefix=NODYN %s
+# NODYN:    Symbols [
+# NODYN-NOT: Name: _DYNAMIC
+# NODYN:    ]
+
+.globl _start
+_start:

test/ELF/gc-sections-local-sym.s

 // CHECK-NEXT: Address:
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size:
 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
-// CHECK-NEXT:   0000: 00666F6F 00                          |.foo.|
+// CHECK-NEXT:   0000: 00666F6F 005F4459 4E414D49 4300      |.foo._DYNAMIC.|
 // CHECK-NEXT: )
 
 // CHECK:      Symbols [
 // CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name:  (0)
 // CHECK-NEXT:     Value: 0x0
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: Undefined
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: _DYNAMIC
+// CHECK-NEXT:     Value: 0x1000
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 2
+// CHECK-NEXT:     Section: .dynamic
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: foo
 // CHECK-NEXT:     Value:
 // CHECK-NEXT:     Size:
 // CHECK-NEXT:     Binding: Global
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other:
 // CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/local-dynamic.s

 // CHECK-NEXT:     Value: 0x1000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: _DYNAMIC
+// CHECK-NEXT:     Value: 0x1000
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 2
+// CHECK-NEXT:     Section: .dynamic
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: _start
 // CHECK-NEXT:     Value: 0x1000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Global
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }

test/ELF/section-symbol.s

 // CHECK-NEXT:     Name: foo
 // CHECK-NEXT:     Value:
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: _DYNAMIC
+// CHECK-NEXT:     Value:
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 2
+// CHECK-NEXT:     Section: .dynamic
+// CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 foo:
         .quad foo

test/ELF/shared.s

 // CHECK-NEXT:     Value: 0x0
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: Undefined
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: _DYNAMIC
+// CHECK-NEXT:     Value: 0x12000
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 2
+// CHECK-NEXT:     Section: .dynamic
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: _start
 // CHECK-NEXT:     Value: 0x11000
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Global
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }

test/ELF/visibility.s

 // CHECK-NEXT:     Value:
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 2
 // CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: _DYNAMIC
+// CHECK-NEXT:     Value: 0x2000
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other: 2
+// CHECK-NEXT:     Section: .dynamic
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: default
 // CHECK-NEXT:     Value:
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Global
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: .text
 // CHECK-NEXT:   }