[lld] Fix the ELF shared library build targets

[garious]

Summary

lldELF is used by each ELF backend. lldELF's ELFLinkingContext
also held a reference to each backend, creating a link-time cycle.
This patch moves the backend references to lldDriver.

Here's a link-time dependency diagram for what is implemented here: http://yuml.me/324beed8.

[• shankar.easwaran]

Could we keep the headers for each of the Target linking contexts inside each target itself.

lib/Driver/GnuLdDriver.cpp

25

Can you create a header file that contains all the elf targets. You need to sort all the includes without this though.

[garious]

Per Shankar, tuck all ELF includes in one header that the Driver then includes.

[garious]

Hi Shankar,

Could we keep the headers for each of the Target linking contexts inside each target itself.

I'm not sure exactly what you're asking for. Do you want the header
that describe's the component's public interface to stay close to
home? Or do you not want some other, presumably smaller, interface to
represent the public interface?

Thanks,
Greg

[shankarke]

Yes, could we move it close to where all the target specific files live ?

[garious]

We could, but that would diverge from the way the LLVM repo is organized. I think a good compromise here would be to move all method implementations into each public header's respective .cpp file. Would you like me to do that as part of this patch?

[shankarke]

I dont follow, llvm keeps target specific header files outside target directories ?

[ruiu]

In this patch you moved lib/ReaderWriter/ELF/<arch>/<arch>LinkingContext to lib/ReaderWriter/ELF. Why did you have to do that? Because of that change, the size of this diff is large, so it is not easy to find the answer myself. Could you elaborate that a bit?

include/lld/ReaderWriter/ELF/Targets.h

21

I don't agree that this is a good idea. We should generally avoid transitive inclusions. If a source file depends on a bunch of headers, it actually depends on all of them. Hiding that dependency by replacing with one #include doesn't make things clean but makes things slightly worse.

lib/Driver/GnuLdDriver.cpp

343

Legitimate code should never reach here, no? If so, please use llvm_unreachable.

[garious]

The reason I moved the headers is because the driver needs access each target's LinkingContext constructor. Before this patch, that code was in lldELF which created a cyclic dependency.

Another option is to leave the headers where they were and do what the LLVM build does, which is to generate a header with only the constructor definitions. Going that route will allow us to configure a build with some targets and not others. I'll take a stab at that and attempt to come back with a smaller patch.

include/lld/ReaderWriter/ELF/Targets.h

21

It's a poor man's "<llvm>/include/llvm/Support/TargetSelect.h", which depends on the generated Targets.def. I can take a shot at implementing a similar header for LinkingContext constructors, but if that doesn't go well, I think this shim is the right short-term solution.

lib/Driver/GnuLdDriver.cpp

343

It can be reached by targeting an architecture that llvm supports but lld does not.

[garious]

This version leaves the targets' LinkingContext headers in their respective source directories and instead follows the pattern from the LLVM repo, which is to generate a header from the build configuration.

[• shankar.easwaran]

Lgtm

[garious]

Rui, any objections?

[ruiu]

Ah, no, sorry. LGTM.

[garious]

This version constructs the LinkingContext with static methods and a class factory. The previous version would blow up if a LinkingContext contained member variables.

Also, moved the triple test into their respective targets so that class factory registration could be generated from the configured targets. The registration is currently done by hand because:

• PPCLinkingContext needs to be renamed to PowerPCLinkingContext
• X86LinkingContext should construct other X86 or X86_64 context objects
• Need to add 'create' methods for all the unimplemented architectures

These changes are all easy to make, but to keep this patch readable, is not done here.

Note: the "if elseif elseif" code I added to the driver is ugly, but after the above changes, will be deleted. There's lots of ways to implement that bit of code and I'm hoping we can discuss none of them at this time. :)

[ruiu]

LGTM

lib/Driver/GnuLdDriver.cpp

328

This else-ifs can be early if-returns. s/else if/if/g

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.cpp

21

Remove this line

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.cpp

22

Remove this blank line

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.cpp

20

Ditto

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

24

Ditto

lib/ReaderWriter/ELF/PPC/PPCLinkingContext.cpp

23

Ditto

lib/ReaderWriter/ELF/X86/X86LinkingContext.cpp

23

Ditto

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.cpp

21

Ditto

[garious]

Should be fixed in r226989.

include/lld/ReaderWriter/ELF/AArch64LinkingContext.h

+//===- lld/ReaderWriter/ELF/AArch64LinkingContext.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_AARCH64_LINKING_CONTEXT_H
+#define LLD_READER_WRITER_ELF_AARCH64_LINKING_CONTEXT_H
+
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/ELF.h"
+
+namespace lld {
+namespace elf {
+
+enum {
+  /// \brief The offset to add operation for a R_AARCH64_ADR_GOT_PAGE
+  ADD_AARCH64_GOTRELINDEX = 0xE000,
+};
+
+class AArch64LinkingContext final : public ELFLinkingContext {
+public:
+  AArch64LinkingContext(llvm::Triple);
+
+  void addPasses(PassManager &) override;
+
+  uint64_t getBaseAddress() const override {
+    if (_baseAddress == 0)
+      return 0x400000;
+    return _baseAddress;
+  }
+
+  bool isDynamicRelocation(const DefinedAtom &,
+                           const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::AArch64);
+    switch (r.kindValue()) {
+    case llvm::ELF::R_AARCH64_COPY:
+    case llvm::ELF::R_AARCH64_GLOB_DAT:
+    case llvm::ELF::R_AARCH64_RELATIVE:
+    case llvm::ELF::R_AARCH64_TLS_DTPREL64:
+    case llvm::ELF::R_AARCH64_TLS_DTPMOD64:
+    case llvm::ELF::R_AARCH64_TLS_TPREL64:
+    case llvm::ELF::R_AARCH64_TLSDESC:
+    case llvm::ELF::R_AARCH64_IRELATIVE:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  bool isCopyRelocation(const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::AArch64);
+    if (r.kindValue() == llvm::ELF::R_AARCH64_COPY)
+      return true;
+    return false;
+  }
+
+  bool isPLTRelocation(const DefinedAtom &,
+                               const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::AArch64);
+    switch (r.kindValue()) {
+    case llvm::ELF::R_AARCH64_JUMP_SLOT:
+    case llvm::ELF::R_AARCH64_IRELATIVE:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  bool isRelativeReloc(const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::AArch64);
+    switch (r.kindValue()) {
+    case llvm::ELF::R_AARCH64_IRELATIVE:
+    case llvm::ELF::R_AARCH64_RELATIVE:
+      return true;
+    default:
+      return false;
+    }
+  }
+};
+} // end namespace elf
+} // end namespace lld
+
+#endif

