[ELF] Convert linker generated sections to input sections

[evgeny777]

Summary

ld/gold allow using linker generated sections as inputs to create some other output sections, for example:

SECTIONS {
  .got : { *(.got.plt) *(.got) }
}

This will create single output section .got with contents of linker generated .got and .got.plt section. This patch makes it possible to do the same
This is done by means of using 'proxy' input section, which holds pointer to linker generated section and can be added to OutputSection<ELFT>,
just like any other regular input section can. In future this can also be used to create single output section for mergeable/non-mergeable inputs,
if linker script demands this.

[grimar]

ELF/InputSection.h

342 ↗

(On Diff #74713)

Do you need/use this typedefs ?

test/ELF/linkerscript/output-to-input.s

16 ↗

(On Diff #74713)

Do you really need to specify order of sections to demonstrate output with/without merging of .got/got.plt ?
I mean shouldn't next work ?

# RUN: echo "SECTIONS { \
# RUN:  .got : {} \
# RUN:  .got.plt : {} \
# RUN: }" > %t1.script

# RUN: echo "SECTIONS { \
# RUN:  .got : { *(.got) *(.got.plt)  } \
# RUN: }" > %t2.script

42 ↗

(On Diff #74713)

Last 32 bytes you mean ? (3 + 1) entries * 8.

[evgeny777]

test/ELF/linkerscript/output-to-input.s

16 ↗

(On Diff #74713)

You should have equal offsets between .plt and .got.plt section in both cases to get same contents of .got.plt.
Of course it's possible to create smaller examples with the same effect, but in this case result would depend on orphan
section placement algorithm

42 ↗

(On Diff #74713)

You're right - that's a mistake.

[evgeny777]

Addressed review comments

[ruiu]

In what situation you would want to put both .got and .got.plt to a .got section? I mean, if you want to handle

.got { *(.got) }

we can just ignore such commands.

[evgeny777]

The reason I'm doing this is that I have same linker script for armv7 and aarch64 and all linkers (gold/ld/lld). This script should enforce two constraints:

1. PLT GOT entries should go before all other GOT entries
2. I need to have start and end symbols for GOT

Both constraints need to be enforced for dynamic loader to work properly. Currently I have something like this in my linker script:

.got  : { 
   PROVIDE_HIDDEN(__got_start = .);
   *(.got.plt) *(.got) 
   PROVIDE_HIDDEN(__got_end = .);
}

The problems I face with current version are:

1. On armv7 neither gold nor ld create .got.plt section, but lld does.
2. On aarch64 all linkers create .got.plt, but on some occasions lld doesn't create .got section, while ld/gold do. Also, even if I specify correct order in linker script sometimes orphan section may be placed in between .got.plt and .got and prevent DSO from being correctly loaded.

BTW it looks like both gold and ld allow placing all linker generated sections wherever you want. May be it makes sense to make this patch more generic?

[ruiu]

Honestly I think I wouldn't want to support this unless it is absolutely necessary or there's a better way to support it than the "virtual input section".

First, the SECTIONS command seems odd. The SECTIONS command is to gather input sections to put them into an output section, but there are no .got nor .got.plt sections are in any input file. Therefore, even though

SECTIONS .got { *(.got) }

looks similar to

SECTIONS .text { *(.text) },

they are very different in semantics. The latter aggregates all .text sections from input files to put them into a .text section, but the former instructs the linker to put a linker-created .got section to .got. The former pattern seems semantically wrong and beyond the limit what we could do with the SECTIONS command.

Second, wrapping an output section with a "virtual" input section seems pretty odd, too. That's a direct consequence of the oddity of the feature, but output sections are not input sections, so it's really confusing.

[evgeny777]

Converted .got and .got.plt sections to inputs according to RFC from Rui Ueyama. All tests pass.

[ruiu]

I think this is still too large to see whether the very concept of virtual input section is good or not. GOT section is used everywhere, so you had to update so many places to convert it. Could you convert much less important section first? Say, build-id?

ELF/InputSection.h

351 ↗

(On Diff #75575)

Does Header = {}; initialize with zero?

[evgeny777]

ELF/InputSection.h

351 ↗

(On Diff #75575)

Yes, but unfortunately base class is initialized first and it is using Header.

[evgeny777]

Converted BuildId section to input.

[peter.smith]

Apologies in advance if I'm missing something, but I'm not completely sure why we need a special SyntheticInputSection?
Is it because we want to retain a similar custom interface to make generating the Section easier, while still allowing it to be placed as an InputSection? Or is it to get around the lack of an InputFile for the SyntheticInputSection? If it is the latter I would have thought a single SyntheticInputFile might be less disruptive.

Another possible use case of linker generated InputSections is Thunks (or other linker generated code sequences/data) as InputSections, which would need to be mixed in with other InputSections from the file. Would this be possible with SyntheticInputSections?

As an aside for ARM PLT and GOT sections:

I've not got a good reason for why ARM only uses a single .got section on ld.bfd and gold. A best guess is that ARM also had to support Symbian OS at the time which only had a single .got section. At the time of doing the initial ARM port I thought about making a single .got section to match gold and ld.bfd, but given the tests I've been running against ld-linux-armhf.so.3 haven't caused a problem I didn't think it worth the additional disruption to the code-base. Is there a widespread use case where this doesn't work?

[evgeny777]

Thanks for your comment, Peter.

a) SyntheticInputSection is actually a helper class to simplify conversion from output section to input section. It doesn't have any other purpose, just helper constructor and base interface which is partially moved from OutputSectionBase<ELFT>.

b) AFAIK thunks in lld are created in a different way: no input section is created for them, instead there is an array of Thunk<ELFT> objects which is member of InputSection<ELFT> class. This array is used to determine real section size. Real thunk code is generated when sections are written.

c) Like I said earlier both ld and gold don't generate .got section on 32 bit ARM platforms. I don't know if this would ever change. On the other hand lld sometimes doesn't create .got section when both ld and gold do. To abstract differences between 32 and 64 bit ARM we merge .got and .got.plt to a single section in linker scripts. Both gold and ld allow doing this. Another possible usage of this patch is discarding certain linker generated section in linker script, which can't be done now.

[ruiu]

Overall, this is towards the right direction. Please rebase on SVN head because Rafael made a few changes that you can use in this patch.

ELF/Writer.cpp

780 ↗

(On Diff #75694)

Remove null check. Sections shouldn't contain a nullptr.

869 ↗

(On Diff #75694)

Why do you have to call S->Outsec->assignOffsets?

1495 ↗

(On Diff #75694)

You want to use needed() for consistency.

[evgeny777]

ELF/Writer.cpp

780 ↗

(On Diff #75694)

Actually they can. In original version if build-id section is not emitted then Out<ELFT>::BuildId is nullptr. isDiscarded() does check for nullptr as well

869 ↗

(On Diff #75694)

In order for OutSec to have non-zero size. Normally assignOffsets is called earlier in createSections().

1495 ↗

(On Diff #75694)

I've removed needed() in upcoming diff, because it isn't required for BuildIdSection.

[evgeny777]

Addressed review comments

[ruiu]

ELF/InputSection.cpp

863 ↗

(On Diff #76177)

Here, you fill the internal buffer with data, which to be memcpy'ed to the final output buffer. I think we don't want to do that. Instead, we want to virtualize InputFile's writeTo so that each input section will directly write to the output buffer.

ELF/InputSection.h

254–255 ↗

(On Diff #76177)

This field is very specific to build-id, which needs to back-fill the buildid value after we get a complete output file. No other sections should need them, and that's a good thing because it keeps most sections being agnostic where they are written. So I'd move this to BuildIdSection, as it used to be.

[evgeny777]

ELF/InputSection.cpp

863 ↗

(On Diff #76177)

Besides writeTo one will also have to virtualize getSize(), in order for assignOffsets to work properly

[evgeny777]

ELF/InputSection.cpp

863 ↗

(On Diff #76177)

Also if you virtualize getSize() then you'll get different values from Data.size() and getSize(). The getDataAs<T> won't work either. Does extra copying really provide that much overhead ?

[ruiu]

LGTM

ELF/InputSection.cpp

863 ↗

(On Diff #76177)

I don't know about that. We might want to create a large virtual section, but I don't have a concrete example now. Because this patch is pretty straightforward and simple, let's land this. We can revisit later.

[evgeny777]

ELF/InputSection.cpp

863 ↗

(On Diff #76177)

Ok. Does it make sense to convert other sections (like .got and .got.plt) now ?

[ruiu]

Yes, but please do one at a time at the moment.

lld/trunk/ELF/InputSection.h

public:
 
   // Relocation sections that refer to this one.
   llvm::TinyPtrVector<const Elf_Shdr *> RelocSections;
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutSecOff = 0;
 
+  // Location of this section in the output buffer
+  uint8_t *OutputLoc = nullptr;
+
   // InputSection that is dependent on us (reverse dependency for GC)
   InputSectionBase<ELFT> *DependentSection = nullptr;
 
   static bool classof(const InputSectionData *S);
 
   InputSectionBase<ELFT> *getRelocatedSection();
 
   // Register thunk related to the symbol. When the section is written

 public:
   MipsAbiFlagsInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Hdr,
                            StringRef Name);
   static bool classof(const InputSectionData *S);
 
   const llvm::object::Elf_Mips_ABIFlags<ELFT> *Flags = nullptr;
 };
 
+template <class ELFT> class BuildIdSection : public InputSection<ELFT> {
+  typedef OutputSectionBase<ELFT> Base;
+
+public:
+  virtual void writeBuildId(ArrayRef<uint8_t> Buf) = 0;
+  virtual ~BuildIdSection() = default;
+
+protected:
+  BuildIdSection(size_t HashSize);
+  std::vector<uint8_t> Buf;
+};
+
+template <class ELFT>
+class BuildIdFastHash final : public BuildIdSection<ELFT> {
+public:
+  BuildIdFastHash() : BuildIdSection<ELFT>(8) {}
+  void writeBuildId(ArrayRef<uint8_t> Buf) override;
+};
+
+template <class ELFT> class BuildIdMd5 final : public BuildIdSection<ELFT> {
+public:
+  BuildIdMd5() : BuildIdSection<ELFT>(16) {}
+  void writeBuildId(ArrayRef<uint8_t> Buf) override;
+};
+
+template <class ELFT> class BuildIdSha1 final : public BuildIdSection<ELFT> {
+public:
+  BuildIdSha1() : BuildIdSection<ELFT>(20) {}
+  void writeBuildId(ArrayRef<uint8_t> Buf) override;
+};
+
+template <class ELFT> class BuildIdUuid final : public BuildIdSection<ELFT> {
+public:
+  BuildIdUuid() : BuildIdSection<ELFT>(16) {}
+  void writeBuildId(ArrayRef<uint8_t> Buf) override;
+};
+
+template <class ELFT>
+class BuildIdHexstring final : public BuildIdSection<ELFT> {
+public:
+  BuildIdHexstring();
+  void writeBuildId(ArrayRef<uint8_t>) override;
+};
+
+// Linker generated sections which can be used as inputs.
+template <class ELFT> struct In {
+  static BuildIdSection<ELFT> *BuildId;
+  static std::vector<InputSection<ELFT> *> Sections;
+};
+
+template <class ELFT> BuildIdSection<ELFT> *In<ELFT>::BuildId;
+template <class ELFT> std::vector<InputSection<ELFT> *> In<ELFT>::Sections;
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/InputSection.cpp

 #include "InputFiles.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "Target.h"
 #include "Thunks.h"
 
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/RandomNumberGenerator.h"
+#include "llvm/Support/xxhash.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 
 using namespace lld;
for (const Relocation &Rel : Relocations) {
     }
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Type == SHT_NOBITS)
     return;
 
+  // Set output location.
+  this->OutputLoc = Buf + OutSecOff;
+
   // If -r is given, then an InputSection may be a relocation section.
   if (this->Type == SHT_RELA) {
     copyRelocations(Buf + OutSecOff, this->template getDataAs<Elf_Rela>());
     return;
   }
   if (this->Type == SHT_REL) {
     copyRelocations(Buf + OutSecOff, this->template getDataAs<Elf_Rel>());
     return;
for (DefinedCommon *Sym : Syms) {
     Size += Sym->Size;
   }
   ArrayRef<uint8_t> Data = makeArrayRef<uint8_t>(nullptr, Size);
   InputSection Ret(SHF_ALLOC | SHF_WRITE, SHT_NOBITS, Alignment, Data, "");
   Ret.Live = true;
   return Ret;
 }
 
+template <class ELFT>
+BuildIdSection<ELFT>::BuildIdSection(size_t HashSize)
+    : InputSection<ELFT>(SHF_ALLOC, SHT_NOTE, 1, ArrayRef<uint8_t>(),
+                         ".note.gnu.build-id") {
+  Buf.resize(16 + HashSize);
+  const endianness E = ELFT::TargetEndianness;
+  write32<E>(Buf.data(), 4);                   // Name size
+  write32<E>(Buf.data() + 4, HashSize);        // Content size
+  write32<E>(Buf.data() + 8, NT_GNU_BUILD_ID); // Type
+  memcpy(Buf.data() + 12, "GNU", 4);           // Name string
+  this->Data = ArrayRef<uint8_t>(Buf);
+}
+
+template <class ELFT>
+void BuildIdFastHash<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
+  const endianness E = ELFT::TargetEndianness;
+
+  // 64-bit xxhash
+  uint64_t Hash = xxHash64(toStringRef(Buf));
+  write64<E>(this->OutputLoc + 16, Hash);
+}
+
+template <class ELFT>
+void BuildIdMd5<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
+  MD5 Hash;
+  Hash.update(Buf);
+  MD5::MD5Result Res;
+  Hash.final(Res);
+  memcpy(this->OutputLoc + 16, Res, 16);
+}
+
+template <class ELFT>
+void BuildIdSha1<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
+  SHA1 Hash;
+  Hash.update(Buf);
+  memcpy(this->OutputLoc + 16, Hash.final().data(), 20);
+}
+
+template <class ELFT>
+void BuildIdUuid<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
+  if (getRandomBytes(this->OutputLoc + 16, 16))
+    error("entropy source failure");
+}
+
+template <class ELFT>
+BuildIdHexstring<ELFT>::BuildIdHexstring()
+    : BuildIdSection<ELFT>(Config->BuildIdVector.size()) {}
+
+template <class ELFT>
+void BuildIdHexstring<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
+  memcpy(this->OutputLoc + 16, Config->BuildIdVector.data(),
+         Config->BuildIdVector.size());
+}
+
 template class elf::InputSectionBase<ELF32LE>;
 template class elf::InputSectionBase<ELF32BE>;
 template class elf::InputSectionBase<ELF64LE>;
 template class elf::InputSectionBase<ELF64BE>;
 
 template class elf::InputSection<ELF32LE>;
 template class elf::InputSection<ELF32BE>;
 template class elf::InputSection<ELF64LE>;

 template class elf::MipsOptionsInputSection<ELF32BE>;
 template class elf::MipsOptionsInputSection<ELF64LE>;
 template class elf::MipsOptionsInputSection<ELF64BE>;
 
 template class elf::MipsAbiFlagsInputSection<ELF32LE>;
 template class elf::MipsAbiFlagsInputSection<ELF32BE>;
 template class elf::MipsAbiFlagsInputSection<ELF64LE>;
 template class elf::MipsAbiFlagsInputSection<ELF64BE>;
+
+template class elf::BuildIdSection<ELF32LE>;
+template class elf::BuildIdSection<ELF32BE>;
+template class elf::BuildIdSection<ELF64LE>;
+template class elf::BuildIdSection<ELF64BE>;
+
+template class elf::BuildIdFastHash<ELF32LE>;
+template class elf::BuildIdFastHash<ELF32BE>;
+template class elf::BuildIdFastHash<ELF64LE>;
+template class elf::BuildIdFastHash<ELF64BE>;
+
+template class elf::BuildIdMd5<ELF32LE>;
+template class elf::BuildIdMd5<ELF32BE>;
+template class elf::BuildIdMd5<ELF64LE>;
+template class elf::BuildIdMd5<ELF64BE>;
+
+template class elf::BuildIdSha1<ELF32LE>;
+template class elf::BuildIdSha1<ELF32BE>;
+template class elf::BuildIdSha1<ELF64LE>;
+template class elf::BuildIdSha1<ELF64BE>;
+
+template class elf::BuildIdUuid<ELF32LE>;
+template class elf::BuildIdUuid<ELF32BE>;
+template class elf::BuildIdUuid<ELF64LE>;
+template class elf::BuildIdUuid<ELF64BE>;
+
+template class elf::BuildIdHexstring<ELF32LE>;
+template class elf::BuildIdHexstring<ELF32BE>;
+template class elf::BuildIdHexstring<ELF64LE>;
+template class elf::BuildIdHexstring<ELF64BE>;

lld/trunk/ELF/OutputSections.h

 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
 template <class ELFT> class OutputSectionBase {
 public:
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Shdr Elf_Shdr;
   enum Kind {
     Base,
-    BuildId,
     Dynamic,
     EHFrame,
     EHFrameHdr,
     GnuHashTable,
     Got,
     GotPlt,
     HashTable,
     Interp,
private:
   struct FdeData {
     uint32_t Pc;
     uint32_t FdeVA;
   };
 
   std::vector<FdeData> Fdes;
 };
 
-template <class ELFT> class BuildIdSection : public OutputSectionBase<ELFT> {
-  typedef OutputSectionBase<ELFT> Base;
-
-public:
-  void writeTo(uint8_t *Buf) override;
-  virtual void writeBuildId(ArrayRef<uint8_t> Buf) = 0;
-  typename Base::Kind getKind() const override { return Base::BuildId; }
-  static bool classof(const Base *B) { return B->getKind() == Base::BuildId; }
-
-protected:
-  BuildIdSection(size_t HashSize);
-  size_t HashSize;
-  uint8_t *HashBuf = nullptr;
-};
-
-template <class ELFT>
-class BuildIdFastHash final : public BuildIdSection<ELFT> {
-public:
-  BuildIdFastHash() : BuildIdSection<ELFT>(8) {}
-  void writeBuildId(ArrayRef<uint8_t> Buf) override;
-};
-
-template <class ELFT> class BuildIdMd5 final : public BuildIdSection<ELFT> {
-public:
-  BuildIdMd5() : BuildIdSection<ELFT>(16) {}
-  void writeBuildId(ArrayRef<uint8_t> Buf) override;
-};
-
-template <class ELFT> class BuildIdSha1 final : public BuildIdSection<ELFT> {
-public:
-  BuildIdSha1() : BuildIdSection<ELFT>(20) {}
-  void writeBuildId(ArrayRef<uint8_t> Buf) override;
-};
-
-template <class ELFT> class BuildIdUuid final : public BuildIdSection<ELFT> {
-public:
-  BuildIdUuid() : BuildIdSection<ELFT>(16) {}
-  void writeBuildId(ArrayRef<uint8_t> Buf) override;
-};
-
-template <class ELFT>
-class BuildIdHexstring final : public BuildIdSection<ELFT> {
-public:
-  BuildIdHexstring();
-  void writeBuildId(ArrayRef<uint8_t>) override;
-};
-
 // All output sections that are hadnled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.
 template <class ELFT> struct Out {
   typedef typename ELFT::uint uintX_t;
   typedef typename ELFT::Phdr Elf_Phdr;
-  static BuildIdSection<ELFT> *BuildId;
   static DynamicSection<ELFT> *Dynamic;
   static EhFrameHeader<ELFT> *EhFrameHdr;
   static EhOutputSection<ELFT> *EhFrame;
   static GdbIndexSection<ELFT> *GdbIndex;
   static GnuHashTableSection<ELFT> *GnuHashTab;
   static GotPltSection<ELFT> *GotPlt;
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;

 };
 
 template <class ELFT> uint64_t getHeaderSize() {
   if (Config->OFormatBinary)
     return 0;
   return Out<ELFT>::ElfHeader->getSize() + Out<ELFT>::ProgramHeaders->getSize();
 }
 
-template <class ELFT> BuildIdSection<ELFT> *Out<ELFT>::BuildId;
 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> GdbIndexSection<ELFT> *Out<ELFT>::GdbIndex;
 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;

lld/trunk/ELF/OutputSections.cpp

 #include "GdbIndex.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Target.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"
 
 using namespace llvm;
 using namespace llvm::dwarf;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 
 using namespace lld;
template <class ELFT> void VersionNeedSection<ELFT>::finalize() {
   this->Header.sh_info = Needed.size();
   unsigned Size = Needed.size() * sizeof(Elf_Verneed);
   for (std::pair<SharedFile<ELFT> *, size_t> &P : Needed)
     Size += P.first->VerdefMap.size() * sizeof(Elf_Vernaux);
   this->Header.sh_size = Size;
 }
 
 template <class ELFT>
-BuildIdSection<ELFT>::BuildIdSection(size_t HashSize)
-    : OutputSectionBase<ELFT>(".note.gnu.build-id", SHT_NOTE, SHF_ALLOC),
-      HashSize(HashSize) {
-  // 16 bytes for the note section header.
-  this->Header.sh_size = 16 + HashSize;
-}
-
-template <class ELFT> void BuildIdSection<ELFT>::writeTo(uint8_t *Buf) {
-  const endianness E = ELFT::TargetEndianness;
-  write32<E>(Buf, 4);                   // Name size
-  write32<E>(Buf + 4, HashSize);        // Content size
-  write32<E>(Buf + 8, NT_GNU_BUILD_ID); // Type
-  memcpy(Buf + 12, "GNU", 4);           // Name string
-  HashBuf = Buf + 16;
-}
-
-template <class ELFT>
-void BuildIdFastHash<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
-  const endianness E = ELFT::TargetEndianness;
-
-  // 64-bit xxhash
-  uint64_t Hash = xxHash64(toStringRef(Buf));
-  write64<E>(this->HashBuf, Hash);
-}
-
-template <class ELFT>
-void BuildIdMd5<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
-  MD5 Hash;
-  Hash.update(Buf);
-  MD5::MD5Result Res;
-  Hash.final(Res);
-  memcpy(this->HashBuf, Res, 16);
-}
-
-template <class ELFT>
-void BuildIdSha1<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
-  SHA1 Hash;
-  Hash.update(Buf);
-  memcpy(this->HashBuf, Hash.final().data(), 20);
-}
-
-template <class ELFT>
-void BuildIdUuid<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
-  if (getRandomBytes(this->HashBuf, 16))
-    error("entropy source failure");
-}
-
-template <class ELFT>
-BuildIdHexstring<ELFT>::BuildIdHexstring()
-    : BuildIdSection<ELFT>(Config->BuildIdVector.size()) {}
-
-template <class ELFT>
-void BuildIdHexstring<ELFT>::writeBuildId(ArrayRef<uint8_t> Buf) {
-  memcpy(this->HashBuf, Config->BuildIdVector.data(),
-         Config->BuildIdVector.size());
-}
-
-template <class ELFT>
 MipsReginfoOutputSection<ELFT>::MipsReginfoOutputSection()
     : OutputSectionBase<ELFT>(".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC) {
   this->Header.sh_addralign = 4;
   this->Header.sh_entsize = sizeof(Elf_Mips_RegInfo);
   this->Header.sh_size = sizeof(Elf_Mips_RegInfo);
 }
 
 template <class ELFT>

 template class VersionNeedSection<ELF64LE>;
 template class VersionNeedSection<ELF64BE>;
 
 template class VersionDefinitionSection<ELF32LE>;
 template class VersionDefinitionSection<ELF32BE>;
 template class VersionDefinitionSection<ELF64LE>;
 template class VersionDefinitionSection<ELF64BE>;
 
-template class BuildIdSection<ELF32LE>;
-template class BuildIdSection<ELF32BE>;
-template class BuildIdSection<ELF64LE>;
-template class BuildIdSection<ELF64BE>;
-
-template class BuildIdFastHash<ELF32LE>;
-template class BuildIdFastHash<ELF32BE>;
-template class BuildIdFastHash<ELF64LE>;
-template class BuildIdFastHash<ELF64BE>;
-
-template class BuildIdMd5<ELF32LE>;
-template class BuildIdMd5<ELF32BE>;
-template class BuildIdMd5<ELF64LE>;
-template class BuildIdMd5<ELF64BE>;
-
-template class BuildIdSha1<ELF32LE>;
-template class BuildIdSha1<ELF32BE>;
-template class BuildIdSha1<ELF64LE>;
-template class BuildIdSha1<ELF64BE>;
-
-template class BuildIdUuid<ELF32LE>;
-template class BuildIdUuid<ELF32BE>;
-template class BuildIdUuid<ELF64LE>;
-template class BuildIdUuid<ELF64BE>;
-
-template class BuildIdHexstring<ELF32LE>;
-template class BuildIdHexstring<ELF32BE>;
-template class BuildIdHexstring<ELF64LE>;
-template class BuildIdHexstring<ELF64BE>;
-
 template class GdbIndexSection<ELF32LE>;
 template class GdbIndexSection<ELF32BE>;
 template class GdbIndexSection<ELF64LE>;
 template class GdbIndexSection<ELF64BE>;
 
 template class OutputSectionFactory<ELF32LE>;
 template class OutputSectionFactory<ELF32BE>;
 template class OutputSectionFactory<ELF64LE>;
 template class OutputSectionFactory<ELF64BE>;
 }
 }

lld/trunk/ELF/Writer.cpp

public:
   typedef typename ELFT::Rela Elf_Rela;
   void run();
 
 private:
   typedef PhdrEntry<ELFT> Phdr;
 
   void copyLocalSymbols();
   void addReservedSymbols();
+  void addInputSec(InputSectionBase<ELFT> *S);
   void createSections();
   void forEachRelSec(std::function<void(InputSectionBase<ELFT> &,
                                         const typename ELFT::Shdr &)> Fn);
   void sortSections();
   void finalizeSections();
   void addPredefinedSections();
   bool needsGot();
 
MipsRldMap.reset(new OutputSection<ELFT>(".rld_map", SHT_PROGBITS,
                                              SHF_ALLOC | SHF_WRITE));
     MipsRldMap->setSize(sizeof(uintX_t));
     MipsRldMap->updateAlignment(sizeof(uintX_t));
   }
   if (!Config->VersionDefinitions.empty())
     VerDef.reset(new VersionDefinitionSection<ELFT>());
 
   Out<ELFT>::Bss = &Bss;
-  Out<ELFT>::BuildId = BuildId.get();
   Out<ELFT>::DynStrTab = DynStrTab.get();
   Out<ELFT>::DynSymTab = DynSymTab.get();
   Out<ELFT>::Dynamic = &Dynamic;
   Out<ELFT>::EhFrame = &EhFrame;
   Out<ELFT>::EhFrameHdr = EhFrameHdr.get();
   Out<ELFT>::GdbIndex = GdbIndex.get();
   Out<ELFT>::GnuHashTab = GnuHashTab.get();
   Out<ELFT>::Got = &Got;
template <class ELFT> void elf::writeResult() {
   Out<ELFT>::TlsPhdr = nullptr;
   Out<ELFT>::ElfHeader = &ElfHeader;
   Out<ELFT>::ProgramHeaders = &ProgramHeaders;
 
   Out<ELFT>::PreinitArray = nullptr;
   Out<ELFT>::InitArray = nullptr;
   Out<ELFT>::FiniArray = nullptr;
 
+  // Initialize linker generated sections
+  In<ELFT>::BuildId = BuildId.get();
+  In<ELFT>::Sections = {BuildId.get()};
+
   Writer<ELFT>().run();
   Out<ELFT>::Pool.clear();
 }
 
 template <class ELFT> static std::vector<DefinedCommon *> getCommonSymbols() {
   std::vector<DefinedCommon *> V;
   for (Symbol *S : Symtab<ELFT>::X->getSymbols())
     if (auto *B = dyn_cast<DefinedCommon>(S->body()))
for (InputSectionBase<ELFT> *IS : F->getSections()) {
       }
       if (auto *S = dyn_cast<EhInputSection<ELFT>>(IS))
         if (S->RelocSection)
           Fn(*S, *S->RelocSection);
     }
   }
 }
 
