Include version string into ".linker-version" section.

[ruiu]

Summary

This patch adds a new section, ".linker-version", to an output.
The section contains the linker's version string. You can now
find out whether a binary is created by LLD or not using objdump
command like this.

$ objdump -j .linker-version -s foo

foo:     file format elf64-x86-64

Contents of section .linker-version:
 0000 4c4c4420 342e3020 28687474 70733a2f  LLD 4.0 (https:/
 0010 2f6c6c76 6d2e6f72 672f7376 6e2f6c6c  /llvm.org/svn/ll
 0020 766d2d70 726f6a65 63742f6c 6c642f74  vm-project/lld/t
 0030 72756e6b 20323834 36333429 00        runk 284634).

An alternative considered:

I first tried to add a SHT_NOTE section because GNU gold does that.
A NOTE section starts with a header which contains content type.
It turned out that ld.gold sets type NT_GNU_GOLD_VERSION to their
NOTE section. So the NOTE type is only for GNU gold (surprise!)

I could define NT_GNU_LINKER_VERSION. However, I doubt that we need
a header at all. It doesn't seem useful at all. Thus, I decided to
just set a version string without any header.

Now that it is not a NOTE section, it doesn't make sense to start
a section name with ".note". So I named it just ".linker-version".

[emaste]

This would have been very useful to me during the initial FreeBSD - lld bring up, so I'm in favour of having a way to identify the linker that was used.

[peter.smith]

The contents of the .linker-version section and the code create it look good to me.

My only question given that .linker-version is SHT_PROGBITS is why use a separate .linker-version section rather than just add to the pre-existing .comment section? For example in a test file built using objects from clang and gcc I get a .comment section out of lld that looks like:
Contents of section .comment:
0000 00474343 3a20284c 696e6172 6f204743 .GCC: (Linaro GC
0010 4320352e 332d3230 31362e30 32292035 C 5.3-2016.02) 5
0020 2e332e31 20323031 36303131 3300636c .3.1 20160113.cl
0030 616e6720 76657273 696f6e20 342e302e ang version 4.0.
0040 302000 0 .

Putting the information from .linker-version in the .comment section collects all the version control information for the toolchain in one place.

Having said all that I don't have a strong opinion and I'm happy to go with .linker-version if others prefer.

[ruiu]

I was thinking about that. The benefit of doing that is that the .comment section is a well-known section, so the exiting tools can handle it (or strip it.) On the other hand, I worried if we add a linker version to .comment, you cannot figure out which is the linker's version string among many strings in a .comment section unless you know the name of the linker.

Probably I was overthinking. The .comment section is for human consumption, so that may a better place to put the version string than creating a new section. Let me update this patch.

[emaste]

.comment sounds good to me

[inglorion]

It would be nice to have an easy way to extract the linker name from the file somehow. There doesn't seem to be an established way to encode this information now - as you observed, gold uses .note.gnu.gold-version, whereas other programs tend to use the .comment section. How about using the .comment section, but using a prefix (e.g. "linker: ", followed by the identifying string (e.g. "${program} version ${version} (${commit_info})" as we use for Clang?

[ruiu]

That's a good idea. I'll add "linker:" prefix.

[davide]

I don't dislike the general idea, but I think you can convert this to a Synthetic Input Section (this patch predates the introduction of SyntheticSections.cpp)

[ruiu]

Yes, we should convert this to synthetic input section, but we are not ready yet, because we cannot create synthetic mergeable string section yet.

[ruiu]

Superceded by https://reviews.llvm.org/D26487.

ELF/OutputSections.h

enum Kind {
     Dynamic,
     EHFrame,
     EHFrameHdr,
     GnuHashTable,
     Got,
     GotPlt,
     HashTable,
     Interp,
+    LinkerVersion,
     Merge,
-    MipsReginfo,
-    MipsOptions,
     MipsAbiFlags,
+    MipsOptions,
+    MipsReginfo,
     Plt,
     Regular,
     Reloc,
     StrTable,
     SymTable,
     VersDef,
     VersNeed,
     VersTable

 
 public:
   InterpSection();
   void writeTo(uint8_t *Buf) override;
   typename Base::Kind getKind() const override { return Base::Interp; }
   static bool classof(const Base *B) { return B->getKind() == Base::Interp; }
 };
 
+// Represents a ".linker-version" section which contains
+// a linker version string.
+template <class ELFT>
+class LinkerVersionSection final : public OutputSectionBase<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
+
+public:
+  LinkerVersionSection();
+  void writeTo(uint8_t *Buf) override;
+  typename Base::Kind getKind() const override { return Base::LinkerVersion; }
+
+  static bool classof(const Base *B) {
+    return B->getKind() == Base::LinkerVersion;
+  }
+};
+
 template <class ELFT>
 class StringTableSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
 
 public:
   typedef typename ELFT::uint uintX_t;
   StringTableSection(StringRef Name, bool Dynamic);
   unsigned addString(StringRef S, bool HashIt = true);