include/lld/ReaderWriter/ELF/ARMLinkingContext.h

+//===--------- lld/ReaderWriter/ELF/ARMLinkingContext.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_ARM_LINKING_CONTEXT_H
+#define LLD_READER_WRITER_ELF_ARM_LINKING_CONTEXT_H
+
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/ELF.h"
+
+namespace lld {
+namespace elf {
+
+class ARMLinkingContext final : public ELFLinkingContext {
+public:
+  ARMLinkingContext(llvm::Triple);
+
+  void addPasses(PassManager &) override;
+
+  uint64_t getBaseAddress() const override {
+    if (_baseAddress == 0)
+      return 0x400000;
+    return _baseAddress;
+  }
+};
+} // end namespace elf
+} // end namespace lld
+
+#endif

include/lld/ReaderWriter/ELF/HexagonLinkingContext.h

+//===- lld/ReaderWriter/ELF/HexagonLinkingContext.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_HEXAGON_LINKING_CONTEXT_H
+#define LLD_READER_WRITER_ELF_HEXAGON_LINKING_CONTEXT_H
+
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/ELF.h"
+
+namespace lld {
+namespace elf {
+
+typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
+
+class HexagonLinkingContext final : public ELFLinkingContext {
+public:
+  HexagonLinkingContext(llvm::Triple);
+
+  void addPasses(PassManager &) override;
+
+  bool isDynamicRelocation(const DefinedAtom &,
+                           const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    switch (r.kindValue()) {
+    case llvm::ELF::R_HEX_RELATIVE:
+    case llvm::ELF::R_HEX_GLOB_DAT:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  bool isPLTRelocation(const DefinedAtom &, const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    switch (r.kindValue()) {
+    case llvm::ELF::R_HEX_JMP_SLOT:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  /// \brief Hexagon has only one relative relocation
+  /// a) for supporting relative relocs - R_HEX_RELATIVE
+  bool isRelativeReloc(const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    switch (r.kindValue()) {
+    case llvm::ELF::R_HEX_RELATIVE:
+      return true;
+    default:
+      return false;
+    }
+  }
+};
+
+} // elf
+} // lld
+
+#endif // LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H

include/lld/ReaderWriter/ELF/MipsELFFlagsMerger.h

+//===- lld/ReaderWriter/ELF/MipsELFFlagsMerger.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_ELF_FLAGS_MERGER_H
+#define LLD_READER_WRITER_ELF_MIPS_ELF_FLAGS_MERGER_H
+
+#include <mutex>
+#include <system_error>
+
+namespace lld {
+namespace elf {
+
+class MipsELFFlagsMerger {
+public:
+  MipsELFFlagsMerger();
+
+  uint32_t getMergedELFFlags() const;
+
+  /// \brief Merge saved ELF header flags and the new set of flags.
+  std::error_code merge(uint8_t newClass, uint32_t newFlags);
+
+private:
+  std::mutex _mutex;
+  uint32_t _flags;
+};
+
+} // namespace elf
+} // namespace lld
+
+#endif

include/lld/ReaderWriter/ELF/MipsLinkingContext.h

+//===- lld/ReaderWriter/ELF/MipsLinkingContext.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_LINKING_CONTEXT_H
+#define LLD_READER_WRITER_ELF_MIPS_LINKING_CONTEXT_H
+
+#include "lld/ReaderWriter/ELF/MipsELFFlagsMerger.h"
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+
+namespace lld {
+namespace elf {
+
+/// \brief Mips internal references.
+enum {
+  /// \brief Do nothing but mark GOT entry as a global one.
+  LLD_R_MIPS_GLOBAL_GOT = 1024,
+  /// \brief Apply high 16 bits of symbol + addend.
+  LLD_R_MIPS_32_HI16 = 1025,
+  /// \brief The same as R_MIPS_26 but for global symbols.
+  LLD_R_MIPS_GLOBAL_26 = 1026,
+  /// \brief Setup hi 16 bits using the symbol this reference refers to.
+  LLD_R_MIPS_HI16 = 1027,
+  /// \brief Setup low 16 bits using the symbol this reference refers to.
+  LLD_R_MIPS_LO16 = 1028,
+  /// \brief Represents a reference between PLT and dynamic symbol.
+  LLD_R_MIPS_STO_PLT = 1029,
+  /// \brief The same as R_MICROMIPS_26_S1 but for global symbols.
+  LLD_R_MICROMIPS_GLOBAL_26_S1 = 1030,
+};
+
+typedef llvm::object::ELFType<llvm::support::little, 2, false> Mips32ElELFType;
+
+template <class ELFType> class MipsTargetLayout;
+
+class MipsLinkingContext final : public ELFLinkingContext {
+public:
+  MipsLinkingContext(llvm::Triple);
+
+  uint32_t getMergedELFFlags() const;
+  MipsELFFlagsMerger &getELFFlagsMerger();
+
+  // ELFLinkingContext
+  uint64_t getBaseAddress() const override;
+  StringRef entrySymbolName() const override;
+  StringRef getDefaultInterpreter() const override;
+  void addPasses(PassManager &pm) override;
+  bool isRelaOutputFormat() const override { return false; }
+  bool isDynamicRelocation(const DefinedAtom &,
+                           const Reference &r) const override;
+  bool isCopyRelocation(const Reference &r) const override;
+  bool isPLTRelocation(const DefinedAtom &, const Reference &r) const override;
+
+private:
+  MipsELFFlagsMerger _flagsMerger;
+};
+
+} // elf
+} // lld
+
+#endif

include/lld/ReaderWriter/ELF/PPCLinkingContext.h

+//===- lld/ReaderWriter/ELF/PPCLinkingContext.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_PPC_LINKING_CONTEXT_H
+#define LLD_READER_WRITER_ELF_PPC_LINKING_CONTEXT_H
+
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/ELF.h"
+
+namespace lld {
+namespace elf {
+
+class PPCLinkingContext final : public ELFLinkingContext {
+public:
+  PPCLinkingContext(llvm::Triple);
+
+  /// \brief PPC has no relative relocations defined
+  bool isRelativeReloc(const Reference &) const override { return false; }
+};
+
+} // elf
+} // lld
+
+#endif // LLD_READER_WRITER_ELF_PPC_PPC_LINKING_CONTEXT_H

include/lld/ReaderWriter/ELF/Targets.h

+//===- lld/ReaderWriter/ELF/Targets.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_TARGETS_H
+#define LLD_READER_WRITER_ELF_TARGETS_H
+
+#include "AArch64LinkingContext.h"
+#include "ARMLinkingContext.h"
+#include "HexagonLinkingContext.h"
+#include "MipsLinkingContext.h"
+#include "PPCLinkingContext.h"
+#include "X86LinkingContext.h"
+#include "X86_64LinkingContext.h"
+
+#endif

include/lld/ReaderWriter/ELF/X86LinkingContext.h

+//===- lld/ReaderWriter/ELF/X86LinkingContext.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_X86_LINKING_CONTEXT_H
+#define LLD_READER_WRITER_ELF_X86_LINKING_CONTEXT_H
+
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/ELF.h"
+
+namespace lld {
+namespace elf {
+class X86LinkingContext final : public ELFLinkingContext {
+public:
+  X86LinkingContext(llvm::Triple);
+
+  /// \brief X86 has only two relative relocation
+  /// a) for supporting IFUNC relocs - R_386_IRELATIVE
+  /// b) for supporting relative relocs - R_386_RELATIVE
+  bool isRelativeReloc(const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86);
+    switch (r.kindValue()) {
+    case llvm::ELF::R_386_IRELATIVE:
+    case llvm::ELF::R_386_RELATIVE:
+      return true;
+    default:
+      return false;
+    }
+  }
+};
+} // end namespace elf
+} // end namespace lld
+#endif

include/lld/ReaderWriter/ELF/X86_64LinkingContext.h

+//===- lld/ReaderWriter/ELF/X86_64LinkingContext.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_X86_64_LINKING_CONTEXT_H
+#define LLD_READER_WRITER_ELF_X86_64_LINKING_CONTEXT_H
+
+#include "lld/ReaderWriter/ELFLinkingContext.h"
+#include "llvm/Object/ELF.h"
+#include "llvm/Support/ELF.h"
+
+namespace lld {
+namespace elf {
+
+/// \brief x86-64 internal references.
+enum {
+  /// \brief The 32 bit index of the relocation in the got this reference refers
+  /// to.
+  LLD_R_X86_64_GOTRELINDEX = 1024,
+};
+
+class X86_64LinkingContext final : public ELFLinkingContext {
+public:
+  X86_64LinkingContext(llvm::Triple);
+
+  void addPasses(PassManager &) override;
+
+  uint64_t getBaseAddress() const override {
+    if (_baseAddress == 0)
+      return 0x400000;
+    return _baseAddress;
+  }
+
+  bool isDynamicRelocation(const DefinedAtom &,
+                           const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86_64);
+    switch (r.kindValue()) {
+    case llvm::ELF::R_X86_64_RELATIVE:
+    case llvm::ELF::R_X86_64_GLOB_DAT:
+    case llvm::ELF::R_X86_64_COPY:
+    case llvm::ELF::R_X86_64_DTPMOD64:
+    case llvm::ELF::R_X86_64_DTPOFF64:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  bool isCopyRelocation(const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86_64);
+    if (r.kindValue() == llvm::ELF::R_X86_64_COPY)
+      return true;
+    return false;
+  }
+
+  virtual bool isPLTRelocation(const DefinedAtom &,
+                               const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86_64);
+    switch (r.kindValue()) {
+    case llvm::ELF::R_X86_64_JUMP_SLOT:
+    case llvm::ELF::R_X86_64_IRELATIVE:
+      return true;
+    default:
+      return false;
+    }
+  }
+
+  /// \brief X86_64 has two relative relocations
+  /// a) for supporting IFUNC - R_X86_64_IRELATIVE
+  /// b) for supporting relative relocs - R_X86_64_RELATIVE
+  bool isRelativeReloc(const Reference &r) const override {
+    if (r.kindNamespace() != Reference::KindNamespace::ELF)
+      return false;
+    assert(r.kindArch() == Reference::KindArch::x86_64);
+    switch (r.kindValue()) {
+    case llvm::ELF::R_X86_64_IRELATIVE:
+    case llvm::ELF::R_X86_64_RELATIVE:
+      return true;
+    default:
+      return false;
+    }
+  }
+};
+} // end namespace elf
+} // end namespace lld
+
+#endif

lib/Driver/CMakeLists.txt

     lldMachO
     lldPECOFF
     lldELF
+    lldHexagonELFTarget
+    lldMipsELFTarget
+    lldPPCELFTarget
+    lldX86ELFTarget
+    lldX86_64ELFTarget
+    lldAArch64ELFTarget
+    lldARMELFTarget
     lldCore
     lldNative
     lldReaderWriter

lib/Driver/GnuLdDriver.cpp

 //===----------------------------------------------------------------------===//
 
 #include "lld/Driver/Driver.h"
+#include "lld/ReaderWriter/ELF/Targets.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
 #include "lld/ReaderWriter/LinkerScript.h"
 #include "llvm/ADT/ArrayRef.h"

   ctx.addSearchPath("=/usr/lib");
 }
 
+std::unique_ptr<ELFLinkingContext>
+createELFLinkingContext(llvm::Triple triple) {
+  switch (triple.getArch()) {
+  case llvm::Triple::x86:
+    return std::unique_ptr<ELFLinkingContext>(
+        new lld::elf::X86LinkingContext(triple));
+  case llvm::Triple::x86_64:
+    return std::unique_ptr<ELFLinkingContext>(
+        new lld::elf::X86_64LinkingContext(triple));
+  case llvm::Triple::hexagon:
+    return std::unique_ptr<ELFLinkingContext>(
+        new lld::elf::HexagonLinkingContext(triple));
+  case llvm::Triple::mipsel:
+    return std::unique_ptr<ELFLinkingContext>(
+        new lld::elf::MipsLinkingContext(triple));
+  case llvm::Triple::ppc:
+    return std::unique_ptr<ELFLinkingContext>(
+        new lld::elf::PPCLinkingContext(triple));
+  case llvm::Triple::aarch64:
+    return std::unique_ptr<ELFLinkingContext>(
+        new lld::elf::AArch64LinkingContext(triple));
+  case llvm::Triple::arm:
+    return std::unique_ptr<ELFLinkingContext>(
+        new lld::elf::ARMLinkingContext(triple));
+  default:
+    return nullptr;
+  }
+}
+
 bool GnuLdDriver::parse(int argc, const char *argv[],
                         std::unique_ptr<ELFLinkingContext> &context,
                         raw_ostream &diagnostics) {

   if (!applyEmulation(triple, *parsedArgs, diagnostics))
     return false;
 
-  std::unique_ptr<ELFLinkingContext> ctx(ELFLinkingContext::create(triple));
+  std::unique_ptr<ELFLinkingContext> ctx(createELFLinkingContext(triple));
 
   if (!ctx) {
     diagnostics << "unknown target triple\n";

lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h

 #ifndef AARCH64_DYNAMIC_LIBRARY_WRITER_H
 #define AARCH64_DYNAMIC_LIBRARY_WRITER_H
 
-#include "AArch64LinkingContext.h"
+#include "lld/ReaderWriter/ELF/AArch64LinkingContext.h"
+#include "AArch64TargetHandler.h"
 #include "DynamicLibraryWriter.h"
 
 namespace lld {

lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h

 #ifndef AARCH64_EXECUTABLE_WRITER_H
 #define AARCH64_EXECUTABLE_WRITER_H
 
-#include "AArch64LinkingContext.h"
+#include "lld/ReaderWriter/ELF/AArch64LinkingContext.h"
 #include "ExecutableWriter.h"
 
 namespace lld {

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.h

-//===- lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.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_AARCH64_AARCH64_LINKING_CONTEXT_H
-#define LLD_READER_WRITER_ELF_AARCH64_AARCH64_LINKING_CONTEXT_H
-
-#include "AArch64TargetHandler.h"
-#include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "llvm/Object/ELF.h"
-#include "llvm/Support/ELF.h"
-
-namespace lld {
-namespace elf {
-
-enum {
-  /// \brief The offset to add operation for a R_AARCH64_ADR_GOT_PAGE
-  ADD_AARCH64_GOTRELINDEX = 0xE000,
-};
-
-class AArch64LinkingContext final : public ELFLinkingContext {
-public:
-  AArch64LinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new AArch64TargetHandler(*this))) {}
-
-  void addPasses(PassManager &) override;
-
-  uint64_t getBaseAddress() const override {
-    if (_baseAddress == 0)
-      return 0x400000;
-    return _baseAddress;
-  }
-
-  bool isDynamicRelocation(const DefinedAtom &,
-                           const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::AArch64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_AARCH64_COPY:
-    case llvm::ELF::R_AARCH64_GLOB_DAT:
-    case llvm::ELF::R_AARCH64_RELATIVE:
-    case llvm::ELF::R_AARCH64_TLS_DTPREL64:
-    case llvm::ELF::R_AARCH64_TLS_DTPMOD64:
-    case llvm::ELF::R_AARCH64_TLS_TPREL64:
-    case llvm::ELF::R_AARCH64_TLSDESC:
-    case llvm::ELF::R_AARCH64_IRELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  bool isCopyRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::AArch64);
-    if (r.kindValue() == llvm::ELF::R_AARCH64_COPY)
-      return true;
-    return false;
-  }
-
-  bool isPLTRelocation(const DefinedAtom &,
-                               const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::AArch64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_AARCH64_JUMP_SLOT:
-    case llvm::ELF::R_AARCH64_IRELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  bool isRelativeReloc(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::AArch64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_AARCH64_IRELATIVE:
-    case llvm::ELF::R_AARCH64_RELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-};
-} // end namespace elf
-} // end namespace lld
-
-#endif

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "AArch64LinkingContext.h"
+#include "lld/ReaderWriter/ELF/AArch64LinkingContext.h"
 #include "AArch64RelocationPass.h"
+#include "AArch64TargetHandler.h"
 
 using namespace lld;
 
+elf::AArch64LinkingContext::AArch64LinkingContext(llvm::Triple triple)
+  : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
+                      new AArch64TargetHandler(*this))) {
+}
+
 void elf::AArch64LinkingContext::addPasses(PassManager &pm) {
   auto pass = createAArch64RelocationPass(*this);
   if (pass)

lib/ReaderWriter/ELF/AArch64/AArch64RelocationHandler.cpp

 //===----------------------------------------------------------------------===//
 
 #include "AArch64TargetHandler.h"
-#include "AArch64LinkingContext.h"
+#include "lld/ReaderWriter/ELF/AArch64LinkingContext.h"
 #include "llvm/Support/Debug.h"
 
 using namespace lld;

lib/ReaderWriter/ELF/AArch64/AArch64RelocationPass.cpp

 //===----------------------------------------------------------------------===//
 
 #include "AArch64RelocationPass.h"
-#include "AArch64LinkingContext.h"
 #include "Atoms.h"
+#include "lld/ReaderWriter/ELF/AArch64LinkingContext.h"
 #include "lld/Core/Simple.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Debug.h"

lib/ReaderWriter/ELF/AArch64/AArch64Target.h

-//===- lib/ReaderWriter/ELF/AArch64/AArch64Target.h -----------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "AArch64LinkingContext.h"

lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp

 #include "Atoms.h"
 #include "AArch64DynamicLibraryWriter.h"
 #include "AArch64ExecutableWriter.h"
-#include "AArch64LinkingContext.h"
 #include "AArch64TargetHandler.h"
+#include "lld/ReaderWriter/ELF/AArch64LinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/ELF/AArch64/CMakeLists.txt

   AArch64RelocationPass.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

 #define LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H
 
 #include "ExecutableWriter.h"
-#include "ARMLinkingContext.h"
+#include "ARMTargetHandler.h"
+#include "lld/ReaderWriter/ELF/ARMLinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.h

-//===--------- lib/ReaderWriter/ELF/ARM/ARMLinkingContext.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_ARM_ARM_LINKING_CONTEXT_H
-#define LLD_READER_WRITER_ELF_ARM_ARM_LINKING_CONTEXT_H
-
-#include "ARMTargetHandler.h"
-
-#include "lld/ReaderWriter/ELFLinkingContext.h"
-
-#include "llvm/Object/ELF.h"
-#include "llvm/Support/ELF.h"
-
-namespace lld {
-namespace elf {
-
-class ARMLinkingContext final : public ELFLinkingContext {
-public:
-  ARMLinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new ARMTargetHandler(*this))) {}
-
-  void addPasses(PassManager &) override;
-
-  uint64_t getBaseAddress() const override {
-    if (_baseAddress == 0)
-      return 0x400000;
-    return _baseAddress;
-  }
-};
-} // end namespace elf
-} // end namespace lld
-
-#endif

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "ARMLinkingContext.h"
 #include "ARMRelocationPass.h"
+#include "ARMTargetHandler.h"
+#include "lld/ReaderWriter/ELF/ARMLinkingContext.h"
 
 using namespace lld;
 using namespace lld::elf;
 
+elf::ARMLinkingContext::ARMLinkingContext(llvm::Triple triple)
+  : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
+                      new ARMTargetHandler(*this))) {
+}
+
 void elf::ARMLinkingContext::addPasses(PassManager &pm) {
   auto pass = createARMRelocationPass(*this);
   if (pass)

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

 //===----------------------------------------------------------------------===//
 
 #include "ARMTargetHandler.h"
-#include "ARMLinkingContext.h"
-
+#include "lld/ReaderWriter/ELF/ARMLinkingContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MathExtras.h"
 

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

 //===----------------------------------------------------------------------===//
 
 #include "ARMRelocationPass.h"
-
+#include "Atoms.h"
 #include "lld/Core/Simple.h"
-
+#include "lld/ReaderWriter/ELF/ARMLinkingContext.h"
 #include "llvm/ADT/DenseMap.h"
-
-#include "Atoms.h"
-#include "ARMLinkingContext.h"
 #include "llvm/Support/Debug.h"
 
 using namespace lld;

lib/ReaderWriter/ELF/ARM/ARMTarget.h

-//===--------- lib/ReaderWriter/ELF/ARM/ARMTarget.h -----------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ARMLinkingContext.h"

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp

 #include "Atoms.h"
 #include "ARMExecutableWriter.h"
 #include "ARMTargetHandler.h"
-#include "ARMLinkingContext.h"
+#include "lld/ReaderWriter/ELF/ARMLinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/ELF/ARM/CMakeLists.txt

   ARMRelocationPass.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
+    LLVMSupport
   )

