[ELF] Make input section's writeTo virtual (required to make .got.plt section synthetic)

[evgeny777]

Summary

The .got.plt section needs to write VA of .dynamic section, so we cannot build its output buffer in finalizeSections().
There are two approaches to deal with this:

a) Make writeTo virtual, so that section is written after assignAddresses() is called. This is what this patch does.
b) Implement special procedure for writing synthetic input sections (like we do with writeBuildId).

[ruiu]

I'm okay with virtualizing writeTo, but Rafael might have something to say because he seems to try to avoid virtual functions for InputSection class.

[ruiu]

LGTM. Rafael, if you have any comment, please do it as a post commit review.

lld/trunk/ELF/InputSection.h

InputSectionData(Kind SectionKind, StringRef Name, ArrayRef<uint8_t> Data,
                    bool Compressed, bool Live)
       : SectionKind(SectionKind), Live(Live), Compressed(Compressed),
         Name(Name), Data(Data) {}
 
 private:
   unsigned SectionKind : 3;
 
 public:
+  virtual ~InputSectionData() = default;
+  InputSectionData(InputSectionData &&) = default;
   Kind kind() const { return (Kind)SectionKind; }
 
   unsigned Live : 1; // for garbage collection
   unsigned Compressed : 1;
   uint32_t Alignment;
   StringRef Name;
   ArrayRef<uint8_t> Data;
 
   template <typename T> llvm::ArrayRef<T> getDataAs() const {
     size_t S = Data.size();
     assert(S % sizeof(T) == 0);
     return llvm::makeArrayRef<T>((const T *)Data.data(), S / sizeof(T));
   }
 
+  virtual void writeTo(uint8_t *Buf) {}
+  virtual size_t getSize() const { return Data.size(); }
+
   // If a section is compressed, this has the uncompressed section data.
   std::unique_ptr<uint8_t[]> UncompressedData;
 
   std::vector<Relocation> Relocations;
 };
 
 // This corresponds to a section of an input file.
 template <class ELFT> class InputSectionBase : public InputSectionData {
public:
 
   // This pointer points to the "real" instance of this instance.
   // Usually Repl == this. However, if ICF merges two sections,
   // Repl pointer of one section points to another section. So,
   // if you need to get a pointer to this instance, do not use
   // this but instead this->Repl.
   InputSectionBase<ELFT> *Repl;
 
-  // Returns the size of this section (even if this is a common or BSS.)
-  size_t getSize() const;
-
   static InputSectionBase<ELFT> Discarded;
 
   ObjectFile<ELFT> *getFile() const { return File; }
   uintX_t getOffset(const DefinedRegular<ELFT> &Sym) const;
   InputSectionBase *getLinkOrderDep() const;
   // Translate an offset in the input section to an offset in the output
   // section.
   uintX_t getOffset(uintX_t Offset) const;

 
 public:
   InputSection(uintX_t Flags, uint32_t Type, uintX_t Addralign,
                ArrayRef<uint8_t> Data, StringRef Name);
   InputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header, StringRef Name);
 
   // Write this section to a mmap'ed file, assuming Buf is pointing to
   // beginning of the output section.
-  void writeTo(uint8_t *Buf);
+  void writeTo(uint8_t *Buf) override;
 
   // 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;
 
public:
   void addThunk(const Thunk<ELFT> *T);
 
   // The offset of synthetic thunk code from beginning of this section.
   uint64_t getThunkOff() const;
 
   // Size of chunk with thunks code.
   uint64_t getThunksSize() const;
 
