[clang][Driver] Deduce target triplet from clang executable name

[kadircet]

ping

[ilya-biryukov]

After looking at this, adjusting arguments on the clangd side seems to be a better approach.
Let's abandon this.

clang/examples/clang-interpreter/main.cpp

int main(int argc, const char **argv) {
   llvm::Triple T(TripleStr);
 
   // Use ELF on Windows-32 and MingW for now.
 #ifndef CLANG_INTERPRETER_COFF_FORMAT
   if (T.isOSBinFormatCOFF())
     T.setObjectFormat(llvm::Triple::ELF);
 #endif
 
-  Driver TheDriver(Path, T.str(), Diags);
+  Driver TheDriver(Path, Diags, nullptr, T.str());
   TheDriver.setTitle("clang interpreter");
   TheDriver.setCheckInputsExist(false);
 
   // FIXME: This is a hack to try to force the driver to do something we can
   // recognize. We need to extend the driver library to support this use model
   // (basically, exactly one input, and the operation mode is hard wired).
   SmallVector<const char *, 16> Args(argv, argv + argc);
   Args.push_back("-fsyntax-only");

clang/include/clang/Driver/Driver.h

 
 public:
 
   /// Takes the path to a binary that's either in bin/ or lib/ and returns
   /// the path to clang's resource directory.
   static std::string GetResourcesPath(StringRef BinaryPath,
                                       StringRef CustomResourceDir = "");
 
-  Driver(StringRef ClangExecutable, StringRef TargetTriple,
-         DiagnosticsEngine &Diags,
-         IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = nullptr);
+  /// If TargetTriple empty, it is deduced from ClangExecutable and falls back
+  /// to llvm::sys::getDefaultTriple() if deduction fails.
+  Driver(StringRef ClangExecutable, DiagnosticsEngine &Diags,
+         IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS = nullptr,
+         StringRef TargetTriple = "");
 
   /// @name Accessors
   /// @{
 
   /// Name to use when invoking gcc/g++.
   const std::string &getCCCGenericGCCName() const { return CCCGenericGCCName; }
 
   const std::string &getConfigFile() const { return ConfigFile; }

clang/lib/Driver/Driver.cpp

 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptSpecifier.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
if (CustomResourceDir != "") {
     P = llvm::sys::path::parent_path(Dir);
     llvm::sys::path::append(P, Twine("lib") + CLANG_LIBDIR_SUFFIX, "clang",
                             CLANG_VERSION_STRING);
   }
 
   return P.str();
 }
 
-Driver::Driver(StringRef ClangExecutable, StringRef TargetTriple,
-               DiagnosticsEngine &Diags,
-               IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS)
+Driver::Driver(StringRef ClangExecutable, DiagnosticsEngine &Diags,
+               IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
+               StringRef TargetTriple)
     : Opts(createDriverOptTable()), Diags(Diags), VFS(std::move(VFS)),
       Mode(GCCMode), SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),
       LTOMode(LTOK_None), ClangExecutable(ClangExecutable),
       SysRoot(DEFAULT_SYSROOT), DriverTitle("clang LLVM compiler"),
       CCPrintOptionsFilename(nullptr), CCPrintHeadersFilename(nullptr),
       CCLogDiagnosticsFilename(nullptr), CCCPrintBindings(false),
       CCPrintOptions(false), CCPrintHeaders(false), CCLogDiagnostics(false),
       CCGenDiagnostics(false), TargetTriple(TargetTriple),
#if defined(CLANG_CONFIG_FILE_SYSTEM_DIR)
   SystemConfigDir = CLANG_CONFIG_FILE_SYSTEM_DIR;
 #endif
 #if defined(CLANG_CONFIG_FILE_USER_DIR)
   UserConfigDir = CLANG_CONFIG_FILE_USER_DIR;
 #endif
 
   // Compute the path to the resource directory.
   ResourceDir = GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);
