[llvm-driver] Fix clang -fno-integrated-cc1 when invoked from the llvm driver

[abrachet]

Summary

Clang discovers the path to it's own executable and uses this
to re-invoke itself when -fno-integrated-cc1 is set, or if there are
multiple jobs, i.e. multiple source files specified. When clang is
invoked as part of the llvm driver, it's executable is going to be the
driver executable 'llvm', not the symlink 'clang', so the invocation
will look like 'llvm -cc1 ...'. The llvm driver will try to find an tool
called '-cc1' and will fail.

This patch changes clang to realize if the executable it found was
the llvm-driver, in which case it will prepend "clang" to the args.
Unconditionally doin'g "clang" is safe because it will only ever
re-invoke itself in cc1 mode, and never need to specify, clang++,
etc.

[phosek]

llvm/lib/Support/LLVMDriver.cpp

11 ↗

(On Diff #464828)

I'd prefer if this variable was a constant because there's no reason why should ever be changed at runtime.

Rather than defining it here, could we instead define it in llvm/tools/llvm-driver/llvm-driver.cpp and llvm/cmake/driver-template.cpp.in as constant that's initialized to true and false respectively.

[abrachet]

Make llvm::IsLLVMDriver const

[abrachet]

llvm/lib/Support/LLVMDriver.cpp

11 ↗

(On Diff #464828)

Nice, I like that, thanks

[phosek]

clang/lib/Driver/ToolChains/Clang.cpp

5022

Instead of storing a boolean and then duplicating this check and hardcoding the name "clang" in multiple places, we could store the name in the Driver (for example as DriverName) and default it to null. It'd be a responsibility of cc1gen_reproducer_main.cpp and driver.cpp to set it.

[abrachet]

clang/lib/Driver/ToolChains/Clang.cpp

5022

Sure

[dblaikie]

naive question, but... what if the llvm-driver special cased -cc1 as a tool? & then clang wouldn't have to do anything special?

[abrachet]

In D135108#3880245, @dblaikie wrote:

naive question, but... what if the llvm-driver special cased -cc1 as a tool? & then clang wouldn't have to do anything special?

Not a naive question at all. I had actually thought about this option too and listed it as one in this patch when it was a WIP, ultimately we thought that maybe it was too hacky, though so too is this patch. I've created D136895 so that we can compare and contrast.

It's certainly a lot cleaner to just touch the llvm-driver binary and it's nice to not have to touch clang's Job handling. What do folks think?

[abrachet]

I've also added D137800 which is very similar to this patch except it doesn't hardcode "clang" and relies on getting that from the driver

[abrachet]

Went a different direction

clang/include/clang/Driver/Driver.h

private:
   llvm::StringSaver Saver;
 
   /// Arguments originated from configuration file.
   std::unique_ptr<llvm::opt::InputArgList> CfgOptions;
 
   /// Arguments originated from command line.
   std::unique_ptr<llvm::opt::InputArgList> CLOptions;
 
+  /// If this is non-null, the driver will prepend this argument before
+  /// reinvoking clang. This is useful for the llvm-driver where clang's
+  /// realpath will be to the llvm binary and not clang, so it must pass
+  /// "clang" as it's first argument.
+  const char *LLVMDriverPrependArg;
+
   /// Whether to check that input files exist when constructing compilation
   /// jobs.
   unsigned CheckInputsExist : 1;
   /// Whether to probe for PCH files on disk, in order to upgrade
   /// -include foo.h to -include-pch foo.h.pch.
   unsigned ProbePrecompiled : 1;
 
 public:
public:
 
   bool getCheckInputsExist() const { return CheckInputsExist; }
 
   void setCheckInputsExist(bool Value) { CheckInputsExist = Value; }
 
   bool getProbePrecompiled() const { return ProbePrecompiled; }
   void setProbePrecompiled(bool Value) { ProbePrecompiled = Value; }
 
+  const char *getLLVMDriverPrependArg() const { return LLVMDriverPrependArg; }
+  void setLLVMDriverPrependArg(const char *Value) {
+    LLVMDriverPrependArg = Value;
+  }
+
   void setTargetAndMode(const ParsedClangName &TM) { ClangNameParts = TM; }
 
   const std::string &getTitle() { return DriverTitle; }
   void setTitle(std::string Value) { DriverTitle = std::move(Value); }
 
   std::string getTargetTriple() const { return TargetTriple; }
 
   /// Get the path to the main clang executable.

clang/include/clang/Driver/Job.h

class Command {
   const Tool &Creator;
 
   /// Whether and how to generate response files if the arguments are too long.
   ResponseFileSupport ResponseSupport;
 
   /// The executable to run.
   const char *Executable;
 
+  /// Optional argument to prepend.
+  const char *PrependArg;
+
   /// The list of program arguments (not including the implicit first
   /// argument, which will be the executable).
   llvm::opt::ArgStringList Arguments;
 
   /// The list of program inputs.
   std::vector<InputInfo> InputInfoList;
 
   /// The list of program arguments which are outputs. May be empty.
public:
   bool PrintInputFilenames = false;
 
   /// Whether the command will be executed in this process or not.
   bool InProcess = false;
 
   Command(const Action &Source, const Tool &Creator,
           ResponseFileSupport ResponseSupport, const char *Executable,
           const llvm::opt::ArgStringList &Arguments, ArrayRef<InputInfo> Inputs,
-          ArrayRef<InputInfo> Outputs = None);
+          ArrayRef<InputInfo> Outputs = None, const char *PrependArg = nullptr);
   // FIXME: This really shouldn't be copyable, but is currently copied in some
   // error handling in Driver::generateCompilationDiagnostics.
   Command(const Command &) = default;
   virtual ~Command() = default;
 
   virtual void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote,
                      CrashReportInfo *CrashInfo = nullptr) const;
 

 };
 
 /// Use the CC1 tool callback when available, to avoid creating a new process
 class CC1Command : public Command {
 public:
   CC1Command(const Action &Source, const Tool &Creator,
              ResponseFileSupport ResponseSupport, const char *Executable,
              const llvm::opt::ArgStringList &Arguments,
-             ArrayRef<InputInfo> Inputs, ArrayRef<InputInfo> Outputs = None);
+             ArrayRef<InputInfo> Inputs, ArrayRef<InputInfo> Outputs = None,
+             const char *PrependArg = nullptr);
 
   void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote,
              CrashReportInfo *CrashInfo = nullptr) const override;
 
   int Execute(ArrayRef<Optional<StringRef>> Redirects, std::string *ErrMsg,
               bool *ExecutionFailed) const override;
 
   void setEnvironment(llvm::ArrayRef<const char *> NewEnvironment) override;

