[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

19

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 ↗

(On Diff #18631)

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 ↗

(On Diff #18631)

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/ELFLinkingContext.h

     return true;
   }
 
-  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
-
   /// \brief Use Elf_Rela format to output relocation tables.
   virtual bool isRelaOutputFormat() const { return true; }
 

include/lld/ReaderWriter/ELFTargets.h

+//===- lld/ReaderWriter/ELFTargets.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 "ELFLinkingContext.h"
+
+namespace lld {
+namespace elf {
+
+#define LLVM_TARGET(TargetName) \
+  class TargetName##LinkingContext final : public ELFLinkingContext { \
+  public: \
+    static std::unique_ptr<ELFLinkingContext> create(llvm::Triple); \
+  };
+#include "llvm/Config/Targets.def"
+
+// X86 => X86,X86_64
+class X86_64LinkingContext final : public ELFLinkingContext {
+public:
+  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple); \
+};
+
+// PowerPC => PPC
+class PPCLinkingContext final : public ELFLinkingContext {
+public:
+  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple); \
+};
+
+} // end namespace elf
+} // end namespace lld
+
+#endif

lib/Driver/CMakeLists.txt

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

lib/Driver/GnuLdDriver.cpp

 
 #include "lld/Driver/Driver.h"
 #include "lld/ReaderWriter/ELFLinkingContext.h"
+#include "lld/ReaderWriter/ELFTargets.h"
 #include "lld/ReaderWriter/LinkerScript.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"

   ctx.addSearchPath("=/usr/lib");
 }
 
+std::unique_ptr<ELFLinkingContext>
+createELFLinkingContext(llvm::Triple triple) {
+  std::unique_ptr<ELFLinkingContext> p;
+  if      ((p = elf::AArch64LinkingContext::create(triple))) return p;
+  else if ((p = elf::ARMLinkingContext::create(triple)))     return p;
+  else if ((p = elf::HexagonLinkingContext::create(triple))) return p;
+  else if ((p = elf::MipsLinkingContext::create(triple)))    return p;
+  else if ((p = elf::PPCLinkingContext::create(triple)))     return p;
+  else if ((p = elf::X86LinkingContext::create(triple)))     return p;
+  else if ((p = elf::X86_64LinkingContext::create(triple)))  return p;
+  else 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

 #define AARCH64_DYNAMIC_LIBRARY_WRITER_H
 
 #include "AArch64LinkingContext.h"
+#include "AArch64TargetHandler.h"
 #include "DynamicLibraryWriter.h"
 
 namespace lld {

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.h

 #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"

 
 class AArch64LinkingContext final : public ELFLinkingContext {
 public:
-  AArch64LinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new AArch64TargetHandler(*this))) {}
+  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
+  AArch64LinkingContext(llvm::Triple);
 
   void addPasses(PassManager &) override;
 

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.cpp

 
 #include "AArch64LinkingContext.h"
 #include "AArch64RelocationPass.h"
+#include "AArch64TargetHandler.h"
 
 using namespace lld;
 
+std::unique_ptr<ELFLinkingContext>
+elf::AArch64LinkingContext::create(llvm::Triple triple) {
+  if (triple.getArch() == llvm::Triple::aarch64)
+    return std::unique_ptr<ELFLinkingContext>(
+             new elf::AArch64LinkingContext(triple));
+
+  return nullptr;
+}
+
+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/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/CMakeLists.txt

   AArch64RelocationPass.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

 
 #include "ExecutableWriter.h"
 #include "ARMLinkingContext.h"
+#include "ARMTargetHandler.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.h

 #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"
 

 
 class ARMLinkingContext final : public ELFLinkingContext {
 public:
-  ARMLinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new ARMTargetHandler(*this))) {}
+  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
+  ARMLinkingContext(llvm::Triple);
 
   void addPasses(PassManager &) override;
 

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.cpp

 
 #include "ARMLinkingContext.h"
 #include "ARMRelocationPass.h"
+#include "ARMTargetHandler.h"
 
 using namespace lld;
 using namespace lld::elf;
 