+  // Size of section in bytes.
+  size_t getSize() const override;
+
   template <class RelTy>
   void relocateNonAlloc(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
 
 private:
   template <class RelTy>
   void copyRelocations(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
 
   // Called by ICF to merge two input sections.

lld/trunk/ELF/InputSection.cpp

InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
                                          const Elf_Shdr *Hdr, StringRef Name,
                                          Kind SectionKind)
     : InputSectionBase(File, Hdr->sh_flags, Hdr->sh_type, Hdr->sh_entsize,
                        Hdr->sh_link, Hdr->sh_info, Hdr->sh_addralign,
                        getSectionContents(File, Hdr), Name, SectionKind) {
   this->Offset = Hdr->sh_offset;
 }
 
-template <class ELFT> size_t InputSectionBase<ELFT>::getSize() const {
-  if (auto *D = dyn_cast<InputSection<ELFT>>(this))
-    if (D->getThunksSize() > 0)
-      return D->getThunkOff() + D->getThunksSize();
-  return Data.size();
-}
-
 // Returns a string for an error message.
 template <class SectionT> static std::string getName(SectionT *Sec) {
   return (Sec->getFile()->getName() + "(" + Sec->Name + ")").str();
 }
 
 template <class ELFT>
 typename ELFT::uint InputSectionBase<ELFT>::getOffset(uintX_t Offset) const {
   switch (kind()) {
InputSection<ELFT>::InputSection(elf::ObjectFile<ELFT> *F,
                                  const Elf_Shdr *Header, StringRef Name)
     : InputSectionBase<ELFT>(F, Header, Name, Base::Regular) {}
 
 template <class ELFT>
 bool InputSection<ELFT>::classof(const InputSectionData *S) {
   return S->kind() == Base::Regular;
 }
 
+template <class ELFT> size_t InputSection<ELFT>::getSize() const {
+  return getThunksSize() > 0 ? getThunkOff() + getThunksSize()
+                             : this->Data.size();
+}
+
 template <class ELFT>
 InputSectionBase<ELFT> *InputSection<ELFT>::getRelocatedSection() {
   assert(this->Type == SHT_RELA || this->Type == SHT_REL);
   ArrayRef<InputSectionBase<ELFT> *> Sections = this->File->getSections();
   return Sections[this->Info];
 }
 
 template <class ELFT> void InputSection<ELFT>::addThunk(const Thunk<ELFT> *T) {

lld/trunk/ELF/SyntheticSections.h

 template <class ELFT> class InterpSection final : public InputSection<ELFT> {
 public:
   InterpSection();
 };
 
 // .note.gnu.build-id section.
 template <class ELFT> class BuildIdSection : public InputSection<ELFT> {
 public:
+  void writeTo(uint8_t *Buf) override;
+  size_t getSize() const override { return 16 + HashSize; }
   virtual void writeBuildId(llvm::MutableArrayRef<uint8_t> Buf) = 0;
   virtual ~BuildIdSection() = default;
 
   uint8_t *getOutputLoc(uint8_t *Start) const;
 
 protected:
   BuildIdSection(size_t HashSize);
-  std::vector<uint8_t> Buf;
 
   void
   computeHash(llvm::MutableArrayRef<uint8_t> Buf,
               std::function<void(ArrayRef<uint8_t> Arr, uint8_t *Hash)> Hash);
 
   size_t HashSize;
 };
 

lld/trunk/ELF/SyntheticSections.cpp

 }
 
 template <class ELFT>
 BuildIdSection<ELFT>::BuildIdSection(size_t HashSize)
     : InputSection<ELFT>(SHF_ALLOC, SHT_NOTE, 1, ArrayRef<uint8_t>(),
                          ".note.gnu.build-id"),
       HashSize(HashSize) {
   this->Live = true;
+}
 
-  Buf.resize(16 + HashSize);
+template <class ELFT> void BuildIdSection<ELFT>::writeTo(uint8_t *Buf) {
   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);
+  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
 }
 
 template <class ELFT>
 uint8_t *BuildIdSection<ELFT>::getOutputLoc(uint8_t *Start) const {
   return Start + this->OutSec->getFileOffset() + this->OutSecOff;
 }
 
 static std::vector<ArrayRef<uint8_t>> split(ArrayRef<uint8_t> Arr,