+
+  if (TargetTriple.empty()) {
+    ClangNameParts =
+        ToolChain::getTargetAndModeFromProgramName(ClangExecutable);
+    if (ClangNameParts.TargetIsValid)
+      this->TargetTriple = ClangNameParts.TargetPrefix;
+    else
+      this->TargetTriple = llvm::sys::getDefaultTargetTriple();
+  }
 }
 
 void Driver::ParseDriverMode(StringRef ProgramName,
                              ArrayRef<const char *> Args) {
   if (ClangNameParts.isEmpty())
     ClangNameParts = ToolChain::getTargetAndModeFromProgramName(ProgramName);
   setDriverModeFromOption(ClangNameParts.DriverMode);
 

clang/lib/Frontend/CreateInvocationFromCommandLine.cpp

std::unique_ptr<CompilerInvocation> clang::createInvocationFromCommandLine(
   }
 
   SmallVector<const char *, 16> Args(ArgList.begin(), ArgList.end());
 
   // FIXME: Find a cleaner way to force the driver into restricted modes.
   Args.push_back("-fsyntax-only");
 
   // FIXME: We shouldn't have to pass in the path info.
-  driver::Driver TheDriver(Args[0], llvm::sys::getDefaultTargetTriple(),
-                           *Diags, VFS);
+  driver::Driver TheDriver(Args[0], *Diags, VFS);
 
   // Don't check that inputs exist, they may have been remapped.
   TheDriver.setCheckInputsExist(false);
 
   std::unique_ptr<driver::Compilation> C(TheDriver.BuildCompilation(Args));
   if (!C)
     return nullptr;
 

clang/lib/Tooling/CompilationDatabase.cpp

static bool stripPositionalArgs(std::vector<const char *> Args,
   UnusedInputDiagConsumer DiagClient(DiagnosticPrinter);
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
       &*DiagOpts, &DiagClient, false);
 
   // The clang executable path isn't required since the jobs the driver builds
   // will not be executed.
   std::unique_ptr<driver::Driver> NewDriver(new driver::Driver(
-      /* ClangExecutable= */ "", llvm::sys::getDefaultTargetTriple(),
-      Diagnostics));
+      /* ClangExecutable= */ "", Diagnostics));
   NewDriver->setCheckInputsExist(false);
 
   // This becomes the new argv[0]. The value is used to detect libc++ include
   // dirs on Mac, it isn't used for other platforms.
   std::string Argv0 = GetClangToolCommand();
   Args.insert(Args.begin(), Argv0.c_str());
 
   // By adding -c, we force the driver to treat compilation as the last phase.

