[ELF] - Make printHelp() print all targets supported.

[grimar]

Summary

We hardcode target names in printHelp.
As a result it is easy to forget to update this list
when new target is added.

For example we did not list elf32-avr and
elf64-sparc targets though support them.

Patch refactors printHelp() implementation
to fix the issue.

[ruiu]

I don't think I like this patch because it makes things more complicated than it can be. "Supported targets" are just informative for compatibility with GNU linkers, and it doesn't change often. I'm more comfortable with the current code than this one.

[grimar]

Abandoning in favor of D42992 solution.

ELF/Driver.h

 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
-void printHelp(const char *Argv0);
+void printHelp();
 std::string createResponseFile(const llvm::opt::InputArgList &Args);
 
 llvm::Optional<std::string> findFromSearchPaths(StringRef Path);
 llvm::Optional<std::string> searchLinkerScript(StringRef Path);
 llvm::Optional<std::string> searchLibrary(StringRef Path);
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Driver.cpp

void LinkerDriver::main(ArrayRef<const char *> ArgsArr, bool CanExitEarly) {
   ELFOptTable Parser;
   opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
 
   // Interpret this flag early because error() depends on them.
   errorHandler().ErrorLimit = args::getInteger(Args, OPT_error_limit, 20);
 
   // Handle -help
   if (Args.hasArg(OPT_help)) {
-    printHelp(ArgsArr[0]);
+    printHelp();
     return;
   }
 
   // Handle -v or -version.
   //
   // A note about "compatible with GNU linkers" message: this is a hack for
   // scripts generated by GNU Libtool 2.4.6 (released in February 2014 and
   // still the newest version in March 2017) or earlier to recognize LLD as

ELF/DriverUtils.cpp

 //===- DriverUtils.cpp ----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains utility functions for the driver. Because there
 // are so many small functions, we created this separate file to make
 // Driver.cpp less cluttered.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
+#include "Target.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Option/Option.h"
opt::InputArgList ELFOptTable::parse(ArrayRef<const char *> Argv) {
   if (MissingCount)
     error(Twine(Args.getArgString(MissingIndex)) + ": missing argument");
 
   for (auto *Arg : Args.filtered(OPT_UNKNOWN))
     error("unknown argument: " + Arg->getSpelling());
   return Args;
 }
 
-void elf::printHelp(const char *Argv0) {
-  ELFOptTable().PrintHelp(outs(), Argv0, "lld", false /*ShowHidden*/,
-                          true /*ShowAllAliases*/);
+void elf::printHelp() {
+  ELFOptTable().PrintHelp(outs(), Config->Argv[0].data(), "lld",
+                          false /*ShowHidden*/, true /*ShowAllAliases*/);
   outs() << "\n";
 
   // Scripts generated by Libtool versions up to at least 2.4.6 (the most
   // recent version as of March 2017) expect /: supported targets:.* elf/
   // in a message for the -help option. If it doesn't match, the scripts
   // assume that the linker doesn't support very basic features such as
   // shared libraries. Therefore, we need to print out at least "elf".
   // Here, we print out all the targets that we support.
-  outs() << Argv0 << ": supported targets: "
-         << "elf32-i386 elf32-iamcu elf32-littlearm elf32-ntradbigmips "
-         << "elf32-ntradlittlemips elf32-powerpc elf32-tradbigmips "
-         << "elf32-tradlittlemips elf32-x86-64 "
-         << "elf64-amdgpu elf64-littleaarch64 elf64-powerpc elf64-tradbigmips "
-         << "elf64-tradlittlemips elf64-x86-64\n";
+  outs() << Config->Argv[0] << ": supported targets: ";
+  for (StringRef Name : getTargetNames())
+    outs() << Name << ' ';
+  outs() << '\n';
 }
 
 // Reconstructs command line arguments so that so that you can re-run
 // the same command with the same inputs. This is for --reproduce.
 std::string elf::createResponseFile(const opt::InputArgList &Args) {
   SmallString<0> Data;
   raw_svector_ostream OS(Data);
   OS << "--chroot .\n";

ELF/Target.h

 
 std::string getErrorLocation(const uint8_t *Loc);
 
 uint64_t getPPC64TocBase();
 uint64_t getAArch64Page(uint64_t Expr);
 
 extern TargetInfo *Target;
 TargetInfo *getTarget();
+std::vector<StringRef> getTargetNames();
 
 template <class ELFT> bool isMipsPIC(const Defined *Sym);
 
 static inline void reportRangeError(uint8_t *Loc, RelType Type, const Twine &V,
                                     int64_t Min, uint64_t Max) {
   error(getErrorLocation(Loc) + "relocation " + lld::toString(Type) +
         " out of range: " + V + " is not in [" + Twine(Min) + ", " +
         Twine(Max) + "]");

ELF/Target.cpp

 
 std::string lld::toString(RelType Type) {
   StringRef S = getELFRelocationTypeName(elf::Config->EMachine, Type);
   if (S == "Unknown")
     return ("Unknown (" + Twine(Type) + ")").str();
   return S;
 }
 
-TargetInfo *elf::getTarget() {
-  switch (Config->EMachine) {
-  case EM_386:
-  case EM_IAMCU:
-    return getX86TargetInfo();
-  case EM_AARCH64:
-    return getAArch64TargetInfo();
-  case EM_AMDGPU:
-    return getAMDGPUTargetInfo();
-  case EM_ARM:
-    return getARMTargetInfo();
-  case EM_AVR:
-    return getAVRTargetInfo();
-  case EM_MIPS:
-    switch (Config->EKind) {
-    case ELF32LEKind:
-      return getMipsTargetInfo<ELF32LE>();
-    case ELF32BEKind:
-      return getMipsTargetInfo<ELF32BE>();
-    case ELF64LEKind:
-      return getMipsTargetInfo<ELF64LE>();
-    case ELF64BEKind:
-      return getMipsTargetInfo<ELF64BE>();
-    default:
-      fatal("unsupported MIPS target");
-    }
-  case EM_PPC:
-    return getPPCTargetInfo();
-  case EM_PPC64:
-    return getPPC64TargetInfo();
-  case EM_SPARCV9:
-    return getSPARCV9TargetInfo();
-  case EM_X86_64:
-    if (Config->EKind == ELF32LEKind)
-      return getX32TargetInfo();
-    return getX86_64TargetInfo();
-  }
+namespace {
+struct TargetDescription {
+  uint16_t EMachine;
+  ELFKind EKind;
+  llvm::function_ref<TargetInfo *()> Create;
+  StringRef Name;
+};
+
+std::vector<TargetDescription> getAllTargets() {
+  return {
+      {EM_386, ELFNoneKind, getX86TargetInfo, "elf32-i386"},
+      {EM_IAMCU, ELFNoneKind, getX86TargetInfo, "elf32-iamcu"},
+      {EM_AARCH64, ELFNoneKind, getAArch64TargetInfo, "elf64-littleaarch64"},
+      {EM_AMDGPU, ELFNoneKind, getAMDGPUTargetInfo, "elf64-amdgpu"},
+      {EM_ARM, ELFNoneKind, getARMTargetInfo, "elf32-littlearm"},
+      {EM_AVR, ELFNoneKind, getAVRTargetInfo, "elf32-avr"},
+      {EM_MIPS, ELF32LEKind, getMipsTargetInfo<ELF32LE>,
+       "elf32-tradlittlemips elf32-ntradlittlemips"},
+      {EM_MIPS, ELF32BEKind, getMipsTargetInfo<ELF32BE>,
+       "elf32-tradbigmips elf32-ntradbigmips"},
+      {EM_MIPS, ELF64LEKind, getMipsTargetInfo<ELF64LE>,
+       "elf64-tradlittlemips elf64-ntradlittlemips"},
+      {EM_MIPS, ELF64BEKind, getMipsTargetInfo<ELF64BE>,
+       "elf64-tradbigmips elf64-ntradbigmips"},
+      {EM_PPC, ELFNoneKind, getPPCTargetInfo, "elf32-powerpc"},
+      {EM_PPC64, ELFNoneKind, getPPC64TargetInfo, "elf64-powerpc"},
+      {EM_SPARCV9, ELFNoneKind, getSPARCV9TargetInfo, "elf64-sparc"},
+      {EM_X86_64, ELF32LEKind, getX32TargetInfo, "elf32-x86-64"},
+      {EM_X86_64, ELFNoneKind, getX86_64TargetInfo, "elf64-x86-64"},
+  };
+}; // namespace
+
+TargetInfo *elf::getTarget() {
+  for (TargetDescription &T : getAllTargets())
+    if (T.EMachine == Config->EMachine)
+      if (T.EKind == ELFNoneKind || T.EKind == Config->EKind)
+        return T.Create();
   fatal("unknown target machine");
 }
 
+std::vector<StringRef> elf::getTargetNames() {
+  std::vector<StringRef> Ret;
+  for (TargetDescription &T : getAllTargets())
+    Ret.push_back(T.Name);
+  return Ret;
+}
+
 template <class ELFT> static std::string getErrorLoc(const uint8_t *Loc) {
   for (InputSectionBase *D : InputSections) {
     auto *IS = dyn_cast<InputSection>(D);
     if (!IS || !IS->getParent())
       continue;
 
     uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
     if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())