[WIP][llvm-driver] Accept -cc1 and friends as tools meaning clang

[abrachet]

Summary

This is a possible alternative to D135108, the downside here is that some tests expect clang -### output to start with clang and those need to be fixed up more often here because in D135108 "clang" is still present as the 1st arg not the executable name. It is much cleaner in terms of amount of code that needs to be changed.

[phosek]

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

65–71

Could you instead include -cc1, -cc1as and -cc1gen-reproducer as an alias for clang by appending them to LLVM_DRIVER_TOOL_ALIASES_clang?

[abrachet]

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

65–71

Unfortunately not because these are the 1st argument and not the executable name so we would end up invoking clang with argv[0] as "-cc1" and that arg would get skipped.

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

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/amdgpu-toolchain.c

 // RUN: %clang -### --target=amdgcn--amdhsa -x assembler -mcpu=kaveri %s 2>&1 | FileCheck -check-prefix=AS_LINK %s
 // RUN: %clang -### -g --target=amdgcn--amdhsa -mcpu=kaveri %s 2>&1 | FileCheck -check-prefix=DWARF_VER %s
 // RUN: %clang -### --target=amdgcn-amd-amdpal -x assembler -mcpu=kaveri %s 2>&1 | FileCheck -check-prefix=AS_LINK %s
 // RUN: %clang -### -g --target=amdgcn-amd-amdpal -mcpu=kaveri %s 2>&1 | FileCheck -check-prefix=DWARF_VER %s
 // RUN: %clang -### --target=amdgcn-mesa-mesa3d -x assembler -mcpu=kaveri %s 2>&1 | FileCheck -check-prefix=AS_LINK %s
 // RUN: %clang -### -g --target=amdgcn-mesa-mesa3d -mcpu=kaveri %s 2>&1 | FileCheck -check-prefix=DWARF_VER %s
 
 // AS_LINK: "-cc1as"
 // AS_LINK: ld.lld{{.*}} "-shared"
 
 // DWARF_VER: "-dwarf-version=5"
 
 // RUN: %clang -### --target=amdgcn-amd-amdhsa -mcpu=gfx906 -nogpulib \
 // RUN:   -flto %s 2>&1 | FileCheck -check-prefix=LTO %s
-// LTO: clang{{.*}} "-flto=full"
+// LTO: {{clang|llvm}}{{.*}} "-flto=full"
 // LTO: ld.lld{{.*}}

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": "{{clang|llvm}}{{.*}}"
 // CHECK:      "name": "process_name"
 // CHECK:      "name": "thread_name"
 
 template <typename T>
 struct Struct {
   T Num;
 };
 
 int main() {
   Struct<int> S;
 
   return 0;
 }