lib/ReaderWriter/ELF/CMakeLists.txt

   Reader.cpp
   Writer.cpp
   LINK_LIBS
-    lldHexagonELFTarget
-    lldMipsELFTarget
-    lldPPCELFTarget
+    lldCore
     lldPasses
-    lldReaderWriter
-    lldX86ELFTarget
-    lldX86_64ELFTarget
-    lldAArch64ELFTarget
-    lldARMELFTarget
+    lldYAML
+    LLVMSupport
   )
 
 include_directories(.)

lib/ReaderWriter/ELF/ELFLinkingContext.cpp

 #include "ArrayOrderPass.h"
 #include "ELFFile.h"
 #include "TargetHandler.h"
-#include "Targets.h"
 #include "lld/Core/Instrumentation.h"
+#include "lld/Core/SharedLibraryFile.h"
 #include "lld/Passes/LayoutPass.h"
 #include "lld/Passes/RoundTripYAMLPass.h"
 #include "llvm/ADT/Triple.h"

 
 ELFLinkingContext::ELFLinkingContext(
     llvm::Triple triple, std::unique_ptr<TargetHandlerBase> targetHandler)
-    : _outputELFType(elf::ET_EXEC), _triple(triple),
+    : _outputELFType(llvm::ELF::ET_EXEC), _triple(triple),
       _targetHandler(std::move(targetHandler)), _baseAddress(0),
       _isStaticExecutable(false), _noInhibitExec(false), _exportDynamic(false),
       _mergeCommonStrings(false), _runLayoutPass(true),

 }
 
 StringRef ELFLinkingContext::entrySymbolName() const {
-  if (_outputELFType == elf::ET_EXEC && _entrySymbolName.empty())
+  if (_outputELFType == llvm::ELF::ET_EXEC && _entrySymbolName.empty())
     return "_start";
   return _entrySymbolName;
 }

 
 Writer &ELFLinkingContext::writer() const { return *_writer; }
 
