ELF: Remove <Arch>ELFReader.h. NFC.

<Arch>ELFReader.h contains only a few typedefs. The typedefs are used
only by one class in <Arch>TargetHandler.h. Thus, the headers don't
worth to be independent files.

Since MipsELFReader.h contains code other than the boilerplate, I didn't
touch that file in this patch.

llvm-svn: 234056

lld/lib/ReaderWriter/ELF/AArch64/AArch64ELFReader.h

@@ -1,30 +0,0 @@
-//===- lib/ReaderWriter/ELF/AArch64/AArch64ELFReader.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_AARCH64_AARCH64_ELF_READER_H
-#define LLD_READER_WRITER_AARCH64_AARCH64_ELF_READER_H
-
-#include "ELFReader.h"
-
-namespace lld {
-namespace elf {
-
-class AArch64LinkingContext;
-
-typedef llvm::object::ELFType<llvm::support::little, 2, true> AArch64ELFType;
-
-typedef ELFObjectReader<AArch64ELFType, AArch64LinkingContext,
-                        lld::elf::ELFFile> AArch64ELFObjectReader;
-
-typedef ELFDSOReader<AArch64ELFType, AArch64LinkingContext> AArch64ELFDSOReader;
-
-} // namespace elf
-} // namespace lld
-
-#endif // LLD_READER_WRITER_AARCH64_AARCH64_ELF_READER_H

lld/lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.h

@@ -10,8 +10,8 @@
 #ifndef LLD_READER_WRITER_ELF_AARCH64_AARCH64_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_AARCH64_AARCH64_TARGET_HANDLER_H
 
-#include "AArch64ELFReader.h"
 #include "AArch64RelocationHandler.h"
+#include "ELFReader.h"
 #include "TargetLayout.h"
 #include "lld/Core/Simple.h"
 
@@ -20,6 +20,11 @@ namespace elf {
 class AArch64LinkingContext;
 
 class AArch64TargetHandler final : public TargetHandler {
+  typedef llvm::object::ELFType<llvm::support::little, 2, true> ELFTy;
+  typedef ELFObjectReader<ELFTy, AArch64LinkingContext, lld::elf::ELFFile>
+      ObjReader;
+  typedef ELFDSOReader<AArch64ELFType, AArch64LinkingContext> DSOReader;
+
 public:
   AArch64TargetHandler(AArch64LinkingContext &ctx);
 
@@ -28,18 +33,18 @@ public:
   }
 
   std::unique_ptr<Reader> getObjReader() override {
-    return llvm::make_unique<AArch64ELFObjectReader>(_ctx);
+    return llvm::make_unique<ObjReader>(_ctx);
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
-    return llvm::make_unique<AArch64ELFDSOReader>(_ctx);
+    return llvm::make_unique<DSOReader>(_ctx);
   }
 
   std::unique_ptr<Writer> getWriter() override;
 
 private:
   AArch64LinkingContext &_ctx;
-  std::unique_ptr<TargetLayout<AArch64ELFType>> _targetLayout;
+  std::unique_ptr<TargetLayout<ELFTy>> _targetLayout;
   std::unique_ptr<AArch64TargetRelocationHandler> _relocationHandler;
 };
 

lld/lib/ReaderWriter/ELF/ARM/ARMELFReader.h

@@ -1,28 +0,0 @@
-//===--------- lib/ReaderWriter/ELF/ARM/ARMELFReader.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_ARM_ARM_ELF_READER_H
-#define LLD_READER_WRITER_ARM_ARM_ELF_READER_H
-
-#include "ARMELFFile.h"
-#include "ELFReader.h"
-
-namespace lld {
-namespace elf {
-
-typedef llvm::object::ELFType<llvm::support::little, 2, false> ARMELFType;
-
-typedef ELFObjectReader<ARMELFType, ARMLinkingContext, lld::elf::ARMELFFile>
-    ARMELFObjectReader;
-typedef ELFDSOReader<ARMELFType, ARMLinkingContext> ARMELFDSOReader;
-
-} // namespace elf
-} // namespace lld
-
-#endif // LLD_READER_WRITER_ARM_ARM_ELF_READER_H

lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

@@ -11,8 +11,8 @@
 #define LLD_READER_WRITER_ELF_ARM_ARM_TARGET_HANDLER_H
 
 #include "ARMELFFile.h"
-#include "ARMELFReader.h"
 #include "ARMRelocationHandler.h"
+#include "ELFReader.h"
 #include "TargetLayout.h"
 #include "llvm/ADT/Optional.h"
 
