LLD: ELF: Remove partial class definitions of <Arch>LinkingContexts.

[ruiu]

Summary

What we are doing in ELFTarget.h is dubious. In the file, we define
partial classes of <Arch>LinkingContexts to declare only a static member
function. We have different (complete) class definitions in other headers.
They would conflict if they exist in the same compilation unit (because
the ones defined in ELFTarget.h has only static member functions).
I don't think this is valid in C++.

[dblaikie]

You're right - this is an ODR violation & your solution looks like it successfully corrects that.

(broader questions about an ideal architecture here - the design here seems a bit awkward - it's trying to avoid any one place including all of the FooLinkingContext.h but instead means we have a header that declares all the functions, so it loses the generality anyway. I'm not sure what a nice generalization would look like - there's always going to be some kind of "all the targets" registration point, likely)

[ruiu]

We used to have a function containing if-else clause for each machine type to dispatch. And then it was replaced with this partial class implementation. Not sure which is better -- but I'll go with this patch for now to just convert invalid C++ code to valid code.

[Bigcheese]

Thanks, the author of the original was supposed to fix this.

[Eugene.Zelenko]

Committed in r234039.

include/lld/ReaderWriter/ELFTargets.h

 #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 : public ELFLinkingContext { \
-  public: \
-    static std::unique_ptr<ELFLinkingContext> create(llvm::Triple); \
-  };
-
-// FIXME: #include "llvm/Config/Targets.def"
-LLVM_TARGET(AArch64)
-LLVM_TARGET(ARM)
-LLVM_TARGET(Hexagon)
-LLVM_TARGET(Mips)
-LLVM_TARGET(X86)
-LLVM_TARGET(Example)
-LLVM_TARGET(X86_64)
-
-#undef LLVM_TARGET
+std::unique_ptr<ELFLinkingContext> createAArch64LinkingContext(llvm::Triple);
+std::unique_ptr<ELFLinkingContext> createARMLinkingContext(llvm::Triple);
+std::unique_ptr<ELFLinkingContext> createExampleLinkingContext(llvm::Triple);
+std::unique_ptr<ELFLinkingContext> createHexagonLinkingContext(llvm::Triple);
+std::unique_ptr<ELFLinkingContext> createMipsLinkingContext(llvm::Triple);
+std::unique_ptr<ELFLinkingContext> createX86LinkingContext(llvm::Triple);
+std::unique_ptr<ELFLinkingContext> createX86_64LinkingContext(llvm::Triple);
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/Driver/GnuLdDriver.cpp

