[llvm-objcopy] Aggressively remove templates to decrease code size

[jakehehrlich]

Summary

Prioir to supporting all 4 ELF formats the fully optimized LTO llvm-objcopy was 650 KB, afterwards it was 3.5 MB. This size increase was an issue for Chromium people who plan on shipping llvm-objcopy as part of the chromium toolchain (why this size issue exists is still a mystery to me). This change splits several classes into template and non template parts so that as little identical code is reproduced as possible. I measure the size afterwards to be 774 KB which is hardly bigger than 650 KB. Going forward this pattern should be followed to minimize the size increase we experience overtime.

[jakehehrlich]

This was caused by a difference between dynamic and static linking. This change only reduces the binary size by about 100 KB.

[jhenderson]

In D40999#950215, @jakehehrlich wrote:

This was caused by a difference between dynamic and static linking. This change only reduces the binary size by about 100 KB.

I'm glad that was the case, as I'm not sure I liked many of the changes this required!

tools/llvm-objcopy/Object.h

 
 public:
   void setSymTab(SymTabType *StrTab) { Symbols = StrTab; }
   void removeSectionReferences(const SectionBase *Sec) override;
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
 };
 
-template <class ELFT>
 class RelocationSection
     : public RelocSectionWithSymtabBase<SymbolTableSection> {
+protected:
+  std::vector<Relocation> Relocations;
+
+public:
+  void addRelocation(Relocation Rel) { Relocations.push_back(Rel); }
+
+  static bool classof(const SectionBase *S) {
+    if (S->Flags & ELF::SHF_ALLOC)
+      return false;
+    return S->Type == ELF::SHT_REL || S->Type == ELF::SHT_RELA;
+  }
+};
+
+template <class ELFT> class RelocationSectionImpl : public RelocationSection {
 private:
   using Elf_Rel = typename ELFT::Rel;
   using Elf_Rela = typename ELFT::Rela;
 
-  std::vector<Relocation> Relocations;
-
   template <class T> void writeRel(T *Buf) const;
 
 public:
-  void addRelocation(Relocation Rel) { Relocations.push_back(Rel); }
   void writeSection(FileOutputBuffer &Out) const override;
 
   static bool classof(const SectionBase *S) {
     if (S->Flags & ELF::SHF_ALLOC)
       return false;
     return S->Type == ELF::SHT_REL || S->Type == ELF::SHT_RELA;
   }
 };
public:
 
   static bool classof(const SectionBase *S) {
     if (!(S->Flags & ELF::SHF_ALLOC))
       return false;
     return S->Type == ELF::SHT_REL || S->Type == ELF::SHT_RELA;
   }
 };
 