-template <class ELFT> void Writer<ELFT>::createSections() {
-  auto Add = [&](InputSectionBase<ELFT> *IS) {
-    if (isDiscarded(IS)) {
-      reportDiscarded(IS);
-      return;
-    }
-    OutputSectionBase<ELFT> *Sec;
-    bool IsNew;
-    StringRef OutsecName = getOutputSectionName(IS->Name);
-    std::tie(Sec, IsNew) = Factory.create(IS, OutsecName);
-    if (IsNew)
-      OutputSections.push_back(Sec);
-    Sec->addSection(IS);
-  };
+template <class ELFT>
+void Writer<ELFT>::addInputSec(InputSectionBase<ELFT> *IS) {
+}
 
+template <class ELFT> void Writer<ELFT>::createSections() {
   for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles())
     for (InputSectionBase<ELFT> *IS : F->getSections())
-      Add(IS);
+      addInputSec(IS);
 
   for (BinaryFile *F : Symtab<ELFT>::X->getBinaryFiles())
     for (InputSectionData *ID : F->getSections())
-      Add(cast<InputSection<ELFT>>(ID));
+      addInputSec(cast<InputSection<ELFT>>(ID));
 
   sortInitFini(findSection(".init_array"));
   sortInitFini(findSection(".fini_array"));
   sortCtorsDtors(findSection(".ctors"));
   sortCtorsDtors(findSection(".dtors"));
 
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Sec->assignOffsets();
if (!InputSection<ELFT>::CommonInputSection->OutSec) {
     Out<ELFT>::Bss->addSection(InputSection<ELFT>::CommonInputSection);
     Out<ELFT>::Bss->assignOffsets();
   }
 
   // So far we have added sections from input object files.
   // This function adds linker-created Out<ELFT>::* sections.
   addPredefinedSections();
 
+  // Adds linker generated input sections to
+  // corresponding output sections.
+  for (InputSection<ELFT> *S : In<ELFT>::Sections)
+    addInputSec(S);
+
   sortSections();
 
   unsigned I = 1;
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     Sec->SectionIndex = I++;
     Sec->setSHName(Out<ELFT>::ShStrTab->addString(Sec->getName()));
   }
 