clang/test/Driver/flang/multiple-inputs-mixed.f90

 ! Check that flang can handle mixed C and fortran inputs.
 
 ! RUN: %clang --driver-mode=flang -### -fsyntax-only %S/Inputs/one.f90 %S/Inputs/other.c 2>&1 | FileCheck --check-prefixes=CHECK-SYNTAX-ONLY %s
 ! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}flang-new{{[^"/]*}}" "-fc1"
 ! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/one.f90"
-! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}clang{{[^"/]*}}" "-cc1"
+! CHECK-SYNTAX-ONLY-LABEL: "{{[^"]*}}{{clang|llvm}}{{[^"/]*}}" "-cc1"
 ! CHECK-SYNTAX-ONLY: "{{[^"]*}}/Inputs/other.c"

clang/test/Driver/hipspv-device-libs.hip

 // Test --hip-device-lib w/ --hip-device-lib-path and HIP_DEVICE_LIB_PATH.
 // RUN: env HIP_DEVICE_LIB_PATH=%S/Inputs/hipspv-dev-lib/a \
 // RUN:   %clang -### -target x86_64-linux-gnu --offload=spirv64 \
 // RUN:    --hip-path=%S/Inputs/hipspv \
 // RUN:    --hip-device-lib-path=%S/Inputs/hipspv-dev-lib/b \
 // RUN:    --hip-device-lib=a.bc --hip-device-lib=b.bc %s \
 // RUN: 2>&1 | FileCheck --check-prefixes=ALL,HIP-DEV-LIB %s
 
-// ALL: {{"[^"]*clang[^"]*"}}
+// ALL: {{"[^"]*[clang|llvm][^"]*"}}
 // HIP-PATH: "-mlink-builtin-bitcode" {{".*/hipspv/lib/hip-device-lib/hipspv-spirv64.bc"}}
 // HIP-DEV-LIB-PATH-NOT: "-mlink-builtin-bitcode" {{".*/hipspv/lib/hip-device-lib/hipspv-spirv64.bc"}}
 // HIP-DEV-LIB-PATH: "-mlink-builtin-bitcode" {{".*/hipspv-dev-lib/hipspv-spirv64.bc"}}
 // HIP-DEV-LIB: "-mlink-builtin-bitcode" {{".*/hipspv-dev-lib/a/a.bc"}}
 // HIP-DEV-LIB-SAME: "-mlink-builtin-bitcode" {{".*/hipspv-dev-lib/b/b.bc"}}

clang/test/Driver/hipspv-toolchain-rdc.hip

 // REQUIRES: x86-registered-target
 // UNSUPPORTED: system-windows
 
 // RUN: %clang -### -x hip -target x86_64-linux-gnu --offload=spirv64 \
 // RUN:   -fgpu-rdc --hip-path=%S/Inputs/hipspv -nohipwrapperinc \
 // RUN:   %S/Inputs/hip_multiple_inputs/a.cu \
 // RUN:   %S/Inputs/hip_multiple_inputs/b.hip \
 // RUN: 2>&1 | FileCheck %s
 
 // Emit objects for host side path
-// CHECK: [[CLANG:".*clang.*"]] "-cc1" "-triple" "x86_64-unknown-linux-gnu"
+// CHECK: [[CLANG:".*[clang|llvm].*"]] "-cc1" "-triple" "x86_64-unknown-linux-gnu"
 // CHECK-SAME: "-aux-triple" "spirv64"
 // CHECK-SAME: "-emit-obj"
 // CHECK-SAME: "-fgpu-rdc"
 // CHECK-SAME: {{.*}} "-o" [[A_OBJ_HOST:".*o"]] "-x" "hip"
 // CHECK-SAME: {{.*}} [[A_SRC:".*a.cu"]]
 
 // CHECK: [[CLANG]] "-cc1" "-triple" "x86_64-unknown-linux-gnu"
 // CHECK-SAME: "-aux-triple" "spirv64"

clang/test/Driver/hipspv-toolchain.hip

 // REQUIRES: x86-registered-target
 // UNSUPPORTED: system-windows
 
 // RUN: %clang -### -target x86_64-linux-gnu --offload=spirv64 \
 // RUN:   --hip-path=%S/Inputs/hipspv -nohipwrapperinc %s \
 // RUN: 2>&1 | FileCheck %s
 
-// CHECK: [[CLANG:".*clang.*"]] "-cc1" "-triple" "spirv64"
+// CHECK: [[CLANG:".*[clang|llvm].*"]] "-cc1" "-triple" "spirv64"
 // CHECK-SAME: "-aux-triple" "{{.*}}" "-emit-llvm-bc"
 // CHECK-SAME: "-fcuda-is-device"
 // CHECK-SAME: "-fcuda-allow-variadic-functions"
 // CHECK-SAME: "-mlink-builtin-bitcode" {{".*/hipspv/lib/hip-device-lib/hipspv-spirv64.bc"}}
 // CHECK-SAME: "-isystem" {{".*/hipspv/include"}}
 // CHECK-SAME: "-fhip-new-launch-api"
 // CHECK-SAME: "-o" [[DEV_BC:".*bc"]]
 // CHECK-SAME: "-x" "hip"

clang/test/Driver/ignore-xcoff-visibility.cpp

 // RUN: %clang -### -target powerpc-unknown-aix  -mignore-xcoff-visibility -S %s 2> %t.log
 // RUN: FileCheck -check-prefix=CHECK %s < %t.log
- CHECK: {{.*}}clang{{.*}}" "-cc1"
+ CHECK: {{.*}}{{clang|llvm}}{{.*}}" "-cc1"
  CHECK: "-mignore-xcoff-visibility"
 
 // RUN: not %clang -mignore-xcoff-visibility -target powerpc-unknown-linux  %s  2>&1 | \
 // RUN: FileCheck -check-prefix=ERROR %s
 
  ERROR: unsupported option '-mignore-xcoff-visibility' for target 'powerpc-unknown-linux'

clang/test/Driver/no-canonical-prefixes.c

 // RUN: ./test-clang -v -S %s 2>&1 \
 // RUN:     -no-canonical-prefixes \
 // RUN:     -canonical-prefixes \
 // RUN:     -no-canonical-prefixes \
 // RUN:     | FileCheck --check-prefix=NON-CANONICAL %s
 //
 // FIXME: This should really be '.real'.
 // CANONICAL: InstalledDir: {{.*}}.fake
-// CANONICAL: {{[/|\\]*}}clang{{.*}}" -cc1
+// CANONICAL: {{[/|\\]*}}{{clang|llvm}}{{.*}}" -cc1
 //
 // NON-CANONICAL: InstalledDir: .{{$}}
 // NON-CANONICAL: test-clang" -cc1

clang/test/Driver/ps4-ps5-header-search.c

 /// PS4 and PS5 use the same SDK layout, so use the same tree for both.
 // RUN: env SCE_ORBIS_SDK_DIR=%S/Inputs/scei-ps4_tree %clang -target x86_64-scei-ps4 --sysroot="" -E -v %s 2>&1 | FileCheck %s --check-prefix=ENVPS4
 // RUN: env SCE_PROSPERO_SDK_DIR=%S/Inputs/scei-ps4_tree %clang -target x86_64-sie-ps5 --sysroot="" -E -v %s 2>&1 | FileCheck %s --check-prefix=ENVPS4
 // ENVPS4: Inputs/scei-ps4_tree/target/include{{$}}
 // ENVPS4: Inputs/scei-ps4_tree/target/include_common{{$}}
 // ENVPS4-NOT: /usr/include
 
 // RUN: %clang -isysroot %S/Inputs/scei-ps4_tree -target x86_64-scei-ps4 -E -v %s 2>&1 | FileCheck %s --check-prefix=SYSROOTPS4
 // RUN: %clang -isysroot %S/Inputs/scei-ps4_tree -target x86_64-sie-ps5 -E -v %s 2>&1 | FileCheck %s --check-prefix=SYSROOTPS4
-// SYSROOTPS4: "{{[^"]*}}clang{{[^"]*}}"
+// SYSROOTPS4: "{{[^"]*}}{{clang|llvm}}{{[^"]*}}"
 // SYSROOTPS4: Inputs/scei-ps4_tree/target/include{{$}}
 // SYSROOTPS4: Inputs/scei-ps4_tree/target/include_common{{$}}
 // SYSROOTPS4-NOT: /usr/include

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/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,

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/));
   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"
     ;
 