-template <class ELFT> class Object {
-private:
+class Object {
+protected:
   using SecPtr = std::unique_ptr<SectionBase>;
   using SegPtr = std::unique_ptr<Segment>;
 
-  using Elf_Shdr = typename ELFT::Shdr;
-  using Elf_Ehdr = typename ELFT::Ehdr;
-  using Elf_Phdr = typename ELFT::Phdr;
-
-  void initSymbolTable(const object::ELFFile<ELFT> &ElfFile,
-                       SymbolTableSection *SymTab, SectionTableRef SecTable);
-  SecPtr makeSection(const object::ELFFile<ELFT> &ElfFile,
-                     const Elf_Shdr &Shdr);
-  void readProgramHeaders(const object::ELFFile<ELFT> &ElfFile);
-  SectionTableRef readSectionHeaders(const object::ELFFile<ELFT> &ElfFile);
-
-protected:
   StringTableSection *SectionNames = nullptr;
   SymbolTableSection *SymbolTable = nullptr;
   std::vector<SecPtr> Sections;
   std::vector<SegPtr> Segments;
 
-  void writeHeader(FileOutputBuffer &Out) const;
-  void writeProgramHeaders(FileOutputBuffer &Out) const;
   void writeSectionData(FileOutputBuffer &Out) const;
-  void writeSectionHeaders(FileOutputBuffer &Out) const;
+
+  virtual uint64_t shdrSize() const = 0;
+  virtual uint64_t ehdrSize() const = 0;
+  virtual uint64_t addrSize() const = 0;
 
 public:
   uint8_t Ident[16];
   uint64_t Entry;
   uint64_t SHOffset;
   uint32_t Type;
   uint32_t Machine;
   uint32_t Version;
   uint32_t Flags;
   bool WriteSectionHeaders = true;
 
-  Object(const object::ELFObjectFile<ELFT> &Obj);
   virtual ~Object() = default;
 
   const SymbolTableSection *getSymTab() const { return SymbolTable; }
   const SectionBase *getSectionHeaderStrTab() const { return SectionNames; }
   void removeSections(std::function<bool(const SectionBase &)> ToRemove);
   virtual size_t totalSize() const = 0;
   virtual void finalize() = 0;
   virtual void write(FileOutputBuffer &Out) const = 0;
 };
 
-template <class ELFT> class ELFObject : public Object<ELFT> {
+template <class ELFT> class ObjectImpl : public virtual Object {
 private:
   using SecPtr = std::unique_ptr<SectionBase>;
   using SegPtr = std::unique_ptr<Segment>;
 
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Ehdr = typename ELFT::Ehdr;
   using Elf_Phdr = typename ELFT::Phdr;
 
+  void initSymbolTable(const object::ELFFile<ELFT> &ElfFile,
+                       SymbolTableSection *SymTab, SectionTableRef SecTable);
+  SecPtr makeSection(const object::ELFFile<ELFT> &ElfFile,
+                     const Elf_Shdr &Shdr);
+  void readProgramHeaders(const object::ELFFile<ELFT> &ElfFile);
+  SectionTableRef readSectionHeaders(const object::ELFFile<ELFT> &ElfFile);
+
+protected:
+  void writeHeader(FileOutputBuffer &Out) const;
+  void writeProgramHeaders(FileOutputBuffer &Out) const;
+  void writeSectionHeaders(FileOutputBuffer &Out) const;
+
+  virtual uint64_t shdrSize() const { return sizeof(Elf_Shdr); }
+  virtual uint64_t ehdrSize() const { return sizeof(Elf_Ehdr); }
+  virtual uint64_t addrSize() const { return sizeof(typename ELFT::Addr); }
+
+public:
+  ObjectImpl(const object::ELFObjectFile<ELFT> &Obj);
+  virtual ~ObjectImpl() = default;
+};
+
+class ELFObject : public virtual Object {
+private:
+  using SecPtr = std::unique_ptr<SectionBase>;
+  using SegPtr = std::unique_ptr<Segment>;
+
   void sortSections();
   void assignOffsets();
 
 public:
-  ELFObject(const object::ELFObjectFile<ELFT> &Obj) : Object<ELFT>(Obj) {}
+  virtual ~ELFObject() = default;
 
   void finalize() override;
   size_t totalSize() const override;
+};
+
+template <class ELFT>
+class ELFObjectImpl : public ObjectImpl<ELFT>, public ELFObject {
+private:
+  using SecPtr = std::unique_ptr<SectionBase>;
+  using SegPtr = std::unique_ptr<Segment>;
+
+  using Elf_Shdr = typename ELFT::Shdr;
+  using Elf_Ehdr = typename ELFT::Ehdr;
+  using Elf_Phdr = typename ELFT::Phdr;
+
+public:
+  ELFObjectImpl(const object::ELFObjectFile<ELFT> &Obj)
+      : ObjectImpl<ELFT>(Obj) {}
+
   void write(FileOutputBuffer &Out) const override;
 };
 
-template <class ELFT> class BinaryObject : public Object<ELFT> {
+class BinaryObject : public virtual Object {
 private:
   using SecPtr = std::unique_ptr<SectionBase>;
   using SegPtr = std::unique_ptr<Segment>;
 
   uint64_t TotalSize;
 
 public:
-  BinaryObject(const object::ELFObjectFile<ELFT> &Obj) : Object<ELFT>(Obj) {}
+  virtual ~BinaryObject() = default;
 
   void finalize() override;
   size_t totalSize() const override;
   void write(FileOutputBuffer &Out) const override;
 };
 
+template <class ELFT>
+class BinaryObjectImpl : public ObjectImpl<ELFT>, public BinaryObject {
+public:
+  BinaryObjectImpl(const object::ELFObjectFile<ELFT> &Obj)
+      : ObjectImpl<ELFT>(Obj) {}
+};
+
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OBJCOPY_OBJECT_H

tools/llvm-objcopy/Object.cpp

 
 template <class ELFT>
 void setAddend(Elf_Rel_Impl<ELFT, true> &Rela, uint64_t Addend) {
   Rela.r_addend = Addend;
 }
 
 template <class ELFT>
 template <class T>
-void RelocationSection<ELFT>::writeRel(T *Buf) const {
+void RelocationSectionImpl<ELFT>::writeRel(T *Buf) const {
   for (const auto &Reloc : Relocations) {
     Buf->r_offset = Reloc.Offset;
     setAddend(*Buf, Reloc.Addend);
     Buf->setSymbolAndType(Reloc.RelocSymbol->Index, Reloc.Type, false);
     ++Buf;
   }
 }
 
 template <class ELFT>
-void RelocationSection<ELFT>::writeSection(FileOutputBuffer &Out) const {
+void RelocationSectionImpl<ELFT>::writeSection(FileOutputBuffer &Out) const {
   uint8_t *Buf = Out.getBufferStart() + Offset;
   if (Type == SHT_REL)
     writeRel(reinterpret_cast<Elf_Rel *>(Buf));
   else
     writeRel(reinterpret_cast<Elf_Rela *>(Buf));
 }
 
 void DynamicRelocationSection::writeSection(FileOutputBuffer &Out) const {
static bool compareSegments(const Segment *A, const Segment *B) {
   if (A->OriginalOffset < B->OriginalOffset)
     return true;
   if (A->OriginalOffset > B->OriginalOffset)
     return false;
   return A->Index < B->Index;
 }
 
 template <class ELFT>
-void Object<ELFT>::readProgramHeaders(const ELFFile<ELFT> &ElfFile) {
+void ObjectImpl<ELFT>::readProgramHeaders(const ELFFile<ELFT> &ElfFile) {
   uint32_t Index = 0;
   for (const auto &Phdr : unwrapOrError(ElfFile.program_headers())) {
     ArrayRef<uint8_t> Data{ElfFile.base() + Phdr.p_offset,
                            (size_t)Phdr.p_filesz};
     Segments.emplace_back(llvm::make_unique<Segment>(Data));
     Segment &Seg = *Segments.back();
     Seg.Type = Phdr.p_type;
     Seg.Flags = Phdr.p_flags;
for (auto &Parent : Segments) {
             Child->ParentSegment = Parent.get();
           }
       }
     }
   }
 }
 
 template <class ELFT>
-void Object<ELFT>::initSymbolTable(const object::ELFFile<ELFT> &ElfFile,
+void ObjectImpl<ELFT>::initSymbolTable(const object::ELFFile<ELFT> &ElfFile,
                                        SymbolTableSection *SymTab,
                                        SectionTableRef SecTable) {
   const Elf_Shdr &Shdr = *unwrapOrError(ElfFile.getSection(SymTab->Index));
   StringRef StrTabData = unwrapOrError(ElfFile.getStringTableForSymtab(Shdr));
 
   for (const auto &Sym : unwrapOrError(ElfFile.symbols(&Shdr))) {
     SectionBase *DefSection = nullptr;
     StringRef Name = unwrapOrError(Sym.getName(StrTabData));
 
     if (Sym.st_shndx >= SHN_LORESERVE) {

 template <class ELFT>
 static void getAddend(uint64_t &ToSet, const Elf_Rel_Impl<ELFT, false> &Rel) {}
 
 template <class ELFT>
 static void getAddend(uint64_t &ToSet, const Elf_Rel_Impl<ELFT, true> &Rela) {
   ToSet = Rela.r_addend;
 }
 
-template <class ELFT, class T>
-void initRelocations(RelocationSection<ELFT> *Relocs,
-                     SymbolTableSection *SymbolTable, T RelRange) {
+template <class T>
+void initRelocations(RelocationSection *Relocs, SymbolTableSection *SymbolTable,
+                     T RelRange) {
   for (const auto &Rel : RelRange) {
     Relocation ToAdd;
     ToAdd.Offset = Rel.r_offset;
     getAddend(ToAdd.Addend, Rel);
     ToAdd.Type = Rel.getType(false);
     ToAdd.RelocSymbol = SymbolTable->getSymbolByIndex(Rel.getSymbol(false));
     Relocs->addRelocation(ToAdd);
   }
T *SectionTableRef::getSectionOfType(uint16_t Index, Twine IndexErrMsg,
                                      Twine TypeErrMsg) {
   if (T *Sec = dyn_cast<T>(getSection(Index, IndexErrMsg)))
     return Sec;
   error(TypeErrMsg);
 }
 
 template <class ELFT>
 std::unique_ptr<SectionBase>
-Object<ELFT>::makeSection(const object::ELFFile<ELFT> &ElfFile,
+ObjectImpl<ELFT>::makeSection(const object::ELFFile<ELFT> &ElfFile,
                               const Elf_Shdr &Shdr) {
   ArrayRef<uint8_t> Data;
   switch (Shdr.sh_type) {
   case SHT_REL:
   case SHT_RELA:
     if (Shdr.sh_flags & SHF_ALLOC) {
       Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
       return llvm::make_unique<DynamicRelocationSection>(Data);
     }
-    return llvm::make_unique<RelocationSection<ELFT>>();
+    return llvm::make_unique<RelocationSectionImpl<ELFT>>();
   case SHT_STRTAB:
     // If a string table is allocated we don't want to mess with it. That would
     // mean altering the memory image. There are no special link types or
     // anything so we can just use a Section.
     if (Shdr.sh_flags & SHF_ALLOC) {
       Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
       return llvm::make_unique<Section>(Data);
     }
case SHT_NOBITS:
     return llvm::make_unique<Section>(Data);
   default:
     Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
     return llvm::make_unique<Section>(Data);
   }
 }
 
 template <class ELFT>
-SectionTableRef Object<ELFT>::readSectionHeaders(const ELFFile<ELFT> &ElfFile) {
+SectionTableRef
+ObjectImpl<ELFT>::readSectionHeaders(const ELFFile<ELFT> &ElfFile) {
   uint32_t Index = 0;
   for (const auto &Shdr : unwrapOrError(ElfFile.sections())) {
     if (Index == 0) {
       ++Index;
       continue;
     }
     SecPtr Sec = makeSection(ElfFile, Shdr);
     Sec->Name = unwrapOrError(ElfFile.getSectionName(&Shdr));
ObjectImpl<ELFT>::readSectionHeaders(const ELFFile<ELFT> &ElfFile) {
 
   // Now that all sections and symbols have been added we can add
   // relocations that reference symbols and set the link and info fields for
   // relocation sections.
   for (auto &Section : Sections) {
     if (Section.get() == SymbolTable)
       continue;
     Section->initialize(SecTable);
-    if (auto RelSec = dyn_cast<RelocationSection<ELFT>>(Section.get())) {
+    if (auto RelSec = dyn_cast<RelocationSectionImpl<ELFT>>(Section.get())) {
       auto Shdr = unwrapOrError(ElfFile.sections()).begin() + RelSec->Index;
       if (RelSec->Type == SHT_REL)
         initRelocations(RelSec, SymbolTable, unwrapOrError(ElfFile.rels(Shdr)));
       else
         initRelocations(RelSec, SymbolTable,
                         unwrapOrError(ElfFile.relas(Shdr)));
     }
   }
 
   return SecTable;
 }
 
-template <class ELFT> Object<ELFT>::Object(const ELFObjectFile<ELFT> &Obj) {
+template <class ELFT>
+ObjectImpl<ELFT>::ObjectImpl(const ELFObjectFile<ELFT> &Obj) {
   const auto &ElfFile = *Obj.getELFFile();
   const auto &Ehdr = *ElfFile.getHeader();
 
   std::copy(Ehdr.e_ident, Ehdr.e_ident + 16, Ident);
   Type = Ehdr.e_type;
   Machine = Ehdr.e_machine;
   Version = Ehdr.e_version;
   Entry = Ehdr.e_entry;
   Flags = Ehdr.e_flags;
 
   SectionTableRef SecTable = readSectionHeaders(ElfFile);
   readProgramHeaders(ElfFile);
 
   SectionNames = SecTable.getSectionOfType<StringTableSection>(
       Ehdr.e_shstrndx,
       "e_shstrndx field value " + Twine(Ehdr.e_shstrndx) + " in elf header " +
           " is invalid",
       "e_shstrndx field value " + Twine(Ehdr.e_shstrndx) + " in elf header " +
           " is not a string table");
 }
 
 template <class ELFT>
-void Object<ELFT>::writeHeader(FileOutputBuffer &Out) const {
+void ObjectImpl<ELFT>::writeHeader(FileOutputBuffer &Out) const {
   uint8_t *Buf = Out.getBufferStart();
   Elf_Ehdr &Ehdr = *reinterpret_cast<Elf_Ehdr *>(Buf);
   std::copy(Ident, Ident + 16, Ehdr.e_ident);
   Ehdr.e_type = Type;
   Ehdr.e_machine = Machine;
   Ehdr.e_version = Version;
   Ehdr.e_entry = Entry;
   Ehdr.e_phoff = sizeof(Elf_Ehdr);
void ObjectImpl<ELFT>::writeHeader(FileOutputBuffer &Out) const {
   } else {
     Ehdr.e_shoff = 0;
     Ehdr.e_shnum = 0;
     Ehdr.e_shstrndx = 0;
   }
 }
 
 template <class ELFT>
-void Object<ELFT>::writeProgramHeaders(FileOutputBuffer &Out) const {
+void ObjectImpl<ELFT>::writeProgramHeaders(FileOutputBuffer &Out) const {
   for (auto &Phdr : Segments)
     Phdr->template writeHeader<ELFT>(Out);
 }
 
 template <class ELFT>
-void Object<ELFT>::writeSectionHeaders(FileOutputBuffer &Out) const {
+void ObjectImpl<ELFT>::writeSectionHeaders(FileOutputBuffer &Out) const {
   uint8_t *Buf = Out.getBufferStart() + SHOffset;
   // This reference serves to write the dummy section header at the begining
   // of the file. It is not used for anything else
   Elf_Shdr &Shdr = *reinterpret_cast<Elf_Shdr *>(Buf);
   Shdr.sh_name = 0;
   Shdr.sh_type = SHT_NULL;
   Shdr.sh_flags = 0;
   Shdr.sh_addr = 0;
   Shdr.sh_offset = 0;
   Shdr.sh_size = 0;
   Shdr.sh_link = 0;
   Shdr.sh_info = 0;
   Shdr.sh_addralign = 0;
   Shdr.sh_entsize = 0;
 
   for (auto &Section : Sections)
     Section->template writeHeader<ELFT>(Out);
 }
 
-template <class ELFT>
-void Object<ELFT>::writeSectionData(FileOutputBuffer &Out) const {
+void Object::writeSectionData(FileOutputBuffer &Out) const {
   for (auto &Section : Sections)
     Section->writeSection(Out);
 }
 
-template <class ELFT>
-void Object<ELFT>::removeSections(
-    std::function<bool(const SectionBase &)> ToRemove) {
+void Object::removeSections(std::function<bool(const SectionBase &)> ToRemove) {
 
   auto Iter = std::stable_partition(
       std::begin(Sections), std::end(Sections), [=](const SecPtr &Sec) {
         if (ToRemove(*Sec))
           return false;
         if (auto RelSec = dyn_cast<RelocationSectionBase>(Sec.get())) {
           if (auto ToRelSec = RelSec->getSection())
             return !ToRemove(*ToRelSec);
for (auto &Segment : Segments)
       Segment->removeSection(RemoveSec.get());
     for (auto &KeepSec : make_range(std::begin(Sections), Iter))
       KeepSec->removeSectionReferences(RemoveSec.get());
   }
   // Now finally get rid of them all togethor.
   Sections.erase(Iter, std::end(Sections));
 }
 
-template <class ELFT> void ELFObject<ELFT>::sortSections() {
+void ELFObject::sortSections() {
   // Put all sections in offset order. Maintain the ordering as closely as
   // possible while meeting that demand however.
   auto CompareSections = [](const SecPtr &A, const SecPtr &B) {
     return A->OriginalOffset < B->OriginalOffset;
   };
   std::stable_sort(std::begin(this->Sections), std::end(this->Sections),
                    CompareSections);
 }
if (Section->ParentSegment != nullptr) {
       Section->Offset = Offset;
       if (Section->Type != SHT_NOBITS)
         Offset += Section->Size;
     }
   }
   return Offset;
 }
 
-template <class ELFT> void ELFObject<ELFT>::assignOffsets() {
+void ELFObject::assignOffsets() {
   // We need a temporary list of segments that has a special order to it
   // so that we know that anytime ->ParentSegment is set that segment has
   // already had its offset properly set.
   std::vector<Segment *> OrderedSegments;
   for (auto &Segment : this->Segments)
     OrderedSegments.push_back(Segment.get());
   OrderSegments(OrderedSegments);
   // The size of ELF + program headers will not change so it is ok to assume
   // that the first offset of the first segment is a good place to start
   // outputting sections. This covers both the standard case and the PT_PHDR
   // case.
   uint64_t Offset;
   if (!OrderedSegments.empty()) {
     Offset = OrderedSegments[0]->Offset;
   } else {
-    Offset = sizeof(Elf_Ehdr);
+    Offset = ehdrSize();
   }
   Offset = LayoutSegments(OrderedSegments, Offset);
   Offset = LayoutSections(this->Sections, Offset);
   // If we need to write the section header table out then we need to align the
   // Offset so that SHOffset is valid.
   if (this->WriteSectionHeaders)
-    Offset = alignTo(Offset, sizeof(typename ELFT::Addr));
+    Offset = alignTo(Offset, addrSize());
   this->SHOffset = Offset;
 }
 
-template <class ELFT> size_t ELFObject<ELFT>::totalSize() const {
+size_t ELFObject::totalSize() const {
   // We already have the section header offset so we can calculate the total
   // size by just adding up the size of each section header.
-  auto NullSectionSize = this->WriteSectionHeaders ? sizeof(Elf_Shdr) : 0;
-  return this->SHOffset + this->Sections.size() * sizeof(Elf_Shdr) +
-         NullSectionSize;
+  auto ShdrSize = shdrSize();
+  auto NullSectionSize = this->WriteSectionHeaders ? ShdrSize : 0;
+  return this->SHOffset + this->Sections.size() * ShdrSize + NullSectionSize;
 }
 
-template <class ELFT> void ELFObject<ELFT>::write(FileOutputBuffer &Out) const {
+template <class ELFT>
+void ELFObjectImpl<ELFT>::write(FileOutputBuffer &Out) const {
   this->writeHeader(Out);
   this->writeProgramHeaders(Out);
   this->writeSectionData(Out);
   if (this->WriteSectionHeaders)
     this->writeSectionHeaders(Out);
 }
 
-template <class ELFT> void ELFObject<ELFT>::finalize() {
+void ELFObject::finalize() {
   // Make sure we add the names of all the sections.
   if (this->SectionNames != nullptr)
     for (const auto &Section : this->Sections) {
       this->SectionNames->addString(Section->Name);
     }
   // Make sure we add the names of all the symbols.
   if (this->SymbolTable != nullptr)
     this->SymbolTable->addSymbolNames();
 
   sortSections();
   assignOffsets();
 
   // Finalize SectionNames first so that we can assign name indexes.
   if (this->SectionNames != nullptr)
     this->SectionNames->finalize();
   // Finally now that all offsets and indexes have been set we can finalize any
   // remaining issues.
-  uint64_t Offset = this->SHOffset + sizeof(Elf_Shdr);
+  auto ShdrSize = shdrSize();
+  uint64_t Offset = this->SHOffset + ShdrSize;
   for (auto &Section : this->Sections) {
     Section->HeaderOffset = Offset;
-    Offset += sizeof(Elf_Shdr);
+    Offset += ShdrSize;
     if (this->WriteSectionHeaders)
       Section->NameIndex = this->SectionNames->findIndex(Section->Name);
     Section->finalize();
   }
 }
 
-template <class ELFT> size_t BinaryObject<ELFT>::totalSize() const {
-  return TotalSize;
-}
+size_t BinaryObject::totalSize() const { return TotalSize; }
 
-template <class ELFT>
-void BinaryObject<ELFT>::write(FileOutputBuffer &Out) const {
+void BinaryObject::write(FileOutputBuffer &Out) const {
   for (auto &Section : this->Sections) {
     if ((Section->Flags & SHF_ALLOC) == 0)
       continue;
     Section->writeSection(Out);
   }
 }
 
-template <class ELFT> void BinaryObject<ELFT>::finalize() {
+void BinaryObject::finalize() {
   // TODO: Create a filter range to construct OrderedSegments from so that this
   // code can be deduped with assignOffsets above. This should also solve the
   // todo below for LayoutSections.
   // We need a temporary list of segments that has a special order to it
   // so that we know that anytime ->ParentSegment is set that segment has
   // already had it's offset properly set. We only want to consider the segments
   // that will affect layout of allocated sections so we only add those.
   std::vector<Segment *> OrderedSegments;
void BinaryObject::finalize() {
   for (const auto &Section : AllocatedSections) {
     if (Section->Type != SHT_NOBITS)
       TotalSize = std::max(TotalSize, Section->Offset + Section->Size);
   }
 }
 
 namespace llvm {
 
-template class Object<ELF64LE>;
-template class Object<ELF64BE>;
-template class Object<ELF32LE>;
-template class Object<ELF32BE>;
-
-template class ELFObject<ELF64LE>;
-template class ELFObject<ELF64BE>;
-template class ELFObject<ELF32LE>;
-template class ELFObject<ELF32BE>;
-
-template class BinaryObject<ELF64LE>;
-template class BinaryObject<ELF64BE>;
-template class BinaryObject<ELF32LE>;
-template class BinaryObject<ELF32BE>;
+template class ObjectImpl<ELF64LE>;
+template class ObjectImpl<ELF64BE>;
+template class ObjectImpl<ELF32LE>;
+template class ObjectImpl<ELF32BE>;
+
+template class ELFObjectImpl<ELF64LE>;
+template class ELFObjectImpl<ELF64BE>;
+template class ELFObjectImpl<ELF32LE>;
+template class ELFObjectImpl<ELF32BE>;
+
+template class BinaryObjectImpl<ELF64LE>;
+template class BinaryObjectImpl<ELF64BE>;
+template class BinaryObjectImpl<ELF32LE>;
+template class BinaryObjectImpl<ELF32BE>;
 
 } // end namespace llvm

tools/llvm-objcopy/llvm-objcopy.cpp

SplitDWO("split-dwo",
              cl::value_desc("dwo-file"));
 
 using SectionPred = std::function<bool(const SectionBase &Sec)>;
 
 bool IsDWOSection(const SectionBase &Sec) {
   return Sec.Name.endswith(".dwo");
 }
 
-template <class ELFT>
-bool OnlyKeepDWOPred(const Object<ELFT> &Obj, const SectionBase &Sec) {
+bool OnlyKeepDWOPred(const Object &Obj, const SectionBase &Sec) {
   // We can't remove the section header string table.
   if (&Sec == Obj.getSectionHeaderStrTab())
     return false;
   // Short of keeping the string table we want to keep everything that is a DWO
   // section and remove everything else.
   return !IsDWOSection(Sec);
 }
 
-template <class ELFT>
-void WriteObjectFile(const Object<ELFT> &Obj, StringRef File) {
+void WriteObjectFile(const Object &Obj, StringRef File) {
   std::unique_ptr<FileOutputBuffer> Buffer;
   Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
       FileOutputBuffer::create(File, Obj.totalSize(),
                                FileOutputBuffer::F_executable);
   handleAllErrors(BufferOrErr.takeError(), [](const ErrorInfoBase &) {
     error("failed to open " + OutputFilename);
   });
   Buffer = std::move(*BufferOrErr);
 
   Obj.write(*Buffer);
   if (auto E = Buffer->commit())
     reportError(File, errorToErrorCode(std::move(E)));
 }
 
 template <class ELFT>
 void SplitDWOToFile(const ELFObjectFile<ELFT> &ObjFile, StringRef File) {
   // Construct a second output file for the DWO sections.
-  ELFObject<ELFT> DWOFile(ObjFile);
+  ELFObjectImpl<ELFT> DWOFile(ObjFile);
 
-  DWOFile.removeSections([&](const SectionBase &Sec) {
-    return OnlyKeepDWOPred<ELFT>(DWOFile, Sec);
-  });
+  DWOFile.removeSections(
+      [&](const SectionBase &Sec) { return OnlyKeepDWOPred(DWOFile, Sec); });
   DWOFile.finalize();
   WriteObjectFile(DWOFile, File);
 }
 
 // This function handles the high level operations of GNU objcopy including
 // handling command line options. It's important to outline certain properties
 // we expect to hold of the command line operations. Any operation that "keeps"
 // should keep regardless of a remove. Additionally any removal should respect
 // any previous removals. Lastly whether or not something is removed shouldn't
 // depend a) on the order the options occur in or b) on some opaque priority
 // system. The only priority is that keeps/copies overrule removes.
-template <class ELFT>
-void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
-  std::unique_ptr<Object<ELFT>> Obj;
-
-  if (!OutputFormat.empty() && OutputFormat != "binary")
-    error("invalid output format '" + OutputFormat + "'");
-  if (!OutputFormat.empty() && OutputFormat == "binary")
-    Obj = llvm::make_unique<BinaryObject<ELFT>>(ObjFile);
-  else
-    Obj = llvm::make_unique<ELFObject<ELFT>>(ObjFile);
-
-  if (!SplitDWO.empty())
-    SplitDWOToFile<ELFT>(ObjFile, SplitDWO.getValue());
-
+void HandleArgs(std::unique_ptr<Object> Obj) {
   SectionPred RemovePred = [](const SectionBase &) { return false; };
 
   // Removes:
 
   if (!ToRemove.empty()) {
     RemovePred = [&](const SectionBase &Sec) {
       return std::find(std::begin(ToRemove), std::end(ToRemove), Sec.Name) !=
              std::end(ToRemove);
if (!Keep.empty()) {
     };
   }
 
   Obj->removeSections(RemovePred);
   Obj->finalize();
   WriteObjectFile(*Obj, OutputFilename.getValue());
 }
 
+template <class ELFT> void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
+  std::unique_ptr<Object> Obj;
+
+  if (!OutputFormat.empty() && OutputFormat != "binary")
+    error("invalid output format '" + OutputFormat + "'");
+  if (!OutputFormat.empty() && OutputFormat == "binary")
+    Obj = llvm::make_unique<BinaryObjectImpl<ELFT>>(ObjFile);
+  else
+    Obj = llvm::make_unique<ELFObjectImpl<ELFT>>(ObjFile);
+
+  // We don't want extra output files to be effected by options. Additionally
+  // SplitDWOToFile needs the original ObjFile object to work.
+  if (!SplitDWO.empty())
+    SplitDWOToFile<ELFT>(ObjFile, SplitDWO.getValue());
+
+  HandleArgs(std::move(Obj));
+}
+
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
   cl::ParseCommandLineOptions(argc, argv, "llvm objcopy utility\n");
   ToolName = argv[0];
   if (InputFilename.empty()) {