clang/lib/Tooling/Tooling.cpp

 // code that sets up a compiler to run tools on it, and we should refactor
 // it to be based on the same framework.
 
 /// Builds a clang driver initialized for running clang tools.
 static driver::Driver *
 newDriver(DiagnosticsEngine *Diagnostics, const char *BinaryName,
           IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS) {
   driver::Driver *CompilerDriver =
-      new driver::Driver(BinaryName, llvm::sys::getDefaultTargetTriple(),
-                         *Diagnostics, std::move(VFS));
+      new driver::Driver(BinaryName, *Diagnostics, std::move(VFS));
   CompilerDriver->setTitle("clang_based_tool");
   return CompilerDriver;
 }
 
 /// Retrieves the clang CC1 specific flags out of the compilation's jobs.
 ///
 /// Returns nullptr on error.
 static const llvm::opt::ArgStringList *getCC1Arguments(

clang/tools/driver/cc1gen_reproducer_main.cpp

generateReproducerForInvocationArguments(ArrayRef<const char *> Argv,
   using namespace driver;
   auto TargetAndMode = ToolChain::getTargetAndModeFromProgramName(Argv[0]);
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions;
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new IgnoringDiagConsumer());
   ProcessWarningOptions(Diags, *DiagOpts, /*ReportDiags=*/false);
-  Driver TheDriver(Argv[0], llvm::sys::getDefaultTargetTriple(), Diags);
+  Driver TheDriver(Argv[0], Diags);
   TheDriver.setTargetAndMode(TargetAndMode);
 
   std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(Argv));
   if (C && !C->containsError()) {
     for (const auto &J : C->getJobs()) {
       if (const Command *Cmd = dyn_cast<Command>(&J)) {
         Driver::CompilationDiagnosticReport Report;
         TheDriver.generateCompilationDiagnostics(

clang/tools/driver/driver.cpp

auto SerializedConsumer =
         clang::serialized_diags::create(DiagOpts->DiagnosticSerializationFile,
                                         &*DiagOpts, /*MergeChildRecords=*/true);
     Diags.setClient(new ChainedDiagnosticConsumer(
         Diags.takeClient(), std::move(SerializedConsumer)));
   }
 
   ProcessWarningOptions(Diags, *DiagOpts, /*ReportDiags=*/false);
 
-  Driver TheDriver(Path, llvm::sys::getDefaultTargetTriple(), Diags);
+  Driver TheDriver(Path, Diags);
   SetInstallDir(argv, TheDriver, CanonicalPrefixes);
   TheDriver.setTargetAndMode(TargetAndMode);
 
   insertTargetAndModeArgs(TargetAndMode, argv, SavedStrings);
 
   SetBackdoorDriverOutputsFromEnvVars(TheDriver);
 
   std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(argv));

clang/unittests/Driver/ToolChainTest.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Driver/ToolChain.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 using namespace clang;
 using namespace clang::driver;
 
 namespace {
 
 TEST(ToolChainTest, VFSGCCInstallation) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
   IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
       new llvm::vfs::InMemoryFileSystem);
-  Driver TheDriver("/bin/clang", "arm-linux-gnueabihf", Diags,
-                   InMemoryFileSystem);
+  Driver TheDriver("/bin/clang", Diags, InMemoryFileSystem,
+                   "arm-linux-gnueabihf");
 
   const char *EmptyFiles[] = {
       "foo.cpp",
       "/bin/clang",
       "/usr/lib/gcc/arm-linux-gnueabi/4.6.1/crtbegin.o",
       "/usr/lib/gcc/arm-linux-gnueabi/4.6.1/crtend.o",
       "/usr/lib/gcc/arm-linux-gnueabihf/4.6.3/crtbegin.o",
       "/usr/lib/gcc/arm-linux-gnueabihf/4.6.3/crtend.o",

 TEST(ToolChainTest, VFSGCCInstallationRelativeDir) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
   IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
       new llvm::vfs::InMemoryFileSystem);
-  Driver TheDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
-                   InMemoryFileSystem);
+  Driver TheDriver("/home/test/bin/clang", Diags, InMemoryFileSystem,
+                   "arm-linux-gnueabi");
 
   const char *EmptyFiles[] = {
       "foo.cpp", "/home/test/lib/gcc/arm-linux-gnueabi/4.6.1/crtbegin.o",
       "/home/test/include/arm-linux-gnueabi/.keep"};
 
   for (const char *Path : EmptyFiles)
     InMemoryFileSystem->addFile(Path, 0,
                                 llvm::MemoryBuffer::getMemBuffer("\n"));
TEST(ToolChainTest, DefaultDriverMode) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
   IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFileSystem(
       new llvm::vfs::InMemoryFileSystem);
 
-  Driver CCDriver("/home/test/bin/clang", "arm-linux-gnueabi", Diags,
-                  InMemoryFileSystem);
+  Driver CCDriver("/home/test/bin/clang", Diags, InMemoryFileSystem,
+                  "arm-linux-gnueabi");
   CCDriver.setCheckInputsExist(false);
-  Driver CXXDriver("/home/test/bin/clang++", "arm-linux-gnueabi", Diags,
-                   InMemoryFileSystem);
+  Driver CXXDriver("/home/test/bin/clang++", Diags, InMemoryFileSystem,
+                   "arm-linux-gnueabi");
   CXXDriver.setCheckInputsExist(false);
-  Driver CLDriver("/home/test/bin/clang-cl", "arm-linux-gnueabi", Diags,
-                  InMemoryFileSystem);
+  Driver CLDriver("/home/test/bin/clang-cl", Diags, InMemoryFileSystem,
+                  "arm-linux-gnueabi");
   CLDriver.setCheckInputsExist(false);
 
   std::unique_ptr<Compilation> CC(CCDriver.BuildCompilation(
       { "/home/test/bin/clang", "foo.cpp"}));
   std::unique_ptr<Compilation> CXX(CXXDriver.BuildCompilation(
       { "/home/test/bin/clang++", "foo.cpp"}));
   std::unique_ptr<Compilation> CL(CLDriver.BuildCompilation(
       { "/home/test/bin/clang-cl", "foo.cpp"}));
 
   EXPECT_TRUE(CC);
   EXPECT_TRUE(CXX);
   EXPECT_TRUE(CL);
   EXPECT_TRUE(CCDriver.CCCIsCC());
   EXPECT_TRUE(CXXDriver.CCCIsCXX());
   EXPECT_TRUE(CLDriver.IsCLMode());
 }
 TEST(ToolChainTest, InvalidArgument) {
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   struct TestDiagnosticConsumer : public DiagnosticConsumer {};
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
-  Driver TheDriver("/bin/clang", "arm-linux-gnueabihf", Diags);
+  Driver TheDriver("/bin/clang", Diags, nullptr, "arm-linux-gnueabihf");
   std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(
       {"-fsyntax-only", "-fan-unknown-option", "foo.cpp"}));
   EXPECT_TRUE(C);
   EXPECT_TRUE(C->containsError());
 }
 
 TEST(ToolChainTest, ParsedClangName) {
   ParsedClangName Empty;
TEST(ToolChainTest, GetTargetAndMode) {
   EXPECT_FALSE(Res.TargetIsValid);
 
   Res = ToolChain::getTargetAndModeFromProgramName("qqq-clang-cl");
   EXPECT_TRUE(Res.TargetPrefix == "qqq");
   EXPECT_TRUE(Res.ModeSuffix == "clang-cl");
   EXPECT_STREQ(Res.DriverMode, "--driver-mode=cl");
   EXPECT_FALSE(Res.TargetIsValid);
 }
+
+TEST(ToolChainTest, TargetTripletDeduction) {
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
+  struct TestDiagnosticConsumer : public DiagnosticConsumer {};
+  DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
+
+  // TargetTriple set
+  {
+    Driver TheDriver("/bin/x86_64-fuchsia-clang", Diags, nullptr,
+                     "arm-linux-gnueabihf");
+    std::unique_ptr<Compilation> C(
+        TheDriver.BuildCompilation({"-fsyntax-only", "foo.cpp"}));
+    EXPECT_TRUE(C);
+    EXPECT_EQ(C->getDefaultToolChain().ComputeEffectiveClangTriple(
+                  llvm::opt::InputArgList{}),
+              "armv6kz-unknown-linux-gnueabihf");
+  }
+
+  // TargetTriple deduced from executable
+  {
+    Driver TheDriver("/bin/x86_64-fuchsia-clang", Diags);
+    std::unique_ptr<Compilation> C(
+        TheDriver.BuildCompilation({"-fsyntax-only", "foo.cpp"}));
+    EXPECT_TRUE(C);
+    EXPECT_EQ(C->getDefaultToolChain().ComputeEffectiveClangTriple(
+                  llvm::opt::InputArgList{}),
+              "x86_64-unknown-linux-gnu");
+  }
+
+  // TargetTriple from default triplet
+  {
+    Driver TheDriver("clang", Diags);
+    std::unique_ptr<Compilation> C(
+        TheDriver.BuildCompilation({"-fsyntax-only", "foo.cpp"}));
+    EXPECT_TRUE(C);
+    EXPECT_EQ(C->getDefaultToolChain().ComputeEffectiveClangTriple(
+                  llvm::opt::InputArgList{}),
+              llvm::sys::getDefaultTargetTriple());
+  }
+}
+
 } // end anonymous namespace.