+constexpr bool isClangDefined() {
+#define LLVM_DRIVER_TOOL(tool, entry)                                          \
+  if constexpr (std::string_view(#entry) == "clang")                           \
+    return true;
+#include "LLVMDriverTools.def"
+  return false;
+}
+
 static void printHelpMessage() {
   llvm::outs() << "OVERVIEW: llvm toolchain driver\n\n"
                << "USAGE: llvm [subcommand] [options]\n\n"
                << "SUBCOMMANDS:\n\n"
                << subcommands
                << "\n  Type \"llvm <subcommand> --help\" to get more help on a "
                   "specific subcommand\n\n"
                << "OPTIONS:\n\n  --help - Display this message";
 }
 
 static int findTool(int Argc, char **Argv) {
   if (!Argc) {
     printHelpMessage();
     return 1;
   }
 
   StringRef ToolName = Argv[0];
 
   if (ToolName == "--help") {
     printHelpMessage();
     return 0;
   }
 
+  if constexpr (isClangDefined()) {
+    if (Argc > 1) {
+      StringRef Argv1 = Argv[1];
+      if (Argv1 == "-cc1" || Argv1 == "-cc1as" || Argv1 == "-cc1gen-reproducer")
+        return clang_main(Argc, Argv);
+    }
+  }
+
   StringRef Stem = sys::path::stem(ToolName);
   auto Is = [=](StringRef Tool) {
     auto IsImpl = [=](StringRef Stem) {
       auto I = Stem.rfind_insensitive(Tool);
       return I != StringRef::npos && (I + Tool.size() == Stem.size() ||
                                       !llvm::isAlnum(Stem[I + Tool.size()]));
     };
     for (StringRef S : {Stem, ToolName})
#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); }