[llvm-dlltool] Imply the target arch from a tool triple prefix

[mstorsjo]

Summary

Also use the default LLVM target as default for dlltool. This
matches how GNU dlltool behaves; it is compiled with one default
target, which is used if no option is provided.

Extend the anonymous namespace in the implementation file instead
of using static functions.

Based on a patch by Mateusz Mikuła.

The effect of the default LLVM target, if neither the -m option
nor a tool triple prefix is provided, isn't tested, as we can't
make assumptions about what it set to.

(We could make the default be forced to one of the four supported
architectures if the default triple is another arch, and then just
test that llvm-dlltool without an -m option is able to produce an
import library, without checking the actual architecture though.)

[mati865]

Feels a bit like approving myself (which is only partially true) but I don't see any issues with the patch itself.

llvm/lib/ToolDrivers/llvm-dlltool/DlltoolDriver.cpp

 //===- DlltoolDriver.cpp - dlltool.exe-compatible driver ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines an interface to a dlltool.exe-compatible driver.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ToolDrivers/llvm-dlltool/DlltoolDriver.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/COFFModuleDefinition.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::COFF;
 

 #undef OPTION
 };
 
 class DllOptTable : public llvm::opt::OptTable {
 public:
   DllOptTable() : OptTable(InfoTable, false) {}
 };
 
-} // namespace
-
 // Opens a file. Path has to be resolved already.
-static std::unique_ptr<MemoryBuffer> openFile(const Twine &Path) {
+std::unique_ptr<MemoryBuffer> openFile(const Twine &Path) {
   ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MB = MemoryBuffer::getFile(Path);
 
   if (std::error_code EC = MB.getError()) {
     llvm::errs() << "cannot open file " << Path << ": " << EC.message() << "\n";
     return nullptr;
   }
 
   return std::move(*MB);
 }
 
-static MachineTypes getEmulation(StringRef S) {
+MachineTypes getEmulation(StringRef S) {
   return StringSwitch<MachineTypes>(S)
       .Case("i386", IMAGE_FILE_MACHINE_I386)
       .Case("i386:x86-64", IMAGE_FILE_MACHINE_AMD64)
       .Case("arm", IMAGE_FILE_MACHINE_ARMNT)
       .Case("arm64", IMAGE_FILE_MACHINE_ARM64)
       .Default(IMAGE_FILE_MACHINE_UNKNOWN);
 }
 
+MachineTypes getMachine(Triple T) {
+  switch (T.getArch()) {
+  case Triple::x86:
+    return COFF::IMAGE_FILE_MACHINE_I386;
+  case Triple::x86_64:
+    return COFF::IMAGE_FILE_MACHINE_AMD64;
+  case Triple::arm:
+    return COFF::IMAGE_FILE_MACHINE_ARMNT;
+  case Triple::aarch64:
+    return COFF::IMAGE_FILE_MACHINE_ARM64;
+  default:
+    return COFF::IMAGE_FILE_MACHINE_UNKNOWN;
+  }
+}
+
+MachineTypes getDefaultMachine() {
+  return getMachine(Triple(sys::getDefaultTargetTriple()));
+}
+
+static bool consume_back_lower(StringRef &S, const char *Str) {
+  if (!S.endswith_lower(Str))
+    return false;
+  S = S.drop_back(strlen(Str));
+  return true;
+}
+
+Optional<std::string> getPrefix(StringRef Argv0) {
+  StringRef ProgName = llvm::sys::path::stem(Argv0);
+  // x86_64-w64-mingw32-dlltool -> x86_64-w64-mingw32
+  // llvm-dlltool -> None
+  // aarch64-w64-mingw32-llvm-dlltool-10.exe -> aarch64-w64-mingw32
+  ProgName = ProgName.rtrim("0123456789.-");
+  if (!consume_back_lower(ProgName, "dlltool"))
+    return None;
+  consume_back_lower(ProgName, "llvm-");
+  consume_back_lower(ProgName, "-");
+  return ProgName.str();
+}
+
+} // namespace
+
 int llvm::dlltoolDriverMain(llvm::ArrayRef<const char *> ArgsArr) {
   DllOptTable Table;
   unsigned MissingIndex;
   unsigned MissingCount;
   llvm::opt::InputArgList Args =
       Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount);
   if (MissingCount) {
     llvm::errs() << Args.getArgString(MissingIndex) << ": missing argument\n";
     return 1;
   }
 
   // Handle when no input or output is specified
   if (Args.hasArgNoClaim(OPT_INPUT) ||
       (!Args.hasArgNoClaim(OPT_d) && !Args.hasArgNoClaim(OPT_l))) {
     Table.PrintHelp(outs(), "llvm-dlltool [options] file...", "llvm-dlltool",
                     false);
     llvm::outs() << "\nTARGETS: i386, i386:x86-64, arm, arm64\n";
     return 1;
   }
 
-  if (!Args.hasArgNoClaim(OPT_m) && Args.hasArgNoClaim(OPT_d)) {
-    llvm::errs() << "error: no target machine specified\n"
-                 << "supported targets: i386, i386:x86-64, arm, arm64\n";
-    return 1;
-  }
-
   for (auto *Arg : Args.filtered(OPT_UNKNOWN))
     llvm::errs() << "ignoring unknown argument: " << Arg->getAsString(Args)
                  << "\n";
 
   if (!Args.hasArg(OPT_d)) {
     llvm::errs() << "no definition file specified\n";
     return 1;
   }
 
   std::unique_ptr<MemoryBuffer> MB =
       openFile(Args.getLastArg(OPT_d)->getValue());
   if (!MB)
     return 1;
 
   if (!MB->getBufferSize()) {
     llvm::errs() << "definition file empty\n";
     return 1;
   }
 
-  COFF::MachineTypes Machine = IMAGE_FILE_MACHINE_UNKNOWN;
+  COFF::MachineTypes Machine = getDefaultMachine();
+  if (Optional<std::string> Prefix = getPrefix(ArgsArr[0])) {
+    Triple T(*Prefix);
+    if (T.getArch() != Triple::UnknownArch)
+      Machine = getMachine(T);
+  }
   if (auto *Arg = Args.getLastArg(OPT_m))
     Machine = getEmulation(Arg->getValue());
 
   if (Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
     llvm::errs() << "unknown target\n";
     return 1;
   }
 

llvm/test/tools/llvm-dlltool/triple-prefix.def

+;; Don't make symlinks on Windows.
+; UNSUPPORTED: system-windows
+
+; RUN: rm -rf %t
+; RUN: mkdir %t
+; RUN: ln -s llvm-dlltool %t/i686-w64-mingw32-llvm-dlltool-10.0.exe
+; RUN: ln -s llvm-dlltool %t/x86_64-w64-mingw32-llvm-dlltool-10
+; RUN: ln -s llvm-dlltool %t/armv7-w64-mingw32-dlltool
+; RUN: ln -s llvm-dlltool %t/aarch64-w64-mingw32-DLLTOOL.exe
+
+; RUN: %t/i686-w64-mingw32-llvm-dlltool-10.0.exe -d %s -l %t.a
+; RUN: llvm-readobj %t.a | FileCheck --check-prefix=I386 %s
+; RUN: %t/x86_64-w64-mingw32-llvm-dlltool-10 -d %s -l %t.a
+; RUN: llvm-readobj %t.a | FileCheck --check-prefix=X86_64 %s
+; RUN: %t/armv7-w64-mingw32-dlltool -d %s -l %t.a
+; RUN: llvm-readobj %t.a | FileCheck --check-prefix=ARM %s
+; RUN: %t/aarch64-w64-mingw32-DLLTOOL.exe -d %s -l %t.a
+; RUN: llvm-readobj %t.a | FileCheck --check-prefix=ARM64 %s
+
+LIBRARY test.dll
+EXPORTS
+TestFunction
+
+; I386: Format: COFF-i386
+; X86_64: Format: COFF-x86-64
+; ARM: Format: COFF-ARM{{$}}
+; ARM64: Format: COFF-ARM64