LLD: ELF: Remove TargetHandler::getTargetLayout.

[ruiu]

Summary

Only MIPS used that member function, and by removing the use of the
function, I removed a static_cast. Seems like it's a win.

[atanasyan]

Really cool. Thanks for cleaning up the code.

lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.h

 public:
   AArch64TargetLayout(AArch64LinkingContext &ctx) : TargetLayout<ELFT>(ctx) {}
 };
 
 class AArch64TargetHandler final : public DefaultTargetHandler<AArch64ELFType> {
 public:
   AArch64TargetHandler(AArch64LinkingContext &ctx);
 
-  AArch64TargetLayout<AArch64ELFType> &getTargetLayout() override {
-    return *_aarch64TargetLayout;
-  }
-
   void registerRelocationNames(Registry &registry) override;
 
   const AArch64TargetRelocationHandler &getRelocationHandler() const override {
     return *_aarch64RelocationHandler;
   }
 
   std::unique_ptr<Reader> getObjReader() override {
     return std::unique_ptr<Reader>(new AArch64ELFObjectReader(_ctx));

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

private:
   // Cached value of the TLS offset from the $tp pointer.
   llvm::Optional<uint64_t> _tpOff;
 };
 
 class ARMTargetHandler final : public DefaultTargetHandler<ARMELFType> {
 public:
   ARMTargetHandler(ARMLinkingContext &ctx);
 
-  ARMTargetLayout<ARMELFType> &getTargetLayout() override {
-    return *_armTargetLayout;
-  }
-
   void registerRelocationNames(Registry &registry) override;
 
   const ARMTargetRelocationHandler &getRelocationHandler() const override {
     return *_armRelocationHandler;
   }
 
   std::unique_ptr<Reader> getObjReader() override {
     return std::unique_ptr<Reader>(new ARMELFObjectReader(_ctx));

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

public:
   HexagonTargetHandler(HexagonLinkingContext &targetInfo);
 
   void registerRelocationNames(Registry &registry) override;
 
   const HexagonTargetRelocationHandler &getRelocationHandler() const override {
     return *_hexagonRelocationHandler;
   }
 
-  HexagonTargetLayout<HexagonELFType> &getTargetLayout() override {
-    return *_hexagonTargetLayout;
-  }
-
   std::unique_ptr<Reader> getObjReader() override {
     return llvm::make_unique<HexagonELFObjectReader>(_ctx);
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
     return llvm::make_unique<HexagonELFDSOReader>(_ctx);
   }
 

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.h

 #define LLD_READER_WRITER_ELF_MIPS_MIPS_RELOCATION_HANDLER_H
 
 #include "TargetHandler.h"
 #include "lld/Core/Reference.h"
 
 namespace lld {
 namespace elf {
 
+template<typename ELFT> class MipsTargetLayout;
+
 class MipsRelocationHandler : public TargetRelocationHandler {
 public:
   virtual Reference::Addend readAddend(Reference::KindValue kind,
                                        const uint8_t *content) const = 0;
 };
 
 template <class ELFT>
 std::unique_ptr<TargetRelocationHandler>
-createMipsRelocationHandler(MipsLinkingContext &ctx);
+createMipsRelocationHandler(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout);
 
 } // elf
 } // lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

struct MipsRelocationParams {
   uint8_t _size;  // Relocations's size in bytes
   uint64_t _mask; // Read/write mask of relocation
   uint8_t _shift; // Relocation's addendum left shift size
   bool _shuffle;  // Relocation's addendum/result needs to be shuffled
 };
 
 template <class ELFT> class RelocationHandler : public MipsRelocationHandler {
 public:
-  RelocationHandler(MipsLinkingContext &ctx) : _ctx(ctx) {}
+  RelocationHandler(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout)
+    : _ctx(ctx), _targetLayout(layout) {}
 
   std::error_code applyRelocation(ELFWriter &writer,
                                   llvm::FileOutputBuffer &buf,
                                   const lld::AtomLayout &atom,
                                   const Reference &ref) const override;
 
   Reference::Addend readAddend(Reference::KindValue kind,
                                const uint8_t *content) const override;
 
 private:
   MipsLinkingContext &_ctx;
+  MipsTargetLayout<ELFT> &_targetLayout;
 };
 }
 
 static MipsRelocationParams getRelocationParams(uint32_t rType) {
   switch (rType) {
   case R_MIPS_NONE:
     return {4, 0x0, 0, false};
   case R_MIPS_64:

 template <class ELFT>
 std::error_code RelocationHandler<ELFT>::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   if (ref.kindNamespace() != lld::Reference::KindNamespace::ELF)
     return std::error_code();
   assert(ref.kindArch() == Reference::KindArch::Mips);
 
-  auto &targetLayout = static_cast<MipsTargetLayout<ELFT> &>(
-      _ctx.getTargetHandler<ELFT>().getTargetLayout());
-
-  AtomLayout *gpAtom = targetLayout.getGP();
+  AtomLayout *gpAtom = _targetLayout.getGP();
   uint64_t gpAddr = gpAtom ? gpAtom->_virtualAddr : 0;
 
-  AtomLayout *gpDispAtom = targetLayout.getGPDisp();
+  AtomLayout *gpDispAtom = _targetLayout.getGPDisp();
   bool isGpDisp = gpDispAtom && ref.target() == gpDispAtom->_atom;
 
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t tgtAddr = writer.addressOfAtom(ref.target());
   uint64_t relAddr = atom._virtualAddr + ref.offsetInAtom();
 
   if (isMicroMipsAtom(ref.target()))
RelocationHandler<ELFT>::readAddend(Reference::KindValue kind,
   return (ins & params._mask) << params._shift;
 }
 
 namespace lld {
 namespace elf {
 
 template <>
 std::unique_ptr<TargetRelocationHandler>
-createMipsRelocationHandler<Mips32ELType>(MipsLinkingContext &ctx) {
-  return llvm::make_unique<RelocationHandler<Mips32ELType>>(ctx);
+createMipsRelocationHandler<Mips32ELType>(MipsLinkingContext &ctx,
+                                          MipsTargetLayout<Mips32ELType> &layout) {
+  return llvm::make_unique<RelocationHandler<Mips32ELType>>(ctx, layout);
 }
 
 template <>
 std::unique_ptr<TargetRelocationHandler>
-createMipsRelocationHandler<Mips64ELType>(MipsLinkingContext &ctx) {
-  return llvm::make_unique<RelocationHandler<Mips64ELType>>(ctx);
+createMipsRelocationHandler<Mips64ELType>(MipsLinkingContext &ctx,
+                                          MipsTargetLayout<Mips64ELType> &layout) {
+  return llvm::make_unique<RelocationHandler<Mips64ELType>>(ctx, layout);
 }
 
 } // elf
 } // lld

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

 
 /// \brief TargetHandler for Mips
 template <class ELFT>
 class MipsTargetHandler final : public DefaultTargetHandler<ELFT> {
 public:
   MipsTargetHandler(MipsLinkingContext &ctx)
       : _ctx(ctx), _runtimeFile(new MipsRuntimeFile<ELFT>(ctx)),
         _targetLayout(new MipsTargetLayout<ELFT>(ctx)),
-        _relocationHandler(createMipsRelocationHandler<ELFT>(ctx)) {}
-
-  MipsTargetLayout<ELFT> &getTargetLayout() override { return *_targetLayout; }
+        _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);
   }

lib/ReaderWriter/ELF/TargetHandler.h

virtual std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                           const Reference &) const = 0;
 };
 
 /// \brief TargetHandler contains all the information responsible to handle a
 /// a particular target on ELF. A target might wish to override implementation
 /// of creating atoms and how the atoms are written to the output file.
 template <class ELFT> class TargetHandler : public TargetHandlerBase {
 public:
-  /// The layout determined completely by the Target.
-  virtual TargetLayout<ELFT> &getTargetLayout() = 0;
-
   /// Determine how relocations need to be applied.
   virtual const TargetRelocationHandler &getRelocationHandler() const = 0;
 
   /// How does the target deal with reading input files.
   virtual std::unique_ptr<Reader> getObjReader() = 0;
 
   /// How does the target deal with reading dynamic libraries.
   virtual std::unique_ptr<Reader> getDSOReader() = 0;

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

public:
   X86TargetLayout(X86LinkingContext &ctx) : TargetLayout<ELFT>(ctx) {}
 };
 
 class X86TargetHandler final
     : public DefaultTargetHandler<X86ELFType> {
 public:
   X86TargetHandler(X86LinkingContext &ctx);
 
-  X86TargetLayout<X86ELFType> &getTargetLayout() override {
-    return *_x86TargetLayout;
-  }
-
   void registerRelocationNames(Registry &registry) override;
 
   const X86TargetRelocationHandler &getRelocationHandler() const override {
     return *_x86RelocationHandler;
   }
 
   std::unique_ptr<Reader> getObjReader() override {
     return llvm::make_unique<X86ELFObjectReader>(_ctx);

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h

public:
   }
 };
 
 class X86_64TargetHandler
     : public DefaultTargetHandler<X86_64ELFType> {
 public:
   X86_64TargetHandler(X86_64LinkingContext &ctx);
 
-  X86_64TargetLayout &getTargetLayout() override {
-    return *_x86_64TargetLayout;
-  }
-
   void registerRelocationNames(Registry &registry) override;
 
   const X86_64TargetRelocationHandler &getRelocationHandler() const override {
     return *_x86_64RelocationHandler;
   }
 
   std::unique_ptr<Reader> getObjReader() override {
     return llvm::make_unique<X86_64ELFObjectReader>(_ctx);