if (triple.getOS() == llvm::Triple::NetBSD &&
     return;
   }
   ctx.addSearchPath("=/usr/lib");
 }
 
 std::unique_ptr<ELFLinkingContext>
 GnuLdDriver::createELFLinkingContext(llvm::Triple triple) {
   std::unique_ptr<ELFLinkingContext> p;
-  // FIXME: #include "llvm/Config/Targets.def"
-#define LLVM_TARGET(targetName) \
-  if ((p = elf::targetName##LinkingContext::create(triple))) return p;
-  LLVM_TARGET(AArch64)
-  LLVM_TARGET(ARM)
-  LLVM_TARGET(Hexagon)
-  LLVM_TARGET(Mips)
-  LLVM_TARGET(X86)
-  LLVM_TARGET(Example)
-  LLVM_TARGET(X86_64)
-#undef LLVM_TARGET
+  if ((p = elf::createAArch64LinkingContext(triple))) return p;
+  if ((p = elf::createARMLinkingContext(triple))) return p;
+  if ((p = elf::createExampleLinkingContext(triple))) return p;
+  if ((p = elf::createHexagonLinkingContext(triple))) return p;
+  if ((p = elf::createMipsLinkingContext(triple))) return p;
+  if ((p = elf::createX86LinkingContext(triple))) return p;
+  if ((p = elf::createX86_64LinkingContext(triple))) return p;
   return nullptr;
 }
 
 static llvm::Optional<bool>
 getBool(const llvm::opt::InputArgList &parsedArgs,
         unsigned yesFlag, unsigned noFlag) {
   if (auto *arg = parsedArgs.getLastArg(yesFlag, noFlag))
     return arg->getOption().getID() == yesFlag;

lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.cpp

 //===- lib/ReaderWriter/ELF/AArch64/AArch64LinkingContext.cpp -------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64LinkingContext.h"
 #include "AArch64RelocationPass.h"
 #include "AArch64TargetHandler.h"
+#include "lld/ReaderWriter/ELFTargets.h"
 
 using namespace lld;
 using namespace lld::elf;
 
 std::unique_ptr<ELFLinkingContext>
-AArch64LinkingContext::create(llvm::Triple triple) {
+elf::createAArch64LinkingContext(llvm::Triple triple) {
   if (triple.getArch() == llvm::Triple::aarch64)
     return llvm::make_unique<AArch64LinkingContext>(triple);
   return nullptr;
 }
 
 AArch64LinkingContext::AArch64LinkingContext(llvm::Triple triple)
     : ELFLinkingContext(triple, std::unique_ptr<TargetHandler>(
                                     new AArch64TargetHandler(*this))) {}

lib/ReaderWriter/ELF/ARM/ARMLinkingContext.cpp

 #include "ARMLinkingContext.h"
 #include "ARMRelocationPass.h"
 #include "ARMTargetHandler.h"
 
 namespace lld {
 namespace elf {
 
 std::unique_ptr<ELFLinkingContext>
-ARMLinkingContext::create(llvm::Triple triple) {
+createARMLinkingContext(llvm::Triple triple) {
   if (triple.getArch() == llvm::Triple::arm)
     return llvm::make_unique<ARMLinkingContext>(triple);
   return nullptr;
 }
 
 ARMLinkingContext::ARMLinkingContext(llvm::Triple triple)
     : ELFLinkingContext(triple, llvm::make_unique<ARMTargetHandler>(*this)) {}
 

lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.cpp

 //===- lib/ReaderWriter/ELF/Hexagon/HexagonLinkingContext.cpp -------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "HexagonLinkingContext.h"
 #include "HexagonTargetHandler.h"
+#include "lld/ReaderWriter/ELFTargets.h"
 
 using namespace lld;
 using namespace lld::elf;
 
 std::unique_ptr<lld::ELFLinkingContext>
-HexagonLinkingContext::create(llvm::Triple triple) {
+elf::createHexagonLinkingContext(llvm::Triple triple) {
   if (triple.getArch() == llvm::Triple::hexagon)
     return llvm::make_unique<HexagonLinkingContext>(triple);
   return nullptr;
 }
 
 HexagonLinkingContext::HexagonLinkingContext(llvm::Triple triple)
     : ELFLinkingContext(triple, std::unique_ptr<TargetHandler>(
                                     new HexagonTargetHandler(*this))) {}

lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp

 //===- lib/ReaderWriter/ELF/Mips/MipsLinkingContext.cpp -------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Atoms.h"
 #include "MipsCtorsOrderPass.h"
 #include "MipsLinkingContext.h"
 #include "MipsRelocationPass.h"
 #include "MipsTargetHandler.h"
+#include "lld/ReaderWriter/ELFTargets.h"
 
 using namespace lld;
 using namespace lld::elf;
 
 std::unique_ptr<ELFLinkingContext>
-MipsLinkingContext::create(llvm::Triple triple) {
+elf::createMipsLinkingContext(llvm::Triple triple) {
   if (triple.getArch() == llvm::Triple::mipsel ||
       triple.getArch() == llvm::Triple::mips64el)
     return llvm::make_unique<MipsLinkingContext>(triple);
   return nullptr;
 }
 
 typedef std::unique_ptr<TargetHandler> TargetHandlerPtr;
 

lib/ReaderWriter/ELF/X86/X86LinkingContext.cpp

 //===- lib/ReaderWriter/ELF/X86/X86LinkingContext.cpp ---------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86LinkingContext.h"
 #include "X86TargetHandler.h"
 #include "lld/Core/LLVM.h"
+#include "lld/ReaderWriter/ELFTargets.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorOr.h"
 
 using namespace lld;
 using namespace lld::elf;
 
 std::unique_ptr<ELFLinkingContext>
-X86LinkingContext::create(llvm::Triple triple) {
+elf::createX86LinkingContext(llvm::Triple triple) {
   if (triple.getArch() == llvm::Triple::x86)
     return llvm::make_unique<X86LinkingContext>(triple);
   return nullptr;
 }
 
 X86LinkingContext::X86LinkingContext(llvm::Triple triple)
     : ELFLinkingContext(triple, llvm::make_unique<X86TargetHandler>(*this)) {}
 

lib/ReaderWriter/ELF/X86_64/ExampleSubTarget/ExampleLinkingContext.cpp

 //===- lib/ReaderWriter/ELF/X86_64/ExampleTarget/ExampleLinkingContext.cpp ----===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ExampleLinkingContext.h"
 #include "ExampleTargetHandler.h"
+#include "lld/ReaderWriter/ELFTargets.h"
 
 using namespace lld;
 using namespace elf;
 
 std::unique_ptr<ELFLinkingContext>
-ExampleLinkingContext::create(llvm::Triple triple) {
+elf::createExampleLinkingContext(llvm::Triple triple) {
   if (triple.getVendorName() == "example")
     return llvm::make_unique<ExampleLinkingContext>(triple);
   return nullptr;
 }
 
 ExampleLinkingContext::ExampleLinkingContext(llvm::Triple triple)
     : X86_64LinkingContext(triple, std::unique_ptr<TargetHandler>(
                                        new ExampleTargetHandler(*this))) {

lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.cpp

 //===- lib/ReaderWriter/ELF/X86_64/X86_64LinkingContext.cpp ---------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "lld/ReaderWriter/ELFTargets.h"
 #include "X86_64LinkingContext.h"
 #include "X86_64RelocationPass.h"
 #include "X86_64TargetHandler.h"
 
 using namespace lld;
 using namespace lld::elf;
 
 X86_64LinkingContext::X86_64LinkingContext(
     llvm::Triple triple, std::unique_ptr<TargetHandler> handler)
     : ELFLinkingContext(triple, std::move(handler)) {}
 
 X86_64LinkingContext::X86_64LinkingContext(llvm::Triple triple)
     : X86_64LinkingContext(triple,
                            llvm::make_unique<X86_64TargetHandler>(*this)) {}
 
 void X86_64LinkingContext::addPasses(PassManager &pm) {
   auto pass = createX86_64RelocationPass(*this);
   if (pass)
     pm.add(std::move(pass));
   ELFLinkingContext::addPasses(pm);
 }
 
 std::unique_ptr<ELFLinkingContext>
-X86_64LinkingContext::create(llvm::Triple triple) {
+elf::createX86_64LinkingContext(llvm::Triple triple) {
   if (triple.getArch() == llvm::Triple::x86_64)
     return llvm::make_unique<X86_64LinkingContext>(triple);
   return nullptr;
 }
 
 static const Registry::KindStrings kindStrings[] = {
 #define ELF_RELOC(name, value) LLD_KIND_STRING_ENTRY(name),
 #include "llvm/Support/ELFRelocs/x86_64.def"