+  // Finalize linker generated sections.
+  for (InputSection<ELFT> *S : In<ELFT>::Sections)
+    if (S && S->OutSec)
+      S->OutSec->assignOffsets();
+
   // Finalizers fix each section's size.
   // .dynsym is finalized early since that may fill up .gnu.hash.
   if (Out<ELFT>::DynSymTab)
     Out<ELFT>::DynSymTab->finalize();
 
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections. The dynamic string table is

 
 // This function add Out<ELFT>::* sections to OutputSections.
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
   auto Add = [&](OutputSectionBase<ELFT> *OS) {
     if (OS)
       OutputSections.push_back(OS);
   };
 
-  // A core file does not usually contain unmodified segments except
-  // the first page of the executable. Add the build ID section to beginning of
-  // the file so that the section is included in the first page.
-  if (Out<ELFT>::BuildId)
-    OutputSections.insert(OutputSections.begin(), Out<ELFT>::BuildId);
-
   // 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.
   if (Out<ELFT>::GdbIndex && Out<ELFT>::DebugInfo)
template <class ELFT> void Writer<ELFT>::writeSections() {
 
   // The .eh_frame_hdr depends on .eh_frame section contents, therefore
   // it should be written after .eh_frame is written.
   if (!Out<ELFT>::EhFrame->empty() && Out<ELFT>::EhFrameHdr)
     Out<ELFT>::EhFrameHdr->writeTo(Buf + Out<ELFT>::EhFrameHdr->getFileOff());
 }
 
 template <class ELFT> void Writer<ELFT>::writeBuildId() {
-  if (!Out<ELFT>::BuildId)
+  if (!In<ELFT>::BuildId || !In<ELFT>::BuildId->OutSec)
     return;
 
   // Compute a hash of all sections of the output file.
   uint8_t *Start = Buffer->getBufferStart();
   uint8_t *End = Start + FileSize;
-  Out<ELFT>::BuildId->writeBuildId({Start, End});
+  In<ELFT>::BuildId->writeBuildId({Start, End});
 }
 
 template void elf::writeResult<ELF32LE>();
 template void elf::writeResult<ELF32BE>();
 template void elf::writeResult<ELF64LE>();
 template void elf::writeResult<ELF64BE>();
 
 template struct elf::PhdrEntry<ELF32LE>;

lld/trunk/test/ELF/build-id.s

 
 .globl _start
 _start:
   nop
 
 .section .note.test, "a", @note
    .quad 42
 
+# DEFAULT:      Contents of section .note.test:
 # DEFAULT:      Contents of section .note.gnu.build-id:
 # DEFAULT-NEXT: 04000000 08000000 03000000 474e5500  ............GNU.
-# DEFAULT:      Contents of section .note.test:
 
 # MD5:      Contents of section .note.gnu.build-id:
 # MD5-NEXT: 04000000 10000000 03000000 474e5500  ............GNU.
 
 # SHA1:      Contents of section .note.gnu.build-id:
 # SHA1-NEXT: 04000000 14000000 03000000 474e5500  ............GNU.
 
 # UUID:      Contents of section .note.gnu.build-id:
 # UUID-NEXT: 04000000 10000000 03000000 474e5500  ............GNU.
 
 # HEX:      Contents of section .note.gnu.build-id:
 # HEX-NEXT: 04000000 04000000 03000000 474e5500  ............GNU.
 # HEX-NEXT: 12345678
 
 # NONE-NOT: Contents of section .note.gnu.build-id: