ELF: Mips: Remove unused field and almost-empty class.

[ruiu]

Summary

Looks like MipsTargetHandler::_runtimeFile is unused.
MipsRuntimeFile doesn't seem to add values to the base class,
so I removed that class too.

[atanasyan]

LGTM. Thanks

lib/ReaderWriter/ELF/Mips/MipsELFWriters.h

 //===- lib/ReaderWriter/ELF/Mips/MipsELFWriters.h -------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_WRITERS_H
 #define LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_WRITERS_H
 
 #include "MipsLinkingContext.h"
 
 namespace lld {
 namespace elf {
 
-template <class ELFT> class MipsRuntimeFile;
 template <class ELFT> class MipsTargetLayout;
 
 template <typename ELFT> class MipsELFWriter {
 public:
   MipsELFWriter(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout)
       : _ctx(ctx), _targetLayout(targetLayout) {}
 
   void setELFHeader(ELFHeader<ELFT> &elfHeader) {
void finalizeMipsRuntimeAtomValues() {
     setAtomValue("_gp_disp", gp);
     setAtomValue("__gnu_local_gp", gp);
   }
 
   bool hasGlobalGOTEntry(const Atom *a) const {
     return _targetLayout.getGOTSection().hasGlobalGOTEntry(a);
   }
 
-  std::unique_ptr<MipsRuntimeFile<ELFT>> createRuntimeFile() {
-    auto file = llvm::make_unique<MipsRuntimeFile<ELFT>>(_ctx);
+  std::unique_ptr<RuntimeFile<ELFT>> createRuntimeFile() {
+    auto file = llvm::make_unique<RuntimeFile<ELFT>>(_ctx, "Mips runtime file");
     if (_ctx.isDynamic()) {
       file->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
       file->addAbsoluteAtom("_gp");
       file->addAbsoluteAtom("_gp_disp");
       file->addAbsoluteAtom("__gnu_local_gp");
     }
     return file;
   }

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

 
 private:
   MipsGOTSection<ELFT> *_gotSection;
   MipsPLTSection<ELFT> *_pltSection;
   llvm::Optional<AtomLayout *> _gpAtom;
   llvm::Optional<AtomLayout *> _gpDispAtom;
 };
 
-/// \brief Mips Runtime file.
-template <class ELFT> class MipsRuntimeFile final : public RuntimeFile<ELFT> {
-public:
-  MipsRuntimeFile(MipsLinkingContext &ctx)
-      : RuntimeFile<ELFT>(ctx, "Mips runtime file") {}
-};
-
 /// \brief Auxiliary class holds relocation's names table.
 class MipsRelocationStringTable {
   static const Registry::KindStrings kindStrings[];
 
 public:
   static void registerTable(Registry &registry);
 };
 
 /// \brief TargetHandler for Mips
 template <class ELFT> class MipsTargetHandler final : public TargetHandler {
 public:
   MipsTargetHandler(MipsLinkingContext &ctx)
-      : _ctx(ctx), _runtimeFile(new MipsRuntimeFile<ELFT>(ctx)),
-        _targetLayout(new MipsTargetLayout<ELFT>(ctx)),
-        _relocationHandler(createMipsRelocationHandler<ELFT>(ctx, *_targetLayout)) {}
+      : _ctx(ctx), _targetLayout(new MipsTargetLayout<ELFT>(ctx)),
+        _relocationHandler(
+            createMipsRelocationHandler<ELFT>(ctx, *_targetLayout)) {}
 
   std::unique_ptr<Reader> getObjReader() override {
     return llvm::make_unique<MipsELFObjectReader<ELFT>>(_ctx);
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
     return llvm::make_unique<MipsELFDSOReader<ELFT>>(_ctx);
   }
public:
   }
 
   void registerRelocationNames(Registry &registry) override {
     MipsRelocationStringTable::registerTable(registry);
   }
 
 private:
   MipsLinkingContext &_ctx;
-  std::unique_ptr<MipsRuntimeFile<ELFT>> _runtimeFile;
   std::unique_ptr<MipsTargetLayout<ELFT>> _targetLayout;
   std::unique_ptr<TargetRelocationHandler> _relocationHandler;
 };
 
 template <class ELFT> class MipsSymbolTable : public SymbolTable<ELFT> {
 public:
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;