template <class ELFT> struct Out {
   static DynamicSection<ELFT> *Dynamic;
   static EhFrameHeader<ELFT> *EhFrameHdr;
   static EhOutputSection<ELFT> *EhFrame;
   static GnuHashTableSection<ELFT> *GnuHashTab;
   static GotPltSection<ELFT> *GotPlt;
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;
   static InterpSection<ELFT> *Interp;
+  static LinkerVersionSection<ELFT> *LinkerVersion;
   static OutputSection<ELFT> *Bss;
   static OutputSection<ELFT> *MipsRldMap;
   static OutputSectionBase<ELFT> *Opd;
   static uint8_t *OpdBuf;
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
   static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;

 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> EhFrameHeader<ELFT> *Out<ELFT>::EhFrameHdr;
 template <class ELFT> EhOutputSection<ELFT> *Out<ELFT>::EhFrame;
 template <class ELFT> GnuHashTableSection<ELFT> *Out<ELFT>::GnuHashTab;
 template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
 template <class ELFT> InterpSection<ELFT> *Out<ELFT>::Interp;
+template <class ELFT> LinkerVersionSection<ELFT> *Out<ELFT>::LinkerVersion;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::MipsRldMap;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::Opd;
 template <class ELFT> uint8_t *Out<ELFT>::OpdBuf;
 template <class ELFT> PltSection<ELFT> *Out<ELFT>::Plt;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaDyn;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaPlt;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::DynStrTab;

ELF/OutputSections.cpp

 //===- OutputSections.cpp -------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OutputSections.h"
 #include "Config.h"
 #include "EhFrame.h"
 #include "LinkerScript.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Target.h"
+#include "lld/Config/Version.h"
 #include "lld/Core/Parallel.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/xxhash.h"
 

 }
 
 template <class ELFT> void InterpSection<ELFT>::writeTo(uint8_t *Buf) {
   StringRef S = Config->DynamicLinker;
   memcpy(Buf, S.data(), S.size());
 }
 
 template <class ELFT>
+LinkerVersionSection<ELFT>::LinkerVersionSection()
+    : OutputSectionBase<ELFT>(".linker-version", SHT_PROGBITS, 0) {
+  this->Header.sh_size = getLLDVersion().size() + 1; // +1 for NUL
+}
+
+template <class ELFT> void LinkerVersionSection<ELFT>::writeTo(uint8_t *Buf) {
+  StringRef S = getLLDVersion();
+  memcpy(Buf, S.data(), S.size());
+}
+
+template <class ELFT>
 HashTableSection<ELFT>::HashTableSection()
     : OutputSectionBase<ELFT>(".hash", SHT_HASH, SHF_ALLOC) {
   this->Header.sh_entsize = sizeof(Elf_Word);
   this->Header.sh_addralign = sizeof(Elf_Word);
 }
 
 static uint32_t hashSysv(StringRef Name) {
   uint32_t H = 0;

 template class HashTableSection<ELF64LE>;
 template class HashTableSection<ELF64BE>;
 
 template class DynamicSection<ELF32LE>;
 template class DynamicSection<ELF32BE>;
 template class DynamicSection<ELF64LE>;
 template class DynamicSection<ELF64BE>;
 
+template class LinkerVersionSection<ELF32LE>;
+template class LinkerVersionSection<ELF32BE>;
+template class LinkerVersionSection<ELF64LE>;
+template class LinkerVersionSection<ELF64BE>;
+
 template class OutputSection<ELF32LE>;
 template class OutputSection<ELF32BE>;
 template class OutputSection<ELF64LE>;
 template class OutputSection<ELF64BE>;
 
 template class EhOutputSection<ELF32LE>;
 template class EhOutputSection<ELF32BE>;
 template class EhOutputSection<ELF64LE>;

ELF/Writer.cpp

 template <class ELFT> void elf::writeResult() {
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Ehdr Elf_Ehdr;
 
   // Create singleton output sections.
   OutputSection<ELFT> Bss(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
   DynamicSection<ELFT> Dynamic;
   EhOutputSection<ELFT> EhFrame;
+  LinkerVersionSection<ELFT> LinkerVersion;
   GotSection<ELFT> Got;
   PltSection<ELFT> Plt;
   RelocationSection<ELFT> RelaDyn(Config->Rela ? ".rela.dyn" : ".rel.dyn",
                                   Config->ZCombreloc);
   StringTableSection<ELFT> ShStrTab(".shstrtab", false);
   VersionTableSection<ELFT> VerSym;
   VersionNeedSection<ELFT> VerNeed;
 
template <class ELFT> void elf::writeResult() {
   Out<ELFT>::Dynamic = &Dynamic;
   Out<ELFT>::EhFrame = &EhFrame;
   Out<ELFT>::EhFrameHdr = EhFrameHdr.get();
   Out<ELFT>::GnuHashTab = GnuHashTab.get();
   Out<ELFT>::Got = &Got;
   Out<ELFT>::GotPlt = GotPlt.get();
   Out<ELFT>::HashTab = HashTab.get();
   Out<ELFT>::Interp = Interp.get();
+  Out<ELFT>::LinkerVersion = &LinkerVersion;
   Out<ELFT>::Plt = &Plt;
   Out<ELFT>::RelaDyn = &RelaDyn;
   Out<ELFT>::RelaPlt = RelaPlt.get();
   Out<ELFT>::ShStrTab = &ShStrTab;
   Out<ELFT>::StrTab = StrTab.get();
   Out<ELFT>::SymTab = SymTabSec.get();
   Out<ELFT>::VerDef = VerDef.get();
   Out<ELFT>::VerSym = &VerSym;
template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
 
   // Add .interp at first because some loaders want to see that section
   // on the first page of the executable file when loaded into memory.
   if (Out<ELFT>::Interp)
     OutputSections.insert(OutputSections.begin(), Out<ELFT>::Interp);
 
   // This order is not the same as the final output order
   // because we sort the sections using their attributes below.
+  Add(Out<ELFT>::LinkerVersion);
   Add(Out<ELFT>::SymTab);
   Add(Out<ELFT>::ShStrTab);
   Add(Out<ELFT>::StrTab);
   if (Out<ELFT>::DynSymTab) {
     Add(Out<ELFT>::DynSymTab);
 
     bool HasVerNeed = Out<ELFT>::VerNeed->getNeedNum() != 0;
     if (Out<ELFT>::VerDef || HasVerNeed)