@@ -60,6 +60,11 @@ private:
 };
 
 class ARMTargetHandler final : public TargetHandler {
+  typedef llvm::object::ELFType<llvm::support::little, 2, false> ELFTy;
+  typedef ELFObjectReader<ELFTy, ARMLinkingContext, lld::elf::ARMELFFile>
+      ObjReader;
+  typedef ELFDSOReader<ELFTy, ARMLinkingContext> DSOReader;
+
 public:
   ARMTargetHandler(ARMLinkingContext &ctx);
 
@@ -68,18 +73,18 @@ public:
   }
 
   std::unique_ptr<Reader> getObjReader() override {
-    return llvm::make_unique<ARMELFObjectReader>(_ctx);
+    return llvm::make_unique<ObjReader>(_ctx);
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
-    return llvm::make_unique<ARMELFDSOReader>(_ctx);
+    return llvm::make_unique<DSOReader>(_ctx);
   }
 
   std::unique_ptr<Writer> getWriter() override;
 
 private:
   ARMLinkingContext &_ctx;
-  std::unique_ptr<ARMTargetLayout<ARMELFType>> _targetLayout;
+  std::unique_ptr<ARMTargetLayout<ELFTy>> _targetLayout;
   std::unique_ptr<ARMTargetRelocationHandler> _relocationHandler;
 };
 

lld/lib/ReaderWriter/ELF/Hexagon/HexagonELFReader.h

@@ -1,28 +0,0 @@
-//===- lib/ReaderWriter/ELF/HexagonELFReader.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_HEXAGON_ELF_READER_H
-#define LLD_READER_WRITER_HEXAGON_ELF_READER_H
-
-#include "ELFReader.h"
-#include "HexagonELFFile.h"
-
-namespace lld {
-namespace elf {
-
-typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
-
-typedef ELFObjectReader<HexagonELFType, HexagonLinkingContext,
-                        lld::elf::HexagonELFFile> HexagonELFObjectReader;
-typedef ELFDSOReader<HexagonELFType, HexagonLinkingContext> HexagonELFDSOReader;
-
-} // namespace elf
-} // namespace lld
-
-#endif // LLD_READER_WRITER_ELF_READER_H

lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

@@ -10,7 +10,8 @@
 #ifndef HEXAGON_TARGET_HANDLER_H
 #define HEXAGON_TARGET_HANDLER_H
 
-#include "HexagonELFReader.h"
+#include "ELFReader.h"
+#include "HexagonELFFile.h"
 #include "HexagonExecutableAtoms.h"
 #include "HexagonRelocationHandler.h"
 #include "HexagonSectionChunks.h"
@@ -97,6 +98,11 @@ private:
 
 /// \brief TargetHandler for Hexagon
 class HexagonTargetHandler final : public TargetHandler {
+  typedef llvm::object::ELFType<llvm::support::little, 2, false> ELFTy;
+  typedef ELFObjectReader<ELFTy, HexagonLinkingContext,
+                          lld::elf::HexagonELFFile> ObjReader;
+  typedef ELFDSOReader<ELFTy, HexagonLinkingContext> ELFDSOReader;
+
 public:
   HexagonTargetHandler(HexagonLinkingContext &targetInfo);
 
@@ -105,19 +111,19 @@ public:
   }
 
   std::unique_ptr<Reader> getObjReader() override {
-    return llvm::make_unique<HexagonELFObjectReader>(_ctx);
+    return llvm::make_unique<ObjReader>(_ctx);
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
-    return llvm::make_unique<HexagonELFDSOReader>(_ctx);
+    return llvm::make_unique<ELFDSOReader>(_ctx);
   }
 
   std::unique_ptr<Writer> getWriter() override;
 
 private:
   HexagonLinkingContext &_ctx;
-  std::unique_ptr<HexagonRuntimeFile<HexagonELFType>> _runtimeFile;
+  std::unique_ptr<HexagonRuntimeFile<ELFTy>> _runtimeFile;
-  std::unique_ptr<HexagonTargetLayout<HexagonELFType>> _targetLayout;
+  std::unique_ptr<HexagonTargetLayout<ELFTy>> _targetLayout;
   std::unique_ptr<HexagonTargetRelocationHandler> _relocationHandler;
 };
 

lld/lib/ReaderWriter/ELF/X86/X86ELFReader.h

@@ -1,28 +0,0 @@
-//===- lib/ReaderWriter/ELF/X86/X86ELFReader.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_X86_X86_ELF_READER_H
-#define LLD_READER_WRITER_X86_X86_ELF_READER_H
-
-#include "ELFReader.h"
-
-namespace lld {
-namespace elf {
-
-class X86LinkingContext;
-typedef llvm::object::ELFType<llvm::support::little, 2, false> X86ELFType;
-
-typedef ELFObjectReader<X86ELFType, X86LinkingContext, lld::elf::ELFFile>
-    X86ELFObjectReader;
-typedef ELFDSOReader<X86ELFType, X86LinkingContext> X86ELFDSOReader;
-
-} // namespace elf
-} // namespace lld
-
-#endif // LLD_READER_WRITER_X86_X86_ELF_READER_H