-std::unique_ptr<ELFLinkingContext>
-ELFLinkingContext::create(llvm::Triple triple) {
-  switch (triple.getArch()) {
-  case llvm::Triple::x86:
-    return std::unique_ptr<ELFLinkingContext>(
-        new lld::elf::X86LinkingContext(triple));
-  case llvm::Triple::x86_64:
-    return std::unique_ptr<ELFLinkingContext>(
-        new lld::elf::X86_64LinkingContext(triple));
-  case llvm::Triple::hexagon:
-    return std::unique_ptr<ELFLinkingContext>(
-        new lld::elf::HexagonLinkingContext(triple));
-  case llvm::Triple::mipsel:
-    return std::unique_ptr<ELFLinkingContext>(
-        new lld::elf::MipsLinkingContext(triple));
-  case llvm::Triple::ppc:
-    return std::unique_ptr<ELFLinkingContext>(
-        new lld::elf::PPCLinkingContext(triple));
-  case llvm::Triple::aarch64:
-    return std::unique_ptr<ELFLinkingContext>(
-        new lld::elf::AArch64LinkingContext(triple));
-  case llvm::Triple::arm:
-    return std::unique_ptr<ELFLinkingContext>(
-        new lld::elf::ARMLinkingContext(triple));
-  default:
-    return nullptr;
-  }
-}
-
 static void buildSearchPath(SmallString<128> &path, StringRef dir,
                             StringRef sysRoot) {
   if (!dir.startswith("=/"))

lib/ReaderWriter/ELF/Hexagon/CMakeLists.txt

   HexagonTargetHandler.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h

 
 #include "DynamicLibraryWriter.h"
 #include "HexagonExecutableAtoms.h"
-#include "HexagonLinkingContext.h"
+#include "lld/ReaderWriter/ELF/HexagonLinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/Hexagon/HexagonELFFile.h

 #define LLD_READER_WRITER_ELF_HEXAGON_ELF_FILE_H
 
 #include "ELFReader.h"
-#include "HexagonLinkingContext.h"
+#include "lld/ReaderWriter/ELF/HexagonLinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/Hexagon/HexagonELFWriters.h

 #ifndef HEXAGON_ELF_WRITERS_H
 #define HEXAGON_ELF_WRITERS_H
 
-#include "HexagonLinkingContext.h"
 #include "OutputELFWriter.h"
+#include "lld/ReaderWriter/ELF/HexagonLinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h

 #include "ExecutableWriter.h"
 #include "HexagonELFWriters.h"
 #include "HexagonExecutableAtoms.h"
-#include "HexagonLinkingContext.h"
+#include "lld/ReaderWriter/ELF/HexagonLinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.h

-//===- lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.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_HEXAGON_HEXAGON_LINKING_CONTEXT_H
-#define LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H
-
-#include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "llvm/Object/ELF.h"
-#include "llvm/Support/ELF.h"
-
-namespace lld {
-namespace elf {
-
-typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
-
-class HexagonLinkingContext final : public ELFLinkingContext {
-public:
-  HexagonLinkingContext(llvm::Triple triple);
-
-  void addPasses(PassManager &) override;
-
-  bool isDynamicRelocation(const DefinedAtom &,
-                           const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    switch (r.kindValue()) {
-    case llvm::ELF::R_HEX_RELATIVE:
-    case llvm::ELF::R_HEX_GLOB_DAT:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  bool isPLTRelocation(const DefinedAtom &, const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    switch (r.kindValue()) {
-    case llvm::ELF::R_HEX_JMP_SLOT:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  /// \brief Hexagon has only one relative relocation
-  /// a) for supporting relative relocs - R_HEX_RELATIVE
-  bool isRelativeReloc(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    switch (r.kindValue()) {
-    case llvm::ELF::R_HEX_RELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-};
-
-} // elf
-} // lld
-
-#endif // LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_LINKING_CONTEXT_H

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "HexagonLinkingContext.h"
 #include "HexagonTargetHandler.h"
+#include "lld/ReaderWriter/ELF/HexagonLinkingContext.h"
 
 using namespace lld::elf;
 

lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp

 //===----------------------------------------------------------------------===//
 
 #include "HexagonTargetHandler.h"
-#include "HexagonLinkingContext.h"
 #include "HexagonRelocationFunctions.h"
 #include "HexagonRelocationHandler.h"
+#include "lld/ReaderWriter/ELF/HexagonLinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/ELF/Hexagon/HexagonTarget.h

-//===- lib/ReaderWriter/ELF/Hexagon/HexagonTarget.h -----------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "HexagonLinkingContext.h"

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp

 
 #include "HexagonExecutableWriter.h"
 #include "HexagonDynamicLibraryWriter.h"
-#include "HexagonLinkingContext.h"
 #include "HexagonTargetHandler.h"
+#include "lld/ReaderWriter/ELF/HexagonLinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/ELF/Makefile

 
 LLD_LEVEL := ../../..
 LIBRARYNAME := lldELF
-USEDLIBS = lldHexagonELFTarget.a lldPPCELFTarget.a lldMipsELFTarget.a \
-           lldX86ELFTarget.a lldX86_64ELFTarget.a lldAArch64ELFTarget.a \
-           lldARMELFTarget.a \
-           lldReaderWriter.a lldPasses.a
+USEDLIBS = lldPasses.a
 
 CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLD_LEVEL)/lib/ReaderWriter/ELF
 

lib/ReaderWriter/ELF/Mips/CMakeLists.txt

   MipsTargetHandler.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h

 #include "DynamicLibraryWriter.h"
 #include "MipsDynamicTable.h"
 #include "MipsELFWriters.h"
-#include "MipsLinkingContext.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/Mips/MipsELFFile.h

 #define LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_FILE_H
 
 #include "ELFReader.h"
-#include "MipsLinkingContext.h"
 #include "llvm/Support/Endian.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 
 namespace llvm {
 namespace object {

lib/ReaderWriter/ELF/Mips/MipsELFFlagsMerger.h

-//===- lib/ReaderWriter/ELF/MipsELFFlagsMerger.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_FLAGS_MERGER_H
-#define LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_FLAGS_MERGER_H
-
-#include <mutex>
-#include <system_error>
-
-namespace lld {
-namespace elf {
-
-class MipsELFFlagsMerger {
-public:
-  MipsELFFlagsMerger();
-
-  uint32_t getMergedELFFlags() const;
-
-  /// \brief Merge saved ELF header flags and the new set of flags.
-  std::error_code merge(uint8_t newClass, uint32_t newFlags);
-
-private:
-  std::mutex _mutex;
-  uint32_t _flags;
-};
-
-} // namespace elf
-} // namespace lld
-
-#endif

lib/ReaderWriter/ELF/Mips/MipsELFFlagsMerger.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "MipsELFFlagsMerger.h"
 #include "lld/Core/Error.h"
+#include "lld/ReaderWriter/ELF/MipsELFFlagsMerger.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/raw_ostream.h"

lib/ReaderWriter/ELF/Mips/MipsELFReader.h

 
 #include "ELFReader.h"
 #include "MipsELFFile.h"
-#include "MipsELFFlagsMerger.h"
-#include "MipsLinkingContext.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
+#include "lld/ReaderWriter/ELF/MipsELFFlagsMerger.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/Mips/MipsELFWriters.h

 #ifndef LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_WRITERS_H
 #define LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_WRITERS_H
 
-#include "MipsLinkingContext.h"
 #include "OutputELFWriter.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h

 #include "ExecutableWriter.h"
 #include "MipsDynamicTable.h"
 #include "MipsELFWriters.h"
-#include "MipsLinkingContext.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.h

-//===- lib/ReaderWriter/ELF/Mips/MipsLinkingContext.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_LINKING_CONTEXT_H
-#define LLD_READER_WRITER_ELF_MIPS_MIPS_LINKING_CONTEXT_H
-
-#include "MipsELFFlagsMerger.h"
-#include "lld/ReaderWriter/ELFLinkingContext.h"
-
-namespace lld {
-namespace elf {
-
-/// \brief Mips internal references.
-enum {
-  /// \brief Do nothing but mark GOT entry as a global one.
-  LLD_R_MIPS_GLOBAL_GOT = 1024,
-  /// \brief Apply high 16 bits of symbol + addend.
-  LLD_R_MIPS_32_HI16 = 1025,
-  /// \brief The same as R_MIPS_26 but for global symbols.
-  LLD_R_MIPS_GLOBAL_26 = 1026,
-  /// \brief Setup hi 16 bits using the symbol this reference refers to.
-  LLD_R_MIPS_HI16 = 1027,
-  /// \brief Setup low 16 bits using the symbol this reference refers to.
-  LLD_R_MIPS_LO16 = 1028,
-  /// \brief Represents a reference between PLT and dynamic symbol.
-  LLD_R_MIPS_STO_PLT = 1029,
-  /// \brief The same as R_MICROMIPS_26_S1 but for global symbols.
-  LLD_R_MICROMIPS_GLOBAL_26_S1 = 1030,
-};
-
-typedef llvm::object::ELFType<llvm::support::little, 2, false> Mips32ElELFType;
-
-template <class ELFType> class MipsTargetLayout;
-
-class MipsLinkingContext final : public ELFLinkingContext {
-public:
-  MipsLinkingContext(llvm::Triple triple);
-
-  uint32_t getMergedELFFlags() const;
-  MipsELFFlagsMerger &getELFFlagsMerger();
-
-  // ELFLinkingContext
-  uint64_t getBaseAddress() const override;
-  StringRef entrySymbolName() const override;
-  StringRef getDefaultInterpreter() const override;
-  void addPasses(PassManager &pm) override;
-  bool isRelaOutputFormat() const override { return false; }
-  bool isDynamicRelocation(const DefinedAtom &,
-                           const Reference &r) const override;
-  bool isCopyRelocation(const Reference &r) const override;
-  bool isPLTRelocation(const DefinedAtom &, const Reference &r) const override;
-
-private:
-  MipsELFFlagsMerger _flagsMerger;
-};
-
-} // elf
-} // lld
-
-#endif

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

 
 #include "Atoms.h"
 #include "MipsCtorsOrderPass.h"
-#include "MipsLinkingContext.h"
 #include "MipsRelocationPass.h"
 #include "MipsTargetHandler.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 
 using namespace lld;
 using namespace lld::elf;

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.h

 #ifndef LLD_READER_WRITER_ELF_MIPS_MIPS_RELOCATION_HANDLER_H
 #define LLD_READER_WRITER_ELF_MIPS_MIPS_RELOCATION_HANDLER_H
 
-#include "MipsLinkingContext.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/Mips/MipsRelocationHandler.cpp

 //===----------------------------------------------------------------------===//
 
 #include "MipsTargetHandler.h"
-#include "MipsLinkingContext.h"
 #include "MipsRelocationHandler.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 #include "lld/ReaderWriter/RelocationHelperFunctions.h"
 
 using namespace lld;

lib/ReaderWriter/ELF/Mips/MipsRelocationPass.cpp

 //===----------------------------------------------------------------------===//
 
 #include "MipsELFFile.h"
-#include "MipsLinkingContext.h"
 #include "MipsRelocationPass.h"
 #include "MipsTargetHandler.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 #include "llvm/ADT/DenseSet.h"
 
 using namespace lld;

lib/ReaderWriter/ELF/Mips/MipsTarget.h

-//===- lib/ReaderWriter/ELF/Mips/MipsTarget.h -----------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "MipsLinkingContext.h"

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

 
 #include "DefaultTargetHandler.h"
 #include "MipsELFReader.h"
-#include "MipsLinkingContext.h"
 #include "MipsRelocationHandler.h"
 #include "MipsSectionChunks.h"
 #include "TargetLayout.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 #include "llvm/ADT/DenseSet.h"
 
 namespace lld {

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.cpp

 #include "ELFFile.h"
 #include "MipsDynamicLibraryWriter.h"
 #include "MipsExecutableWriter.h"
-#include "MipsLinkingContext.h"
 #include "MipsTargetHandler.h"
+#include "lld/ReaderWriter/ELF/MipsLinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/ELF/PPC/CMakeLists.txt

   PPCTargetHandler.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/ELF/PPC/PPCLinkingContext.h

-//===- lib/ReaderWriter/ELF/PPC/PPCLinkingContext.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_PPC_PPC_LINKING_CONTEXT_H
-#define LLD_READER_WRITER_ELF_PPC_PPC_LINKING_CONTEXT_H
-
-#include "PPCTargetHandler.h"
-#include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "llvm/Object/ELF.h"
-#include "llvm/Support/ELF.h"
-
-namespace lld {
-namespace elf {
-
-class PPCLinkingContext final : public ELFLinkingContext {
-public:
-  PPCLinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new PPCTargetHandler(*this))) {}
-
-  /// \brief PPC has no relative relocations defined
-  bool isRelativeReloc(const Reference &) const override { return false; }
-};
-
-} // elf
-} // lld
-
-#endif // LLD_READER_WRITER_ELF_PPC_PPC_LINKING_CONTEXT_H

lib/ReaderWriter/ELF/PPC/PPCLinkingContext.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "PPCLinkingContext.h"
+#include "PPCTargetHandler.h"
 #include "lld/Core/LLVM.h"
+#include "lld/ReaderWriter/ELF/PPCLinkingContext.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorOr.h"
 
 using namespace lld;
 
+elf::PPCLinkingContext::PPCLinkingContext(llvm::Triple triple)
+  : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
+                      new PPCTargetHandler(*this))) {
+}
+

lib/ReaderWriter/ELF/PPC/PPCTarget.h

-//===- lib/ReaderWriter/ELF/PPC/PPCTarget.h -------------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "PPCLinkingContext.h"

lib/ReaderWriter/ELF/PPC/PPCTargetHandler.cpp

 //===----------------------------------------------------------------------===//
 
 #include "PPCTargetHandler.h"
-#include "PPCLinkingContext.h"
+#include "lld/ReaderWriter/ELF/PPCLinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/ELF/Targets.h

-//===- lib/ReaderWriter/ELF/Targets.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_TARGETS_H
-#define LLD_READER_WRITER_ELF_TARGETS_H
-
-#include "AArch64/AArch64Target.h"
-#include "ARM/ARMTarget.h"
-#include "Hexagon/HexagonTarget.h"
-#include "Mips/MipsTarget.h"
-#include "PPC/PPCTarget.h"
-#include "X86/X86Target.h"
-#include "X86_64/X86_64Target.h"
-
-#endif

lib/ReaderWriter/ELF/X86/CMakeLists.txt

   X86RelocationHandler.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h

 #define X86_X86_DYNAMIC_LIBRARY_WRITER_H
 
 #include "DynamicLibraryWriter.h"
-#include "X86LinkingContext.h"
+#include "lld/ReaderWriter/ELF/X86LinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h

 #define X86_X86_EXECUTABLE_WRITER_H
 
 #include "ExecutableWriter.h"
-#include "X86LinkingContext.h"
+#include "lld/ReaderWriter/ELF/X86LinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/X86/X86LinkingContext.h

-//===- lib/ReaderWriter/ELF/X86/X86LinkingContext.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_X86_TARGETINFO_H
-#define LLD_READER_WRITER_ELF_X86_TARGETINFO_H
-
-#include "X86TargetHandler.h"
-#include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "llvm/Object/ELF.h"
-#include "llvm/Support/ELF.h"
-
-namespace lld {
-namespace elf {
-class X86LinkingContext final : public ELFLinkingContext {
-public:
-  X86LinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new X86TargetHandler(*this))) {}
-
-  /// \brief X86 has only two relative relocation
-  /// a) for supporting IFUNC relocs - R_386_IRELATIVE
-  /// b) for supporting relative relocs - R_386_RELATIVE
-  bool isRelativeReloc(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_386_IRELATIVE:
-    case llvm::ELF::R_386_RELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-};
-} // end namespace elf
-} // end namespace lld
-#endif

lib/ReaderWriter/ELF/X86/X86LinkingContext.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "X86LinkingContext.h"
+#include "X86TargetHandler.h"
 #include "lld/Core/LLVM.h"
+#include "lld/ReaderWriter/ELF/X86LinkingContext.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorOr.h"
 
 using namespace lld;
 
+elf::X86LinkingContext::X86LinkingContext(llvm::Triple triple)
+  : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
+                      new X86TargetHandler(*this))) {
+  }

lib/ReaderWriter/ELF/X86/X86RelocationHandler.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "X86LinkingContext.h"
 #include "X86TargetHandler.h"
+#include "lld/ReaderWriter/ELF/X86LinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/ELF/X86/X86Target.h

-//===- lib/ReaderWriter/ELF/X86/X86Target.h -------------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "X86LinkingContext.h"

lib/ReaderWriter/ELF/X86/X86TargetHandler.cpp

 #include "X86TargetHandler.h"
 #include "X86DynamicLibraryWriter.h"
 #include "X86ExecutableWriter.h"
-#include "X86LinkingContext.h"
 #include "X86RelocationHandler.h"
+#include "lld/ReaderWriter/ELF/X86LinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/ELF/X86_64/CMakeLists.txt

   X86_64RelocationPass.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h

 #define X86_64_DYNAMIC_LIBRARY_WRITER_H
 
 #include "DynamicLibraryWriter.h"
-#include "X86_64LinkingContext.h"
+#include "X86_64TargetHandler.h"
+#include "lld/ReaderWriter/ELF/X86_64LinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h

 #define X86_64_EXECUTABLE_WRITER_H
 
 #include "ExecutableWriter.h"
-#include "X86_64LinkingContext.h"
+#include "X86_64TargetHandler.h"
+#include "lld/ReaderWriter/ELF/X86_64LinkingContext.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.h

-//===- lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.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_X86_64_X86_64_LINKING_CONTEXT_H
-#define LLD_READER_WRITER_ELF_X86_64_X86_64_LINKING_CONTEXT_H
-
-#include "X86_64TargetHandler.h"
-#include "lld/ReaderWriter/ELFLinkingContext.h"
-#include "llvm/Object/ELF.h"
-#include "llvm/Support/ELF.h"
-
-namespace lld {
-namespace elf {
-
-/// \brief x86-64 internal references.
-enum {
-  /// \brief The 32 bit index of the relocation in the got this reference refers
-  /// to.
-  LLD_R_X86_64_GOTRELINDEX = 1024,
-};
-
-class X86_64LinkingContext final : public ELFLinkingContext {
-public:
-  X86_64LinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new X86_64TargetHandler(*this))) {}
-
-  void addPasses(PassManager &) override;
-
-  uint64_t getBaseAddress() const override {
-    if (_baseAddress == 0)
-      return 0x400000;
-    return _baseAddress;
-  }
-
-  bool isDynamicRelocation(const DefinedAtom &,
-                           const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86_64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_X86_64_RELATIVE:
-    case llvm::ELF::R_X86_64_GLOB_DAT:
-    case llvm::ELF::R_X86_64_COPY:
-    case llvm::ELF::R_X86_64_DTPMOD64:
-    case llvm::ELF::R_X86_64_DTPOFF64:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  bool isCopyRelocation(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86_64);
-    if (r.kindValue() == llvm::ELF::R_X86_64_COPY)
-      return true;
-    return false;
-  }
-
-  virtual bool isPLTRelocation(const DefinedAtom &,
-                               const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86_64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_X86_64_JUMP_SLOT:
-    case llvm::ELF::R_X86_64_IRELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-
-  /// \brief X86_64 has two relative relocations
-  /// a) for supporting IFUNC - R_X86_64_IRELATIVE
-  /// b) for supporting relative relocs - R_X86_64_RELATIVE
-  bool isRelativeReloc(const Reference &r) const override {
-    if (r.kindNamespace() != Reference::KindNamespace::ELF)
-      return false;
-    assert(r.kindArch() == Reference::KindArch::x86_64);
-    switch (r.kindValue()) {
-    case llvm::ELF::R_X86_64_IRELATIVE:
-    case llvm::ELF::R_X86_64_RELATIVE:
-      return true;
-    default:
-      return false;
-    }
-  }
-};
-} // end namespace elf
-} // end namespace lld
-
-#endif

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "X86_64LinkingContext.h"
 #include "X86_64RelocationPass.h"
+#include "X86_64TargetHandler.h"
+#include "lld/ReaderWriter/ELF/X86_64LinkingContext.h"
 
 using namespace lld;
 
+elf::X86_64LinkingContext::X86_64LinkingContext(llvm::Triple triple)
+  : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
+                      new X86_64TargetHandler(*this))) {
+}
+
 void elf::X86_64LinkingContext::addPasses(PassManager &pm) {
   auto pass = createX86_64RelocationPass(*this);
   if (pass)

lib/ReaderWriter/ELF/X86_64/X86_64RelocationHandler.cpp

 //
 //===----------------------------------------------------------------------===//
 
-#include "X86_64LinkingContext.h"
 #include "X86_64TargetHandler.h"
+#include "lld/ReaderWriter/ELF/X86_64LinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/ELF/X86_64/X86_64RelocationPass.cpp

 
 #include "X86_64RelocationPass.h"
 #include "Atoms.h"
-#include "X86_64LinkingContext.h"
 #include "lld/Core/Simple.h"
+#include "lld/ReaderWriter/ELF/X86_64LinkingContext.h"
 #include "llvm/ADT/DenseMap.h"
 
 using namespace lld;

lib/ReaderWriter/ELF/X86_64/X86_64Target.h

-//===- lib/ReaderWriter/ELF/X86_64/X86_64Target.h -------------------------===//
-//
-//                             The LLVM Linker
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "X86_64LinkingContext.h"

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp

 #include "Atoms.h"
 #include "X86_64DynamicLibraryWriter.h"
 #include "X86_64ExecutableWriter.h"
-#include "X86_64LinkingContext.h"
 #include "X86_64TargetHandler.h"
+#include "lld/ReaderWriter/ELF/X86_64LinkingContext.h"
 
 using namespace lld;
 using namespace elf;

lib/ReaderWriter/MachO/CMakeLists.txt

   StubsPass.cpp
   WriterMachO.cpp
   LINK_LIBS
-    lldReaderWriter
+    lldCore
     lldPasses
+    lldYAML
+    LLVMObject
     LLVMSupport
   )
 

lib/ReaderWriter/MachO/Makefile

 
 LLD_LEVEL := ../../..
 LIBRARYNAME := lldMachO
-USEDLIBS = lldReaderWriter.a lldCore.a
+USEDLIBS = lldCore.a
 
 include $(LLD_LEVEL)/Makefile

lib/ReaderWriter/PECOFF/CMakeLists.txt

   WriterImportLibrary.cpp
   WriterPECOFF.cpp
   LINK_LIBS
-    lldReaderWriter
+    lldCore
+    lldPasses
     LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/PECOFF/Makefile

 
 LLD_LEVEL := ../../..
 LIBRARYNAME := lldPECOFF
-USEDLIBS = lldReaderWriter.a lldCore.a
+USEDLIBS = lldCore.a
 
 include $(LLD_LEVEL)/Makefile