Index: ELF/InputSection.h
===================================================================
--- ELF/InputSection.h
+++ ELF/InputSection.h
@@ -52,6 +52,8 @@
   unsigned SectionKind : 3;
 
 public:
+  virtual ~InputSectionData() = default;
+  InputSectionData(InputSectionData &&) = default;
   Kind kind() const { return (Kind)SectionKind; }
 
   unsigned Live : 1; // for garbage collection
@@ -66,6 +68,9 @@
     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;
 
@@ -113,9 +118,6 @@
   // 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; }
@@ -243,7 +245,7 @@
 
   // 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;
@@ -270,6 +272,9 @@
   // 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);
 
Index: ELF/InputSection.cpp
===================================================================
--- ELF/InputSection.cpp
+++ ELF/InputSection.cpp
@@ -79,13 +79,6 @@
   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();
@@ -207,6 +200,11 @@
   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);
Index: ELF/SyntheticSections.h
===================================================================
--- ELF/SyntheticSections.h
+++ ELF/SyntheticSections.h
@@ -17,6 +17,8 @@
 
 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;
 
@@ -24,7 +26,7 @@
 
 protected:
   BuildIdSection(size_t HashSize);
-  std::vector<uint8_t> Buf;
+  size_t HashSize;
 };
 
 template <class ELFT>
Index: ELF/SyntheticSections.cpp
===================================================================
--- ELF/SyntheticSections.cpp
+++ ELF/SyntheticSections.cpp
@@ -39,14 +39,15 @@
 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);
+                         ".note.gnu.build-id"),
+      HashSize(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>