[llvm-objcopy] [COFF] Remove pointless Reader/Writer base classes. NFC.

[mstorsjo]

Summary

These were copied as part of the original design from the ELF backend, but aren't necessary at the moment.

In the original review of the initial COFF backend, I tried to get an opionion on whether to keep them or not, but I guess it drowned in the rest of that review. @alexshap pointed out in D55881 that they could be removed.

[jhenderson]

LGTM. I have no issue with this, but I'd like @jakehehrlich to give his opinion as essentially it's a design choice as to how much the COFF structure of llvm-objcopy should match the ELF structure.

[rupprecht]

I think there's a chance we'll end up reintroducing this in some form, e.g. to support something like "-I binary -O <coff format>" (or vice versa), but it's usually a bad idea to leave speculative code lying around, so LGTM.

llvm/trunk/tools/llvm-objcopy/COFF/Reader.h

 namespace llvm {
 namespace objcopy {
 namespace coff {
 
 struct Object;
 
 using object::COFFObjectFile;
 
-class Reader {
-public:
-  virtual ~Reader();
-  virtual Expected<std::unique_ptr<Object>> create() const = 0;
-};
-
-class COFFReader : public Reader {
+class COFFReader {
   const COFFObjectFile &COFFObj;
 
   Error readExecutableHeaders(Object &Obj) const;
   Error readSections(Object &Obj) const;
   Error readSymbols(Object &Obj, bool IsBigObj) const;
   Error setRelocTargets(Object &Obj) const;
 
 public:
   explicit COFFReader(const COFFObjectFile &O) : COFFObj(O) {}
-  Expected<std::unique_ptr<Object>> create() const override;
+  Expected<std::unique_ptr<Object>> create() const;
 };
 
 } // end namespace coff
 } // end namespace objcopy
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OBJCOPY_COFF_READER_H

llvm/trunk/tools/llvm-objcopy/COFF/Reader.cpp

 #include <cstdint>
 
 namespace llvm {
 namespace objcopy {
 namespace coff {
 
 using namespace object;
 
-Reader::~Reader() {}
-
 Error COFFReader::readExecutableHeaders(Object &Obj) const {
   const dos_header *DH = COFFObj.getDOSHeader();
   Obj.Is64 = COFFObj.is64();
   if (!DH)
     return Error::success();
 
   Obj.IsPE = true;
   Obj.DosHeader = *DH;

llvm/trunk/tools/llvm-objcopy/COFF/Writer.h

 #include <utility>
 
 namespace llvm {
 namespace objcopy {
 namespace coff {
 
 struct Object;
 
-class Writer {
-protected:
+class COFFWriter {
   Object &Obj;
   Buffer &Buf;
 
-public:
-  virtual ~Writer();
-  virtual Error write() = 0;
-
-  Writer(Object &O, Buffer &B) : Obj(O), Buf(B) {}
-};
-
-class COFFWriter : public Writer {
   size_t FileSize;
   size_t FileAlignment;
   size_t SizeOfInitializedData;
   StringTableBuilder StrTabBuilder;
 
   Error finalizeRelocTargets();
   void layoutSections();
   size_t finalizeStringTable();
   template <class SymbolTy> std::pair<size_t, size_t> finalizeSymbolTable();
 
   Error finalize(bool IsBigObj);
 
   void writeHeaders(bool IsBigObj);
   void writeSections();
   template <class SymbolTy> void writeSymbolStringTables();
 
   Error write(bool IsBigObj);
 
   Error patchDebugDirectory();
 
 public:
   virtual ~COFFWriter() {}
-  Error write() override;
+  Error write();
 
   COFFWriter(Object &Obj, Buffer &Buf)
-      : Writer(Obj, Buf), StrTabBuilder(StringTableBuilder::WinCOFF) {}
+      : Obj(Obj), Buf(Buf), StrTabBuilder(StringTableBuilder::WinCOFF) {}
 };
 
 } // end namespace coff
 } // end namespace objcopy
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OBJCOPY_COFF_WRITER_H

llvm/trunk/tools/llvm-objcopy/COFF/Writer.cpp

 
 namespace llvm {
 namespace objcopy {
 namespace coff {
 
 using namespace object;
 using namespace COFF;
 
-Writer::~Writer() {}
-
 Error COFFWriter::finalizeRelocTargets() {
   for (Section &Sec : Obj.Sections) {
     for (Relocation &R : Sec.Relocs) {
       const Symbol *Sym = Obj.findSymbol(R.Target);
       if (Sym == nullptr)
         return make_error<StringError>("Relocation target " + R.TargetName +
                                            " (" + Twine(R.Target) +
                                            ") not found",