+std::unique_ptr<ELFLinkingContext>
+elf::ARMLinkingContext::create(llvm::Triple triple) {
+  if (triple.getArch() == llvm::Triple::arm)
+    return std::unique_ptr<ELFLinkingContext>(
+             new elf::ARMLinkingContext(triple));
+
+    return nullptr;
+}
+
+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/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/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/HexagonLinkingContext.h

 
 class HexagonLinkingContext final : public ELFLinkingContext {
 public:
+  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
   HexagonLinkingContext(llvm::Triple triple);
 
   void addPasses(PassManager &) override;

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.cpp

 
 using namespace lld::elf;
 
+std::unique_ptr<lld::ELFLinkingContext>
+HexagonLinkingContext::create(llvm::Triple triple) {
+  if (triple.getArch() == llvm::Triple::hexagon)
+    return std::unique_ptr<lld::ELFLinkingContext>(
+             new HexagonLinkingContext(triple));
+
+  return nullptr;
+}
+
 HexagonLinkingContext::HexagonLinkingContext(llvm::Triple triple)
     : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
                                     new HexagonTargetHandler(*this))) {}

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/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/MipsLinkingContext.h

 
 class MipsLinkingContext final : public ELFLinkingContext {
 public:
+  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
   MipsLinkingContext(llvm::Triple triple);
 
   uint32_t getMergedELFFlags() const;

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

 using namespace lld;
 using namespace lld::elf;
 
+std::unique_ptr<ELFLinkingContext>
+MipsLinkingContext::create(llvm::Triple triple) {
+  if (triple.getArch() == llvm::Triple::mipsel)
+    return std::unique_ptr<ELFLinkingContext>(
+             new MipsLinkingContext(triple));
+
+    return nullptr;
+}
+
 MipsLinkingContext::MipsLinkingContext(llvm::Triple triple)
     : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
                                     new MipsTargetHandler(*this))) {}

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/PPC/CMakeLists.txt

   PPCTargetHandler.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/ELF/PPC/PPCLinkingContext.h

 #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"

 
 class PPCLinkingContext final : public ELFLinkingContext {
 public:
-  PPCLinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new PPCTargetHandler(*this))) {}
+  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
+  PPCLinkingContext(llvm::Triple triple);
 
   /// \brief PPC has no relative relocations defined
   bool isRelativeReloc(const Reference &) const override { return false; }

lib/ReaderWriter/ELF/PPC/PPCLinkingContext.cpp

 //===----------------------------------------------------------------------===//
 
 #include "PPCLinkingContext.h"
+#include "PPCTargetHandler.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorOr.h"
 
 using namespace lld;
 
+std::unique_ptr<ELFLinkingContext>
+elf::PPCLinkingContext::create(llvm::Triple triple) {
+  if (triple.getArch() == llvm::Triple::ppc)
+    return std::unique_ptr<ELFLinkingContext>(
+             new elf::PPCLinkingContext(triple));
+
+  return nullptr;
+}
+
+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/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/X86LinkingContext.h

 #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 elf {
 class X86LinkingContext final : public ELFLinkingContext {
 public:
-  X86LinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new X86TargetHandler(*this))) {}
+  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
+  X86LinkingContext(llvm::Triple);
 
   /// \brief X86 has only two relative relocation
   /// a) for supporting IFUNC relocs - R_386_IRELATIVE

lib/ReaderWriter/ELF/X86/X86LinkingContext.cpp

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

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_64/CMakeLists.txt

   X86_64RelocationPass.cpp
   LINK_LIBS
     lldCore
+    lldELF
+    LLVMObject
     LLVMSupport
   )

lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h

 
 #include "DynamicLibraryWriter.h"
 #include "X86_64LinkingContext.h"
+#include "X86_64TargetHandler.h"
 
 namespace lld {
 namespace elf {

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.h

 #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"

 
 class X86_64LinkingContext final : public ELFLinkingContext {
 public:
-  X86_64LinkingContext(llvm::Triple triple)
-      : ELFLinkingContext(triple, std::unique_ptr<TargetHandlerBase>(
-                                      new X86_64TargetHandler(*this))) {}
+  static std::unique_ptr<ELFLinkingContext> create(llvm::Triple);
+  X86_64LinkingContext(llvm::Triple);
 
   void addPasses(PassManager &) override;
 

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.cpp

 //===----------------------------------------------------------------------===//
 
 #include "X86_64LinkingContext.h"
+#include "X86_64TargetHandler.h"
 #include "X86_64RelocationPass.h"
 
 using namespace lld;
 
+std::unique_ptr<ELFLinkingContext>
+elf::X86_64LinkingContext::create(llvm::Triple triple) {
+  if (triple.getArch() == llvm::Triple::x86_64)
+    return std::unique_ptr<ELFLinkingContext>(
+             new elf::X86_64LinkingContext(triple));
+
+  return nullptr;
+}
+
+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_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/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