lld/lib/ReaderWriter/ELF/X86/X86TargetHandler.h

@@ -11,7 +11,7 @@
 #define LLD_READER_WRITER_ELF_X86_TARGET_HANDLER_H
 
 #include "TargetLayout.h"
-#include "X86ELFReader.h"
+#include "ELFReader.h"
 #include "X86RelocationHandler.h"
 
 namespace lld {
@@ -20,6 +20,11 @@ namespace elf {
 class X86LinkingContext;
 
 class X86TargetHandler final : public TargetHandler {
+  typedef llvm::object::ELFType<llvm::support::little, 2, false> ELFTy;
+  typedef ELFObjectReader<ELFTy, X86LinkingContext, lld::elf::ELFFile>
+      ObjReader;
+  typedef ELFDSOReader<ELFTy, X86LinkingContext> DSOReader;
+
 public:
   X86TargetHandler(X86LinkingContext &ctx);
 
@@ -28,18 +33,18 @@ public:
   }
 
   std::unique_ptr<Reader> getObjReader() override {
-    return llvm::make_unique<X86ELFObjectReader>(_ctx);
+    return llvm::make_unique<ObjReader>(_ctx);
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
-    return llvm::make_unique<X86ELFDSOReader>(_ctx);
+    return llvm::make_unique<DSOReader>(_ctx);
   }
 
   std::unique_ptr<Writer> getWriter() override;
 
 protected:
   X86LinkingContext &_ctx;
-  std::unique_ptr<TargetLayout<X86ELFType>> _targetLayout;
+  std::unique_ptr<TargetLayout<ELFTy>> _targetLayout;
   std::unique_ptr<X86TargetRelocationHandler> _relocationHandler;
 };
 } // end namespace elf

lld/lib/ReaderWriter/ELF/X86_64/X86_64ELFReader.h

@@ -1,28 +0,0 @@
-//===- lib/ReaderWriter/ELF/X86_64/X86_64ELFReader.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_X86_64_X86_64_ELF_READER_H
-#define LLD_READER_WRITER_X86_64_X86_64_ELF_READER_H
-
-#include "ELFReader.h"
-
-namespace lld {
-namespace elf {
-
-class X86_64LinkingContext;
-typedef llvm::object::ELFType<llvm::support::little, 2, true> X86_64ELFType;
-
-typedef ELFObjectReader<X86_64ELFType, X86_64LinkingContext, lld::elf::ELFFile>
-    X86_64ELFObjectReader;
-typedef ELFDSOReader<X86_64ELFType, X86_64LinkingContext> X86_64ELFDSOReader;
-
-} // namespace elf
-} // namespace lld
-
-#endif // LLD_READER_WRITER_ELF_X86_64_X86_64_READER_H

lld/lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h

@@ -10,8 +10,8 @@
 #ifndef LLD_READER_WRITER_ELF_X86_64_X86_64_TARGET_HANDLER_H
 #define LLD_READER_WRITER_ELF_X86_64_X86_64_TARGET_HANDLER_H
 
+#include "ELFReader.h"
 #include "TargetLayout.h"
-#include "X86_64ELFReader.h"
 #include "X86_64LinkingContext.h"
 #include "X86_64RelocationHandler.h"
 #include "lld/Core/Simple.h"
@@ -58,6 +58,11 @@ private:
 };
 
 class X86_64TargetHandler : public TargetHandler {
+  typedef llvm::object::ELFType<llvm::support::little, 2, true> ELFTy;
+  typedef ELFObjectReader<ELFTy, X86_64LinkingContext, lld::elf::ELFFile>
+      ObjReader;
+  typedef ELFDSOReader<ELFTy, X86_64LinkingContext> DSOReader;
+
 public:
   X86_64TargetHandler(X86_64LinkingContext &ctx);
 
@@ -66,11 +71,11 @@ public:
   }
 
   std::unique_ptr<Reader> getObjReader() override {
-    return llvm::make_unique<X86_64ELFObjectReader>(_ctx);
+    return llvm::make_unique<ObjReader>(_ctx);
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
-    return llvm::make_unique<X86_64ELFDSOReader>(_ctx);
+    return llvm::make_unique<DSOReader>(_ctx);
   }
 
   std::unique_ptr<Writer> getWriter() override;