clang/lib/Driver/Driver.cpp

Driver::Driver(StringRef ClangExecutable, StringRef TargetTriple,
     : Diags(Diags), VFS(std::move(VFS)), Mode(GCCMode),
       SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),
       Offload(OffloadHostDevice), CXX20HeaderType(HeaderMode_None),
       ModulesModeCXX20(false), LTOMode(LTOK_None),
       ClangExecutable(ClangExecutable), SysRoot(DEFAULT_SYSROOT),
       DriverTitle(Title), CCCPrintBindings(false), CCPrintOptions(false),
       CCPrintHeaders(false), CCLogDiagnostics(false), CCGenDiagnostics(false),
       CCPrintProcessStats(false), TargetTriple(TargetTriple), Saver(Alloc),
-      CheckInputsExist(true), ProbePrecompiled(true),
-      SuppressMissingInputWarning(false) {
+      LLVMDriverPrependArg(nullptr), CheckInputsExist(true),
+      ProbePrecompiled(true), SuppressMissingInputWarning(false) {
   // Provide a sane fallback if no VFS is specified.
   if (!this->VFS)
     this->VFS = llvm::vfs::getRealFileSystem();
 
   Name = std::string(llvm::sys::path::filename(ClangExecutable));
   Dir = std::string(llvm::sys::path::parent_path(ClangExecutable));
   InstalledDir = Dir; // Provide a sensible default installed dir.
 

clang/lib/Driver/Job.cpp

 #include <utility>
 
 using namespace clang;
 using namespace driver;
 
 Command::Command(const Action &Source, const Tool &Creator,
                  ResponseFileSupport ResponseSupport, const char *Executable,
                  const llvm::opt::ArgStringList &Arguments,
-                 ArrayRef<InputInfo> Inputs, ArrayRef<InputInfo> Outputs)
+                 ArrayRef<InputInfo> Inputs, ArrayRef<InputInfo> Outputs,
+                 const char *PrependArg)
     : Source(Source), Creator(Creator), ResponseSupport(ResponseSupport),
-      Executable(Executable), Arguments(Arguments) {
+      Executable(Executable), PrependArg(PrependArg), Arguments(Arguments) {
   for (const auto &II : Inputs)
     if (II.isFilename())
       InputInfoList.push_back(II);
   for (const auto &II : Outputs)
     if (II.isFilename())
       OutputFilenames.push_back(II.getFilename());
 }
 
if (ResponseSupport.ResponseKind != ResponseFileSupport::RF_FileList) {
     Out.push_back(ResponseFileFlag.c_str());
     return;
   }
 
   llvm::StringSet<> Inputs;
   for (const auto *InputName : InputFileList)
     Inputs.insert(InputName);
   Out.push_back(Executable);
+
+  if (PrependArg)
+    Out.push_back(PrependArg);
+
   // In a file list, build args vector ignoring parameters that will go in the
   // response file (elements of the InputFileList vector)
   bool FirstInput = true;
   for (const auto *Arg : Arguments) {
     if (Inputs.count(Arg) == 0) {
       Out.push_back(Arg);
     } else if (FirstInput) {
       FirstInput = false;
void Command::Print(raw_ostream &OS, const char *Terminator, bool Quote,
   OS << ' ';
   llvm::sys::printArg(OS, Executable, /*Quote=*/true);
 
   ArrayRef<const char *> Args = Arguments;
   SmallVector<const char *, 128> ArgsRespFile;
   if (ResponseFile != nullptr) {
     buildArgvForResponseFile(ArgsRespFile);
     Args = ArrayRef<const char *>(ArgsRespFile).slice(1); // no executable name
+  } else if (PrependArg) {
+    OS << ' ';
+    llvm::sys::printArg(OS, PrependArg, /*Quote=*/true);
   }
 
   bool HaveCrashVFS = CrashInfo && !CrashInfo->VFSPath.empty();
   for (size_t i = 0, e = Args.size(); i < e; ++i) {
     const char *const Arg = Args[i];
 
     if (CrashInfo) {
       int NumArgs = 0;

 
 int Command::Execute(ArrayRef<llvm::Optional<StringRef>> Redirects,
                      std::string *ErrMsg, bool *ExecutionFailed) const {
   PrintFileNames();
 
   SmallVector<const char *, 128> Argv;
   if (ResponseFile == nullptr) {
     Argv.push_back(Executable);
+    if (PrependArg)
+      Argv.push_back(PrependArg);
     Argv.append(Arguments.begin(), Arguments.end());
     Argv.push_back(nullptr);
   } else {
     // If the command is too large, we need to put arguments in a response file.
     std::string RespContents;
     llvm::raw_string_ostream SS(RespContents);
 
     // Write file contents and build the Argv vector
return llvm::sys::ExecuteAndWait(Executable, Args, Env, Redirects,
                                    /*secondsToWait*/ 0, /*memoryLimit*/ 0,
                                    ErrMsg, ExecutionFailed, &ProcStat);
 }
 
 CC1Command::CC1Command(const Action &Source, const Tool &Creator,
                        ResponseFileSupport ResponseSupport,
                        const char *Executable,
                        const llvm::opt::ArgStringList &Arguments,
-                       ArrayRef<InputInfo> Inputs, ArrayRef<InputInfo> Outputs)
+                       ArrayRef<InputInfo> Inputs, ArrayRef<InputInfo> Outputs,
+                       const char *PrependArg)
     : Command(Source, Creator, ResponseSupport, Executable, Arguments, Inputs,
-              Outputs) {
+              Outputs, PrependArg) {
   InProcess = true;
 }
 
 void CC1Command::Print(raw_ostream &OS, const char *Terminator, bool Quote,
                        CrashReportInfo *CrashInfo) const {
   if (InProcess)
     OS << " (in-process)\n";
   Command::Print(OS, Terminator, Quote, CrashInfo);

clang/lib/Driver/ToolChains/Clang.cpp

for (const auto &II : Inputs) {
       addDashXForInput(Args, II, CmdArgs);
       if (II.isFilename())
         CmdArgs.push_back(II.getFilename());
       else
         II.getInputArg().renderAsInput(Args, CmdArgs);
     }
 
     C.addCommand(std::make_unique<Command>(
         JA, *this, ResponseFileSupport::AtFileUTF8(), D.getClangProgramPath(),
-        CmdArgs, Inputs, Output));
+        CmdArgs, Inputs, Output, D.getLLVMDriverPrependArg()));
     return;
   }
 
   if (C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO)
     CmdArgs.push_back("-fembed-bitcode=marker");
 
   // We normally speed up the clang process a bit by skipping destructors at
   // exit, but when we're generating diagnostics we can rely on some of the
for (const InputInfo &Input : FrontendInputs) {
     if (Input.isFilename())
       CmdArgs.push_back(Input.getFilename());
     else
       Input.getInputArg().renderAsInput(Args, CmdArgs);
   }
 
   if (D.CC1Main && !D.CCGenDiagnostics) {
     // Invoke the CC1 directly in this process
-    C.addCommand(std::make_unique<CC1Command>(JA, *this,
-                                              ResponseFileSupport::AtFileUTF8(),
-                                              Exec, CmdArgs, Inputs, Output));
-  } else {
-    C.addCommand(std::make_unique<Command>(JA, *this,
-                                           ResponseFileSupport::AtFileUTF8(),
-                                           Exec, CmdArgs, Inputs, Output));
+    C.addCommand(std::make_unique<CC1Command>(
+        JA, *this, ResponseFileSupport::AtFileUTF8(), Exec, CmdArgs, Inputs,
+        Output, D.getLLVMDriverPrependArg()));
+  } else {
+    C.addCommand(std::make_unique<Command>(
+        JA, *this, ResponseFileSupport::AtFileUTF8(), Exec, CmdArgs, Inputs,
+        Output, D.getLLVMDriverPrependArg()));
   }
 
   // Make the compile command echo its inputs for /showFilenames.
   if (Output.getType() == types::TY_Object &&
       Args.hasFlag(options::OPT__SLASH_showFilenames,
                    options::OPT__SLASH_showFilenames_, false)) {
     C.getJobs().getJobs().back()->PrintInputFilenames = true;
   }
if (Triple.isAMDGPU())
     handleAMDGPUCodeObjectVersionOptions(D, Args, CmdArgs, /*IsCC1As=*/true);
 
   assert(Input.isFilename() && "Invalid input.");
   CmdArgs.push_back(Input.getFilename());
 
   const char *Exec = getToolChain().getDriver().getClangProgramPath();
   if (D.CC1Main && !D.CCGenDiagnostics) {
     // Invoke cc1as directly in this process.
-    C.addCommand(std::make_unique<CC1Command>(JA, *this,
-                                              ResponseFileSupport::AtFileUTF8(),
-                                              Exec, CmdArgs, Inputs, Output));
-  } else {
-    C.addCommand(std::make_unique<Command>(JA, *this,
-                                           ResponseFileSupport::AtFileUTF8(),
-                                           Exec, CmdArgs, Inputs, Output));
+    C.addCommand(std::make_unique<CC1Command>(
+        JA, *this, ResponseFileSupport::AtFileUTF8(), Exec, CmdArgs, Inputs,
+        Output, D.getLLVMDriverPrependArg()));
+  } else {
+    C.addCommand(std::make_unique<Command>(
+        JA, *this, ResponseFileSupport::AtFileUTF8(), Exec, CmdArgs, Inputs,
+        Output, D.getLLVMDriverPrependArg()));
   }
 }
 
 // Begin OffloadBundler
 
 void OffloadBundler::ConstructJob(Compilation &C, const JobAction &JA,
                                   const InputInfo &Output,
                                   const InputInfoList &Inputs,

clang/test/Analysis/scan-build/lit.local.cfg

 # -*- Python -*-
 
 import lit.util
 import lit.formats
 import os
 
 use_lit_shell = os.environ.get("LIT_USE_INTERNAL_SHELL")
 config.test_format = lit.formats.ShTest(use_lit_shell == "0")
 
+clang_path = config.clang if config.is_llvm_driver else os.path.realpath(config.clang)
+
 config.substitutions.append(('%scan-build',
                              '\'%s\' --use-analyzer=%s ' % (
                                  lit.util.which('scan-build',
                                                 os.path.join(
                                                     config.clang_src_dir,
                                                     'tools',
                                                     'scan-build',
                                                     'bin')),
-                                 os.path.realpath(config.clang))))
+                                 clang_path)))

clang/test/CMakeLists.txt

llvm_canonicalize_cmake_booleans(
   CLANG_PLUGIN_SUPPORT
   CLANG_SPAWN_CC1
   ENABLE_BACKTRACES
   LLVM_ENABLE_ZLIB
   LLVM_ENABLE_ZSTD
   LLVM_ENABLE_PER_TARGET_RUNTIME_DIR
   LLVM_ENABLE_THREADS
   LLVM_WITH_Z3
+  LLVM_TOOL_LLVM_DRIVER_BUILD
   )
 
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py
   MAIN_CONFIG
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py
   PATHS
list(APPEND CLANG_TEST_DEPS
   clang-import-test
   clang-rename
   clang-refactor
   clang-diff
   clang-scan-deps
   diagtool
   hmaptool
   )
-  
 if(CLANG_ENABLE_STATIC_ANALYZER)
   list(APPEND CLANG_TEST_DEPS
     clang-check
     clang-extdef-mapping
     )
 endif()
 
 if (CLANG_ENABLE_ARCMT)

clang/test/CodeGen/debug-info-codeview-buildinfo.c

 // REQUIRES: x86-registered-target
 // RUN: %clang_cl --target=i686-windows-msvc /c /Z7 /Fo%t.obj -- %s
 // RUN: llvm-pdbutil dump --types %t.obj | FileCheck %s
 // RUN: %clang_cl --target=i686-windows-msvc /c /Z7 /Fo%t.obj -fdebug-compilation-dir=. -- %s
 // RUN: llvm-pdbutil dump --types %t.obj | FileCheck %s --check-prefix RELATIVE
 
 int main(void) { return 42; }
 
 // CHECK:                       Types (.debug$T)
 // CHECK: ============================================================
 // CHECK: 0x[[PWD:.+]] | LF_STRING_ID [size = {{.+}}] ID: <no type>, String: [[PWDVAL:.+]]
 // CHECK: 0x[[FILEPATH:.+]] | LF_STRING_ID [size = {{.+}}] ID: <no type>, String: [[FILEPATHVAL:.+[\\/]debug-info-codeview-buildinfo.c]]
 // CHECK: 0x[[ZIPDB:.+]] | LF_STRING_ID [size = {{.+}}] ID: <no type>, String:
-// CHECK: 0x[[TOOL:.+]] | LF_STRING_ID [size = {{.+}}] ID: <no type>, String: [[TOOLVAL:.+[\\/]clang.*]]
+// CHECK: 0x[[TOOL:.+]] | LF_STRING_ID [size = {{.+}}] ID: <no type>, String: [[TOOLVAL:.+[\\/][clang|llvm].*]]
 // CHECK: 0x[[CMDLINE:.+]] | LF_STRING_ID [size = {{.+}}] ID: <no type>, String: "-cc1
 // CHECK: 0x{{.+}} | LF_BUILDINFO [size = {{.+}}]
 // CHECK:          0x[[PWD]]: `[[PWDVAL]]`
 // CHECK:          0x[[TOOL]]: `[[TOOLVAL]]`
 // CHECK:          0x[[FILEPATH]]: `[[FILEPATHVAL]]`
 // CHECK:          0x[[ZIPDB]]: ``
 // CHECK:          0x[[CMDLINE]]: `"-cc1
 
 // RELATIVE:                       Types (.debug$T)
 // RELATIVE: ============================================================
 // RELATIVE: 0x{{.+}} | LF_BUILDINFO [size = {{.+}}]
 // RELATIVE:          0x{{.+}}: `.`

clang/test/Driver/check-time-trace.cpp

 // CHECK:      "args":
 // CHECK:      "detail":
 // CHECK:      "dur":
 // CHECK:      "name":
 // CHECK-NEXT: "ph":
 // CHECK-NEXT: "pid":
 // CHECK-NEXT: "tid":
 // CHECK-NEXT: "ts":
-// CHECK:      "name": "clang{{.*}}"
+// CHECK:      "name": "{{[llvm|clang]}}{{.*}}"
 // CHECK:      "name": "process_name"
 // CHECK:      "name": "thread_name"
 
 template <typename T>
 struct Struct {
   T Num;
 };
 
 int main() {
   Struct<int> S;
 
   return 0;
 }

clang/test/lit.site.cfg.py.in

 config.enable_threads = @LLVM_ENABLE_THREADS@
 config.host_arch = "@HOST_ARCH@"
 config.python_executable = "@Python3_EXECUTABLE@"
 config.use_z3_solver = lit_config.params.get('USE_Z3_SOLVER', "@USE_Z3_SOLVER@")
 config.has_plugins = @CLANG_PLUGIN_SUPPORT@
 config.clang_vendor_uti = "@CLANG_VENDOR_UTI@"
 config.llvm_external_lit = path(r"@LLVM_EXTERNAL_LIT@")
 config.standalone_build = @CLANG_BUILT_STANDALONE@
+config.is_llvm_driver = @LLVM_TOOL_LLVM_DRIVER_BUILD@
 
 import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
 lit_config.load_config(
     config, os.path.join(config.clang_src_dir, "test/lit.cfg.py"))

clang/tools/driver/cc1gen_reproducer_main.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Driver.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
+#include "llvm/Support/LLVMDriver.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 
 namespace {
generateReproducerForInvocationArguments(ArrayRef<const char *> Argv,
 
   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);
   TheDriver.setTargetAndMode(TargetAndMode);
+  if (llvm::IsLLVMDriver)
+    TheDriver.setLLVMDriverPrependArg("clang");
 
   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(
             *C, *Cmd, generateReproducerMetaInfo(Info), &Report);

clang/tools/driver/driver.cpp

 #include "llvm/Option/Option.h"
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/LLVMDriver.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/TargetSelect.h"
TheDriver.CCLogDiagnostics =
       CheckEnvVar("CC_LOG_DIAGNOSTICS", "CC_LOG_DIAGNOSTICS_FILE",
                   TheDriver.CCLogDiagnosticsFilename);
   TheDriver.CCPrintProcessStats =
       CheckEnvVar("CC_PRINT_PROC_STAT", "CC_PRINT_PROC_STAT_FILE",
                   TheDriver.CCPrintStatReportFilename);
 }
 
 static void FixupDiagPrefixExeName(TextDiagnosticPrinter *DiagClient,
-                                   const std::string &Path) {
+                                   const std::string &Path,
+                                   llvm::StringRef Argv0) {
   // If the clang binary happens to be named cl.exe for compatibility reasons,
   // use clang-cl.exe as the prefix to avoid confusion between clang and MSVC.
   StringRef ExeBasename(llvm::sys::path::stem(Path));
   if (ExeBasename.equals_insensitive("cl"))
     ExeBasename = "clang-cl";
+  if (llvm::IsLLVMDriver)
+    ExeBasename = llvm::sys::path::stem(Argv0);
   DiagClient->setPrefix(std::string(ExeBasename));
 }
 
 static void SetInstallDir(SmallVectorImpl<const char *> &argv,
                           Driver &TheDriver, bool CanonicalPrefixes) {
   // Attempt to find the original path used to invoke the driver, to determine
   // the installed path. We do this manually, because we want to support that
   // path being a symlink.
UseNewCC1Process = llvm::StringSwitch<bool>(Arg)
                            .Case("-fintegrated-cc1", false)
                            .Default(UseNewCC1Process);
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts =
       CreateAndPopulateDiagOpts(Args);
 
   TextDiagnosticPrinter *DiagClient
     = new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
-  FixupDiagPrefixExeName(DiagClient, Path);
+  FixupDiagPrefixExeName(DiagClient, Path, Args[0]);
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
 
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
 
   if (!DiagOpts->DiagnosticSerializationFile.empty()) {
     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);
   SetInstallDir(Args, TheDriver, CanonicalPrefixes);
   auto TargetAndMode = ToolChain::getTargetAndModeFromProgramName(Args[0]);
   TheDriver.setTargetAndMode(TargetAndMode);
+  if (llvm::IsLLVMDriver && CanonicalPrefixes)
+    TheDriver.setLLVMDriverPrependArg("clang");
 
   insertTargetAndModeArgs(TargetAndMode, Args, SavedStrings);
 
   SetBackdoorDriverOutputsFromEnvVars(TheDriver);
 
   if (!UseNewCC1Process) {
     TheDriver.CC1Main = &ExecuteCC1Tool;
     // Ensure the CC1Command actually catches cc1 crashes

clang/tools/scan-build/libexec/ccc-analyzer

while (<$OutputStream>) {
     next if (!/\s"?-cc1"?\s/);
     $line = $_;
   }
   die "could not find clang line\n" if (!defined $line);
   # Strip leading and trailing whitespace characters.
   $line =~ s/^\s+|\s+$//g;
   my @items = quotewords('\s+', 0, $line);
   my $cmd = shift @items;
-  die "cannot find 'clang' in 'clang' command\n" if (!($cmd =~ /clang/));
+  die "cannot find 'clang' in 'clang' command\n" if (!($cmd =~ /clang/ || basename($cmd) =~ /llvm/));
+  # If this is the llvm-driver the internal command will look like "llvm clang ...".
+  # Later this will be invoked like "clang clang ...", so skip over it.
+  if (basename($cmd) =~ /llvm/) {
+    die "Expected first arg to llvm driver to be 'clang'" if $items[0] ne "clang";
+    shift @items;
+  }
   return \@items;
 }
 
 sub Analyze {
   my ($Clang, $OriginalArgs, $AnalyzeArgs, $Lang, $Output, $Verbose, $HtmlDir,
       $file) = @_;
 
   my @Args = @$OriginalArgs;

llvm/cmake/modules/llvm-driver-template.cpp.in

 //===-- driver-template.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+namespace llvm {
+
+extern const bool IsLLVMDriver = false;
+
+} // namespace llvm
+
 int @TOOL_NAME@_main(int argc, char **argv);
 
 int main(int argc, char **argv) { return @TOOL_NAME@_main(argc, argv); }

llvm/include/llvm/Support/LLVMDriver.h

+//===- LLVMDriver.h ---------------------------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// The llvm-driver is an executable which statically links in many llvm tools
+// into one. This can be useful for tools which need to behave slightly
+// differently under that environment.
+//
+//===----------------------------------------------------------------------===//
+
+namespace llvm {
+extern const bool IsLLVMDriver;
+} // namespace llvm

llvm/lib/Support/Path.cpp

 // Include the truly platform-specific parts.
 #if defined(LLVM_ON_UNIX)
 #include "Unix/Path.inc"
 #endif
 #if defined(_WIN32)
 #include "Windows/Path.inc"
 #endif
 
-bool IsLLVMDriver = false;
-
 namespace llvm {
 namespace sys {
 namespace fs {
 
-std::string getMainExecutable(const char *Argv0, void *MainAddr) {
-  if (IsLLVMDriver)
-    return sys::path::stem(Argv0).str();
-  return getMainExecutableImpl(Argv0, MainAddr);
-}
-
 TempFile::TempFile(StringRef Name, int FD)
     : TmpName(std::string(Name)), FD(FD) {}
 TempFile::TempFile(TempFile &&Other) { *this = std::move(Other); }
 TempFile &TempFile::operator=(TempFile &&Other) {
   TmpName = std::move(Other.TmpName);
   FD = Other.FD;
   Other.Done = true;
   Other.FD = -1;

llvm/lib/Support/Unix/Path.inc

getprogpath(char ret[PATH_MAX], const char *bin)
   }
   free(s);
   return nullptr;
 }
 #endif // __FreeBSD__ || __NetBSD__ || __FreeBSD_kernel__
 
 /// GetMainExecutable - Return the path to the main executable, given the
 /// value of argv[0] from program startup.
-std::string getMainExecutableImpl(const char *argv0, void *MainAddr) {
+std::string getMainExecutable(const char *argv0, void *MainAddr) {
 #if defined(__APPLE__)
   // On OS X the executable path is saved to the stack by dyld. Reading it
   // from there is much faster than calling dladdr, especially for large
   // binaries with symbols.
   char exe_path[PATH_MAX];
   uint32_t size = sizeof(exe_path);
   if (_NSGetExecutablePath(exe_path, &size) == 0) {
     char link_path[PATH_MAX];

llvm/lib/Support/Windows/Path.inc

 }
 
 } // end namespace windows
 
 namespace fs {
 
 const file_t kInvalidFile = INVALID_HANDLE_VALUE;
 
-std::string getMainExecutableImpl(const char *argv0, void *MainExecAddr) {
+std::string getMainExecutable(const char *argv0, void *MainExecAddr) {
   SmallVector<wchar_t, MAX_PATH> PathName;
   PathName.resize_for_overwrite(PathName.capacity());
   DWORD Size = ::GetModuleFileNameW(NULL, PathName.data(), PathName.size());
 
   // A zero return value indicates a failure other than insufficient space.
   if (Size == 0)
     return "";
 

llvm/tools/llvm-driver/llvm-driver.cpp

 //===-- llvm-driver.cpp ---------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/LLVMDriver.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/WithColor.h"
 
+namespace llvm {
+
+const bool IsLLVMDriver = true;
+
+}
+
 using namespace llvm;
 
 #define LLVM_DRIVER_TOOL(tool, entry) int entry##_main(int argc, char **argv);
 #include "LLVMDriverTools.def"
 
 constexpr char subcommands[] =
 #define LLVM_DRIVER_TOOL(tool, entry) "  " tool "\n"
 #include "LLVMDriverTools.def"
#include "LLVMDriverTools.def"
 
   if (Is("llvm"))
     return findTool(Argc - 1, Argv + 1);
 
   printHelpMessage();
   return 1;
 }
 
-extern bool IsLLVMDriver;
-
-int main(int Argc, char **Argv) {
-  IsLLVMDriver = true;
-  return findTool(Argc, Argv);
-}
+int main(int Argc, char **Argv) { return findTool(Argc, Argv); }