[Clang][WIP] Allow renaming of "clang"

[nemanjai]

Summary

It is likely that at least some vendors would like the ability to rename the clang executable to a proprietary name. That would allow a clear differentiation between the upstream clang and a proprietary downstream version of clang on the same system.

I am not sure if there are vendors that already do this downstream but it seems like a useful capability to allow that to be parameterized in the CMake configuration and an upstream buildbot to be added that builds with a different name. We at IBM certainly desire this capability and are willing to convert one of our upstream buildbots to such a build.

This patch provides a new CMake macro CLANG_EXE_NAME that can be used to specify the name of the clang executable. Then the symlinks to it (i.e. clang-cl and clang++ will use that name and append the appropriate suffix). Furthermore, this patch updates test cases and utilities that use clang to use this name. The name is added to llvm-config so that it can be queried using llvm-config --clang-exe (which will return the full path with the correct name of the clang executable).

This is a work in progress because it is incomplete. Depending on the feedback on this review, the name change can affect the various clang-xx utilities, libclang... libraries, etc.

Please provide feedback if you think this is useful, not useful, a good/bad idea, good/bad technical direction etc.

[dblaikie]

Can't say I'm super enthusiastic about this (I assume the build already supports prefixes and suffixes, which I'd hope would be adequate - but presumably are not for your use case), though there's some, I think, related prior art: Sony folks (@probinson @jhenderson) have (or had at some point) different C++ language standard/version defaults than upstream and have maintained/made changes to upstream test cases that assume the upstream default version to not make that assumption (to have it explicit). So having some costs/changes upstream for downstream differences like this seems at least vaguely plausible to me.

I guess I might use this if it existed to have shorter names for my development build (rather than clang-tot maybe I could name it clot or something... ).

[jhenderson]

In D103125#2780936, @dblaikie wrote:

Can't say I'm super enthusiastic about this (I assume the build already supports prefixes and suffixes, which I'd hope would be adequate - but presumably are not for your use case), though there's some, I think, related prior art: Sony folks (@probinson @jhenderson) have (or had at some point) different C++ language standard/version defaults than upstream and have maintained/made changes to upstream test cases that assume the upstream default version to not make that assumption (to have it explicit). So having some costs/changes upstream for downstream differences like this seems at least vaguely plausible to me.

We do our executable renaming post build and lit testing. We do the renaming to nearly all our built tools, not just the clang (clang++ etc) family, e.g. the LLVM binutils like llvm-objdump becomes xxx-llvm-objdump, so unless the scope of this increases to include those, I'm not sure how useful it would be to us (and expanding the scope to other tools becomes problematic because there isn't a %clang equivalent for testing purposes for those other tools, so presumably would require significantly more updates?).

@probinson may have more thoughts on this though.

[probinson]

In D103125#2781239, @jhenderson wrote:

In D103125#2780936, @dblaikie wrote:

Can't say I'm super enthusiastic about this (I assume the build already supports prefixes and suffixes, which I'd hope would be adequate - but presumably are not for your use case), though there's some, I think, related prior art: Sony folks (@probinson @jhenderson) have (or had at some point) different C++ language standard/version defaults than upstream and have maintained/made changes to upstream test cases that assume the upstream default version to not make that assumption (to have it explicit). So having some costs/changes upstream for downstream differences like this seems at least vaguely plausible to me.

We do our executable renaming post build and lit testing. We do the renaming to nearly all our built tools, not just the clang (clang++ etc) family, e.g. the LLVM binutils like llvm-objdump becomes xxx-llvm-objdump, so unless the scope of this increases to include those, I'm not sure how useful it would be to us (and expanding the scope to other tools becomes problematic because there isn't a %clang equivalent for testing purposes for those other tools, so presumably would require significantly more updates?).

@probinson may have more thoughts on this though.

No, you've stated my thoughts almost exactly. If this became a generic prefixing thing, we'd want to apply it to clang, llvm tools, lld, etc.

Re the %clang equivalent, actually there is already tool-name substitution without the % in order to add the build-dir path to the tool name, so I *think* that can be made to work without having to update every test in existence. But, if the prefix isn't added universally, it's not really useful for us.

[echristo]

I'm also not a fan of this change. From a project perspective the binary is clang and while people may wish to change the name for their own product teams it seems like that onus should be on them.

[probinson]

In D103125#2782096, @echristo wrote:

I'm also not a fan of this change. From a project perspective the binary is clang and while people may wish to change the name for their own product teams it seems like that onus should be on them.

It occurs to me that there's precedent regarding prefixes, which is that you can rename/soft-link clang to have a triple embedded in the name (e.g., x86_64-pc-linux-clang) and then the driver will factor the prefix into default-target computations. But AFAIK there's no support for directly doing that renaming/linking in the build system. I agree with @echristo this properly belongs to the vendors not the project.

[nemanjai]

Thanks everyone for providing feedback on this. I posted this to gauge interest in the community for such a change. As it appears, the consensus seems to be that this isn't desired so I will abandon this change and vendors will continue with their homegrown solutions to this problem.

clang-tools-extra/clangd/test/lit.site.cfg.py.in

 @LIT_SITE_CFG_IN_HEADER@
 
 # Variables needed for common clang config.
 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.clang_tools_dir = "@CLANG_TOOLS_DIR@"
 config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.clang_libs_dir = "@CLANG_LIBS_DIR@"
 config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.python_executable = "@Python3_EXECUTABLE@"
+config.clang_exe_name = "@CLANG_EXE_NAME@"
 
 # Support substitution of the tools and libs dirs with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.clang_tools_dir = config.clang_tools_dir % lit_config.params
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
 except KeyError:

clang-tools-extra/test/CMakeLists.txt

set(CLANG_TOOLS_TEST_DEPS
   # Unit tests
   ExtraToolsUnitTests
 
   # clang-tidy tests require it.
   clang-resource-headers
 
   clang-tidy
   # Clang-tidy tests need clang for building modules.
-  clang
+  ${CLANG_EXE_NAME}
 )
 
 # Add lit test dependencies.
 set(LLVM_UTILS_DEPS
   FileCheck count not
 )
 foreach(dep ${LLVM_UTILS_DEPS})
   if(TARGET ${dep})

clang-tools-extra/test/lit.site.cfg.py.in

 @LIT_SITE_CFG_IN_HEADER@
 
 import sys
 
 config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.clang_tools_binary_dir = "@CLANG_TOOLS_BINARY_DIR@"
 config.clang_tools_dir = "@CLANG_TOOLS_DIR@"
 config.clang_libs_dir = "@SHLIBDIR@"
 config.python_executable = "@Python3_EXECUTABLE@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.clang_tidy_staticanalyzer = @CLANG_TIDY_ENABLE_STATIC_ANALYZER@
+config.clang_exe_name = "@CLANG_EXE_NAME@"
 
 # Support substitution of the tools and libs dirs with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.clang_tools_dir = config.clang_tools_dir % lit_config.params
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
 except KeyError:

clang/CMakeLists.txt

else()
     set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
   endif()
 
   option(LLVM_INSTALL_TOOLCHAIN_ONLY
     "Only include toolchain files in the 'install' target." OFF)
 
   option(LLVM_FORCE_USE_OLD_HOST_TOOLCHAIN
     "Set to ON to force using an old, unsupported host toolchain." OFF)
-  option(CLANG_ENABLE_BOOTSTRAP "Generate the clang bootstrap target" OFF)
+  option(CLANG_ENABLE_BOOTSTRAP "Generate the ${CLANG_EXE_NAME} bootstrap target" OFF)
   option(LLVM_ENABLE_LIBXML2 "Use libxml2 if available." ON)
 
   include(AddLLVM)
   include(TableGen)
   include(HandleLLVMOptions)
   include(VersionFromVCS)
   include(GetErrcMessages)
   include(LLVMDistributionSupport)

 
 include(CheckIncludeFile)
 check_include_file(sys/resource.h CLANG_HAVE_RLIMITS)
 
 set(CLANG_RESOURCE_DIR "" CACHE STRING
   "Relative directory from the Clang binary to its resource files.")
 
 set(C_INCLUDE_DIRS "" CACHE STRING
-  "Colon separated list of directories clang will search for headers.")
+  "Colon separated list of directories ${CLANG_EXE_NAME} will search for headers.")
 
 set(GCC_INSTALL_PREFIX "" CACHE PATH "Directory where gcc is installed." )
 set(DEFAULT_SYSROOT "" CACHE STRING
   "Default <path> to all compiler invocations for --sysroot=<path>." )
 
 set(ENABLE_LINKER_BUILD_ID OFF CACHE BOOL "pass --build-id to ld")
 
 set(ENABLE_X86_RELAX_RELOCATIONS ON CACHE BOOL
     "enable x86 relax relocations by default")
 
 set(CLANG_SPAWN_CC1 OFF CACHE BOOL
-    "Whether clang should use a new process for the CC1 invocation")
+    "Whether ${CLANG_EXE_NAME} should use a new process for the CC1 invocation")
 
 # TODO: verify the values against LangStandards.def?
 set(CLANG_DEFAULT_STD_C "" CACHE STRING
   "Default standard to use for C/ObjC code (IDENT from LangStandards.def, empty for platform default)")
 set(CLANG_DEFAULT_STD_CXX "" CACHE STRING
   "Default standard to use for C++/ObjC++ code (IDENT from LangStandards.def, empty for platform default)")
 
 set(CLANG_DEFAULT_LINKER "" CACHE STRING

 if( CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE )
   message(FATAL_ERROR "In-source builds are not allowed. "
 "Please create a directory and run cmake "
 "from there, passing the path to this source directory as the last argument. "
 "This process created the file `CMakeCache.txt' and the directory "
 "`CMakeFiles'. Please delete them.")
 endif()
 
+# If CLANG_EXE_NAME is specified, use it, otherwise make it clang
+if(NOT DEFINED CLANG_EXE_NAME)
+  set(CLANG_EXE_NAME "clang" CACHE STRING
+      "The name of the clang executable")
+endif()
 # If CLANG_VERSION_* is specified, use it, if not use LLVM_VERSION_*.
 if(NOT DEFINED CLANG_VERSION_MAJOR)
   set(CLANG_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
 endif()
 if(NOT DEFINED CLANG_VERSION_MINOR)
   set(CLANG_VERSION_MINOR ${LLVM_VERSION_MINOR})
 endif()
 if(NOT DEFINED CLANG_VERSION_PATCHLEVEL)

 
 add_definitions( -D_GNU_SOURCE )
 
 option(CLANG_BUILD_TOOLS
   "Build the Clang tools. If OFF, just generate build targets." ON)
 
 option(CLANG_ENABLE_ARCMT "Build ARCMT." ON)
 option(CLANG_ENABLE_STATIC_ANALYZER
-  "Include static analyzer in clang binary." ON)
+  "Include static analyzer in ${CLANG_EXE_NAME} binary." ON)
 
 option(CLANG_ENABLE_PROTO_FUZZER "Build Clang protobuf fuzzer." OFF)
 
 option(CLANG_ROUND_TRIP_CC1_ARGS
   "Round-trip command line arguments in -cc1." ${LLVM_ENABLE_ASSERTIONS})
 
 if(NOT CLANG_ENABLE_STATIC_ANALYZER AND CLANG_ENABLE_ARCMT)
   message(FATAL_ERROR "Cannot disable static analyzer while enabling ARCMT or Z3")
 endif()
 
 if(CLANG_ENABLE_ARCMT)
   set(CLANG_ENABLE_OBJC_REWRITER ON)
 endif()
 
 if (CLANG_ROUND_TRIP_CC1_ARGS)
   add_definitions(-DCLANG_ROUND_TRIP_CC1_ARGS=ON)
 endif()
 
 # Clang version information
 set(CLANG_EXECUTABLE_VERSION
     "${CLANG_VERSION_MAJOR}" CACHE STRING
-    "Major version number that will be appended to the clang executable name")
+    "Major version number that will be appended to the ${CLANG_EXE_NAME} executable name")
 set(LIBCLANG_LIBRARY_VERSION
     "${CLANG_VERSION_MAJOR}" CACHE STRING
     "Major version number that will be appended to the libclang library")
 mark_as_advanced(CLANG_EXECUTABLE_VERSION LIBCLANG_LIBRARY_VERSION)
 
 option(CLANG_INCLUDE_TESTS
        "Generate build targets for the Clang unit tests."
        ${LLVM_INCLUDE_TESTS})
if(APPLE)
   # default value get updated to the new default.
   if(CLANG_ORDER_FILE STREQUAL "")
     unset(CLANG_ORDER_FILE CACHE)
     unset(CLANG_ORDER_FILE)
   endif()
 
 
   set(CLANG_ORDER_FILE ${CMAKE_CURRENT_BINARY_DIR}/clang.order CACHE FILEPATH
-    "Order file to use when compiling clang in order to improve startup time (Darwin Only - requires ld64).")
+    "Order file to use when compiling ${CLANG_EXE_NAME} in order to improve startup time (Darwin Only - requires ld64).")
 
   if(NOT EXISTS ${CLANG_ORDER_FILE})
     string(FIND "${CLANG_ORDER_FILE}" "${CMAKE_CURRENT_BINARY_DIR}" PATH_START)
     if(PATH_START EQUAL 0)
       file(WRITE ${CLANG_ORDER_FILE} "\n")
     else()
       message(FATAL_ERROR "Specified order file '${CLANG_ORDER_FILE}' does not exist.")
     endif()
if(NOT LLVM_ENABLE_IDE)
       add_dependencies(install-clang-libraries-stripped install-${lib}-stripped)
     endif()
   endforeach()
 endif()
 
 add_subdirectory(cmake/modules)
 
 if(CLANG_STAGE)
-  message(STATUS "Setting current clang stage to: ${CLANG_STAGE}")
+  message(STATUS "Setting current ${CLANG_EXE_NAME} stage to: ${CLANG_STAGE}")
 endif()
 
 if (CLANG_ENABLE_BOOTSTRAP)
   include(ExternalProject)
 
-  add_custom_target(clang-bootstrap-deps DEPENDS clang)
+  add_custom_target(clang-bootstrap-deps DEPENDS ${CLANG_EXE_NAME})
 
   if(NOT CLANG_STAGE)
     set(CLANG_STAGE stage1)
   endif()
 
   string(REGEX MATCH "stage([0-9]*)" MATCHED_STAGE "${CLANG_STAGE}")
   if(MATCHED_STAGE)
     if(NOT LLVM_BUILD_INSTRUMENTED)
       math(EXPR STAGE_NUM "${CMAKE_MATCH_1} + 1")
       set(NEXT_CLANG_STAGE stage${STAGE_NUM})
     else()
       set(NEXT_CLANG_STAGE stage${CMAKE_MATCH_1})
     endif()
   else()
     set(NEXT_CLANG_STAGE bootstrap)
   endif()
 
   if(BOOTSTRAP_LLVM_BUILD_INSTRUMENTED)
     set(NEXT_CLANG_STAGE ${NEXT_CLANG_STAGE}-instrumented)
   endif()
-  message(STATUS "Setting next clang stage to: ${NEXT_CLANG_STAGE}")
+  message(STATUS "Setting next ${CLANG_EXE_NAME} stage to: ${NEXT_CLANG_STAGE}")
 
 
   set(STAMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/${NEXT_CLANG_STAGE}-stamps/)
   set(BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${NEXT_CLANG_STAGE}-bins/)
 
   if(BOOTSTRAP_LLVM_ENABLE_LLD)
     # adding lld to clang-bootstrap-deps without having it enabled in
     # LLVM_ENABLE_PROJECTS just generates a cryptic error message.
if(NOT LLVM_BUILD_INSTRUMENTED)
     if(TARGET compiler-rt)
       add_dependencies(clang-bootstrap-deps compiler-rt)
     endif()
     if(TARGET cxx-headers)
       add_dependencies(clang-bootstrap-deps cxx-headers)
     endif()
   endif()
 
-  set(C_COMPILER "clang")
-  set(CXX_COMPILER "clang++")
+  set(C_COMPILER "${CLANG_EXE_NAME}")
+  set(CXX_COMPILER "${CLANG_EXE_NAME}++")
   if(WIN32)
-    set(C_COMPILER "clang-cl.exe")
-    set(CXX_COMPILER "clang-cl.exe")
+    set(C_COMPILER "${CLANG_EXE_NAME}-cl.exe")
+    set(CXX_COMPILER "${CLANG_EXE_NAME}-cl.exe")
   endif()
 
   set(COMPILER_OPTIONS
     -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CXX_COMPILER}
     -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${C_COMPILER}
     -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${C_COMPILER}
     -DCMAKE_ASM_COMPILER_ID=Clang)
 

clang/include/clang/Config/config.h.cmake

 /* This generated file is for internal use. Do not include it from headers. */
 
 #ifdef CLANG_CONFIG_H
 #error config.h can only be included once
 #else
 #define CLANG_CONFIG_H
 
 /* Bug report URL. */
 #define BUG_REPORT_URL "${BUG_REPORT_URL}"
 
+/* Clang executable name. */
+#define CLANG_EXE_NAME "${CLANG_EXE_NAME}"
+
 /* Default linker to use. */
 #define CLANG_DEFAULT_LINKER "${CLANG_DEFAULT_LINKER}"
 
 /* Default C/ObjC standard to use. */
 #cmakedefine CLANG_DEFAULT_STD_C LangStandard::lang_${CLANG_DEFAULT_STD_C}
 
 /* Default C++/ObjC++ standard to use. */
 #cmakedefine CLANG_DEFAULT_STD_CXX LangStandard::lang_${CLANG_DEFAULT_STD_CXX}

clang/runtime/CMakeLists.txt

if(LLVM_BUILD_EXTERNAL_COMPILER_RT AND EXISTS ${COMPILER_RT_SRC_ROOT}/)
   if(TARGET cxx-headers)
     list(APPEND compiler_rt_configure_deps "cxx-headers")
   endif()
   if(LLVM_INCLUDE_TESTS)
     list(APPEND compiler_rt_configure_deps LLVMTestingSupport)
   endif()
 
   ExternalProject_Add(compiler-rt
-    DEPENDS llvm-config clang ${compiler_rt_configure_deps}
+    DEPENDS llvm-config ${CLANG_EXE_NAME} ${compiler_rt_configure_deps}
     PREFIX ${COMPILER_RT_PREFIX}
     SOURCE_DIR ${COMPILER_RT_SRC_ROOT}
     STAMP_DIR ${STAMP_DIR}
     BINARY_DIR ${BINARY_DIR}
     CMAKE_ARGS ${CLANG_COMPILER_RT_CMAKE_ARGS}
-               -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang
-               -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++
-               -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang
+               -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}
+               -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}++
+               -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}
                -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
                -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
                -DLLVM_CONFIG_PATH=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-config
                -DLLVM_LIT_ARGS=${LLVM_LIT_ARGS}
                -DCOMPILER_RT_OUTPUT_DIR=${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION}
                -DCOMPILER_RT_EXEC_OUTPUT_DIR=${LLVM_RUNTIME_OUTPUT_INTDIR}
                -DCOMPILER_RT_INSTALL_PATH:STRING=lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}
                -DCOMPILER_RT_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
ExternalProject_Add(compiler-rt
     )
 
   get_ext_project_build_command(run_clean_compiler_rt clean)
   ExternalProject_Add_Step(compiler-rt clean
     COMMAND ${run_clean_compiler_rt}
     COMMENT "Cleaning compiler-rt..."
     DEPENDEES configure
     DEPENDERS build
-    DEPENDS clang
+    DEPENDS ${CLANG_EXE_NAME}
     WORKING_DIRECTORY ${BINARY_DIR}
     )
 
   install(CODE "execute_process\(COMMAND \${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=\${CMAKE_INSTALL_PREFIX} -P ${BINARY_DIR}/cmake_install.cmake \)"
     COMPONENT compiler-rt)
 
   add_llvm_install_targets(install-compiler-rt
                            DEPENDS compiler-rt

clang/test/Analysis/check-analyzer-fixit.py

 
 
 def write_file(file_name, text):
     with open(file_name, 'w') as f:
         f.write(text)
 
 
 def run_test_once(args, extra_args):
+    clang_exe_name = args.clang_exe_name
     input_file_name = args.input_file_name
     temp_file_name = args.temp_file_name
     clang_analyzer_extra_args = extra_args
 
     file_name_with_extension = input_file_name
     _, extension = os.path.splitext(file_name_with_extension)
     if extension not in ['.c', '.hpp', '.m', '.mm']:
         extension = '.cpp'
def run_test_once(args, extra_args):
     cleaned_test = re.sub('// *CHECK-[A-Z0-9\-]*:[^\r\n]*', '//', input_text)
     write_file(temp_file_name, cleaned_test)
 
     original_file_name = temp_file_name + ".orig"
     write_file(original_file_name, cleaned_test)
 
     try:
         builtin_include_dir = subprocess.check_output(
-            ['clang', '-print-file-name=include'], stderr=subprocess.STDOUT).decode()
+            [clang_exe_name, '-print-file-name=include'], stderr=subprocess.STDOUT).decode()
     except subprocess.CalledProcessError as e:
         print('Cannot print Clang include directory: ' + e.output.decode())
 
     builtin_include_dir = os.path.normpath(builtin_include_dir)
 
-    args = (['clang', '-cc1', '-internal-isystem', builtin_include_dir,
+    args = ([clang_exe_name, '-cc1', '-internal-isystem', builtin_include_dir,
              '-nostdsysteminc', '-analyze', '-analyzer-constraints=range',
              '-analyzer-config', 'apply-fixits=true']
             + clang_analyzer_extra_args + ['-verify', temp_file_name])
 
     print('Running ' + str(args) + '...')
 
     try:
         clang_analyzer_output = \
try:
             stderr=subprocess.STDOUT)
     except subprocess.CalledProcessError as e:
         print('FileCheck failed:\n' + e.output.decode())
         raise
 
 
 def main():
     parser = argparse.ArgumentParser()
+    parser.add_argument('clang_exe_name')
     parser.add_argument('input_file_name')
     parser.add_argument('temp_file_name')
 
     args, extra_args = parser.parse_known_args()
     run_test_once(args, extra_args)
 
 
 if __name__ == '__main__':
     main()

clang/test/Analysis/scan-build/cxx-name.test

 REQUIRES: shell
 
 RUN: %scan-build sh -c 'echo "CLANG_CXX=/$(basename "$CLANG_CXX")/"' | FileCheck %s
 
 Check that scan-build sets the CLANG_CXX environment variable (meant to be
 consumed by ccc-analyzer) to an appropriate pathname for the clang++ executable,
 derived from the pathname of the clang executable:
 
-CHECK: CLANG_CXX=/clang++{{(\.exe)?}}/
+CHECK: Using {{.*}}/[[CLANG:[^ -]+]]
+CHECK: CLANG_CXX=/[[CLANG]]++/

clang/test/CMakeLists.txt

 option(CLANG_TEST_USE_VG "Run Clang tests under Valgrind" OFF)
 if(CLANG_TEST_USE_VG)
   set(CLANG_TEST_EXTRA_ARGS ${CLANG_TEST_EXTRA_ARGS} "--vg")
 endif ()
 
 list(APPEND CLANG_TEST_DEPS
   apinotes-test
   c-index-test
-  clang
+  ${CLANG_EXE_NAME}
   clang-resource-headers
   clang-format
   clang-tblgen
   clang-offload-bundler
   clang-import-test
   clang-rename
   clang-refactor
   clang-repl

clang/test/Driver/baremetal.cpp

 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target armv6m-none-eabi \
 // RUN:     -T semihosted.lds \
 // RUN:     -L some/directory/user/asked/for \
 // RUN:     --sysroot=%S/Inputs/baremetal_arm \
 // RUN:   | FileCheck --check-prefix=CHECK-V6M-C %s
-// CHECK-V6M-C: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}clang{{.*}}" "-cc1" "-triple" "thumbv6m-none-unknown-eabi"
+// CHECK-V6M-C: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}{{[^/^\\]+}}" "-cc1" "-triple" "thumbv6m-none-unknown-eabi"
 // CHECK-V6M-C-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-V6M-C-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-V6M-C-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECk-V6M-C-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}include"
 // CHECK-V6M-C-SAME: "-x" "c++" "{{.*}}baremetal.cpp"
 // CHECK-V6M-C-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic"
 // CHECK-V6M-C-SAME: "-T" "semihosted.lds" "-Lsome{{[/\\]+}}directory{{[/\\]+}}user{{[/\\]+}}asked{{[/\\]+}}for"
 // CHECK-V6M-C-SAME: "-L[[SYSROOT:[^"]+]]{{[/\\]+}}lib"

 // RUN:   | FileCheck %s --check-prefix=CHECK-SYSROOT-INC
 // CHECK-SYSROOT-INC-NOT: "-internal-isystem" "include"
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target riscv64-unknown-elf \
 // RUN:     -L some/directory/user/asked/for \
 // RUN:     --sysroot=%S/Inputs/basic_riscv64_tree/riscv64-unknown-elf \
 // RUN:   | FileCheck --check-prefix=CHECK-RV64 %s
-// CHECK-RV64: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}clang{{.*}}" "-cc1" "-triple" "riscv64-unknown-unknown-elf"
+// CHECK-RV64: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}{{[^/^\\]+}}" "-cc1" "-triple" "riscv64-unknown-unknown-elf"
 // CHECK-RV64-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-RV64-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-RV64-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECk-RV64-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}include"
 // CHECK-RV64-SAME: "-x" "c++" "{{.*}}baremetal.cpp"
 // CHECK-RV64-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic"
 // CHECK-RV64-SAME: "-Lsome{{[/\\]+}}directory{{[/\\]+}}user{{[/\\]+}}asked{{[/\\]+}}for"
 // CHECK-RV64-SAME: "-L[[SYSROOT:[^"]+]]{{[/\\]+}}lib"

 // CHECK-RV64-LIBSTDCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-riscv64"
 // CHECK-RV64-LIBSTDCXX-SAME: "-o" "{{.*}}.o"
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target riscv32-unknown-elf \
 // RUN:     -L some/directory/user/asked/for \
 // RUN:     --sysroot=%S/Inputs/basic_riscv32_tree/riscv32-unknown-elf \
 // RUN:   | FileCheck --check-prefix=CHECK-RV32 %s
-// CHECK-RV32: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}clang{{.*}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
+// CHECK-RV32: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}{{[^/^\\]+}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
 // CHECK-RV32-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-RV32-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-RV32-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECK-RV32-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}include"
 // CHECK-RV32-SAME: "-x" "c++" "{{.*}}baremetal.cpp"
 // CHECK-RV32-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic"
 // CHECK-RV32-SAME: "-Lsome{{[/\\]+}}directory{{[/\\]+}}user{{[/\\]+}}asked{{[/\\]+}}for"
 // CHECK-RV32-SAME: "-L[[SYSROOT:[^"]+]]{{[/\\]+}}lib"

 // RUN:   | FileCheck --check-prefix=CHECK-RV64FD %s
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target riscv64-unknown-elf \
 // RUN:     -march=rv64gc -mabi=lp64d \
 // RUN:     --sysroot=%S/Inputs/basic_riscv64_tree/riscv64-unknown-elf \
 // RUN:   | FileCheck --check-prefix=CHECK-RV64FD %s
 
-// CHECK-RV64FD: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}clang{{.*}}" "-cc1" "-triple" "riscv64-unknown-unknown-elf"
+// CHECK-RV64FD: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}{{[^/^\\]+}}" "-cc1" "-triple" "riscv64-unknown-unknown-elf"
 // CHECK-RV64FD-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-RV64FD-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-RV64FD-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv64imafdc{{[/\\]+}}lp64d{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECk-RV64FD-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv64imafdc{{[/\\]+}}lp64d{{[/\\]+}}include"
 // CHECK-RV64FD-SAME: "-x" "c++" "{{.*}}baremetal.cpp"
 // CHECK-RV64FD-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic"
 // CHECK-RV64FD-SAME: "-L[[SYSROOT:[^"]+]]{{[/\\]+}}rv64imafdc{{[/\\]+}}lp64d{{[/\\]+}}lib"
 // CHECK-RV64FD-SAME: "-L[[RESOURCE_DIR:[^"]+]]{{[/\\]+}}lib{{[/\\]+}}baremetal{{[/\\]+}}rv64imafdc{{[/\\]+}}lp64d"
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target riscv32-unknown-elf \
 // RUN:     -march=rv32i -mabi=ilp32 \
 // RUN:     --sysroot=%S/Inputs/basic_riscv32_tree/riscv32-unknown-elf \
 // RUN:   | FileCheck --check-prefix=CHECK-RV32I %s
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target riscv32-unknown-elf \
 // RUN:     -march=rv32ic -mabi=ilp32 \
 // RUN:     --sysroot=%S/Inputs/basic_riscv32_tree/riscv32-unknown-elf \
 // RUN:   | FileCheck --check-prefix=CHECK-RV32I %s
 
-// CHECK-RV32I: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}clang{{.*}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
+// CHECK-RV32I: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}{{[^/^\\]+}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
 // CHECK-RV32I-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-RV32I-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-RV32I-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv32i{{[/\\]+}}ilp32{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECK-RV32I-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv32i{{[/\\]+}}ilp32{{[/\\]+}}include"
 // CHECK-RV32I-SAME: "-x" "c++" "{{.*}}baremetal.cpp"
 // CHECK-RV32I-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic"
 // CHECK-RV32I-SAME: "-L[[SYSROOT:[^"]+]]{{[/\\]+}}rv32i{{[/\\]+}}ilp32{{[/\\]+}}lib"
 // CHECK-RV32I-SAME: "-L[[RESOURCE_DIR:[^"]+]]{{[/\\]+}}lib{{[/\\]+}}baremetal{{[/\\]+}}rv32i{{[/\\]+}}ilp32"
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target riscv32-unknown-elf \
 // RUN:     -march=rv32im -mabi=ilp32 \
 // RUN:     --sysroot=%S/Inputs/basic_riscv32_tree/riscv32-unknown-elf \
 // RUN:   | FileCheck --check-prefix=CHECK-RV32IM %s
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target riscv32-unknown-elf \
 // RUN:     -march=rv32imc -mabi=ilp32 \
 // RUN:     --sysroot=%S/Inputs/basic_riscv32_tree/riscv32-unknown-elf \
 // RUN:   | FileCheck --check-prefix=CHECK-RV32IM %s
 
-// CHECK-RV32IM: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}clang{{.*}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
+// CHECK-RV32IM: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}{{[^/^\\]+}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
 // CHECK-RV32IM-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-RV32IM-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-RV32IM-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv32im{{[/\\]+}}ilp32{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECK-RV32IM-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv32im{{[/\\]+}}ilp32{{[/\\]+}}include"
 // CHECK-RV32IM-SAME: "-x" "c++" "{{.*}}baremetal.cpp"
 // CHECK-RV32IM-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic"
 // CHECK-RV32IM-SAME: "-L[[SYSROOT:[^"]+]]{{[/\\]+}}rv32im{{[/\\]+}}ilp32{{[/\\]+}}lib"
 // CHECK-RV32IM-SAME: "-L[[RESOURCE_DIR:[^"]+]]{{[/\\]+}}lib{{[/\\]+}}baremetal{{[/\\]+}}rv32im{{[/\\]+}}ilp32"
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target riscv32-unknown-elf \
 // RUN:     -march=rv32iac -mabi=ilp32 \
 // RUN:     --sysroot=%S/Inputs/basic_riscv32_tree/riscv32-unknown-elf \
 // RUN:   | FileCheck --check-prefix=CHECK-RV32IAC %s
 
-// CHECK-RV32IAC: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}clang{{.*}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
+// CHECK-RV32IAC: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}{{[^/^\\]+}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
 // CHECK-RV32IAC-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-RV32IAC-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-RV32IAC-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv32iac{{[/\\]+}}ilp32{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECK-RV32IAC-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv32iac{{[/\\]+}}ilp32{{[/\\]+}}include"
 // CHECK-RV32IAC-SAME: "-x" "c++" "{{.*}}baremetal.cpp"
 // CHECK-RV32IAC-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic"
 // CHECK-RV32IAC-SAME: "-L[[SYSROOT:[^"]+]]{{[/\\]+}}rv32iac{{[/\\]+}}ilp32{{[/\\]+}}lib"
 // CHECK-RV32IAC-SAME: "-L[[RESOURCE_DIR:[^"]+]]{{[/\\]+}}lib{{[/\\]+}}baremetal{{[/\\]+}}rv32iac{{[/\\]+}}ilp32"

 // RUN:   | FileCheck --check-prefix=CHECK-RV32IMAFC %s
 
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     -target riscv32-unknown-elf \
 // RUN:     -march=rv32gc -mabi=ilp32f \
 // RUN:     --sysroot=%S/Inputs/basic_riscv32_tree/riscv32-unknown-elf \
 // RUN:   | FileCheck --check-prefix=CHECK-RV32IMAFC %s
 
-// CHECK-RV32IMAFC: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}clang{{.*}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
+// CHECK-RV32IMAFC: "[[PREFIX_DIR:.*]]{{[/\\]+}}{{[^/^\\]+}}{{[/\\]+}}{{[^/^\\]+}}" "-cc1" "-triple" "riscv32-unknown-unknown-elf"
 // CHECK-RV32IMAFC-SAME: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]"
 // CHECK-RV32IMAFC-SAME: "-isysroot" "[[SYSROOT:[^"]*]]"
 // CHECK-RV32IMAFC-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv32imafc{{[/\\]+}}ilp32f{{[/\\]+}}include{{[/\\]+}}c++{{[/\\]+}}v1"
 // CHECK-RV32IMAFC-SAME: "-internal-isystem" "[[SYSROOT]]{{[/\\]+}}rv32imafc{{[/\\]+}}ilp32f{{[/\\]+}}include"
 // CHECK-RV32IMAFC-SAME: "-x" "c++" "{{.*}}baremetal.cpp"
 // CHECK-RV32IMAFC-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic"
 // CHECK-RV32IMAFC-SAME: "-L[[SYSROOT:[^"]+]]{{[/\\]+}}rv32imafc{{[/\\]+}}ilp32f{{[/\\]+}}lib"
 // CHECK-RV32IMAFC-SAME: "-L[[RESOURCE_DIR:[^"]+]]{{[/\\]+}}lib{{[/\\]+}}baremetal{{[/\\]+}}rv32imafc{{[/\\]+}}ilp32f"

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

 // RUN: %clangxx -S -ftime-trace -ftime-trace-granularity=0 -o %T/check-time-trace %s
 // RUN: cat %T/check-time-trace.json \
-// RUN:   | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=2)' \
+// RUN:   | %python -c 'import json, sys; json.dump(json.loads(sys.stdin.read()), sys.stdout, sort_keys=True, indent=">>")' \
 // RUN:   | FileCheck %s
 
 // CHECK:      "beginningOfTime": {{[0-9]{16},}}
 // CHECK-NEXT: "traceEvents": [
 // 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":
 // 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.cfg.py

if config.clang_staticanalyzer:
 
     if config.clang_staticanalyzer_z3 == '1':
         config.available_features.add('z3')
 
     check_analyzer_fixit_path = os.path.join(
         config.test_source_root, "Analysis", "check-analyzer-fixit.py")
     config.substitutions.append(
         ('%check_analyzer_fixit',
-         '"%s" %s' % (config.python_executable, check_analyzer_fixit_path)))
+         '"%s" %s "%s"' % (config.python_executable, check_analyzer_fixit_path,
+                           config.clang_exe_name)))
 
 llvm_config.add_tool_substitutions(tools, tool_dirs)
 
 config.substitutions.append(
     ('%hmaptool', "'%s' %s" % (config.python_executable,
                              os.path.join(config.clang_tools_dir, 'hmaptool'))))
 
 config.substitutions.append(('%host_cc', config.host_cc))

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

 config.enable_backtrace = @ENABLE_BACKTRACES@
 config.enable_experimental_new_pass_manager = @LLVM_ENABLE_NEW_PASS_MANAGER@
 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 = @LLVM_ENABLE_PLUGINS@
 config.clang_vendor_uti = "@CLANG_VENDOR_UTI@"
+config.clang_exe_name = "@CLANG_EXE_NAME@"
 
 # Support substitution of the tools and libs dirs with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.clang_tools_dir = config.clang_tools_dir % lit_config.params
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_shlib_dir = config.llvm_shlib_dir % lit_config.params
     config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params

clang/test/utils/update_cc_test_checks/lit.local.cfg

 import os
 
 import lit.util
 
 # python 2.7 backwards compatibility
 try:
     from shlex import quote as shell_quote
 except ImportError:
     from pipes import quote as shell_quote
 
 
 config.test_format = lit.formats.ShTest(execute_external=False)
 config.suffixes = ['.test']
 
-clang_path = os.path.join(config.clang_tools_dir, 'clang')
+clang_path = os.path.join(config.clang_tools_dir, config.clang_exe_name)
 extra_args = '--clang ' + shell_quote(clang_path)
 opt_path = os.path.join(config.llvm_tools_dir, 'opt')
 extra_args += ' --opt ' + shell_quote(opt_path)
 script_path = os.path.join(config.llvm_src_root, 'utils',
                            'update_cc_test_checks.py')
 assert os.path.isfile(script_path)
 config.substitutions.append(
     ('%update_cc_test_checks', "%s %s %s" % (
         shell_quote(config.python_executable), shell_quote(script_path),
         extra_args)))
 config.substitutions.append(
     ('%clang_tools_dir', shell_quote(config.clang_tools_dir)))

clang/tools/clang-offload-bundler/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS Object Support)
 
 add_clang_tool(clang-offload-bundler
   ClangOffloadBundler.cpp
   
   DEPENDS
   intrinsics_gen
   )
 
 set(CLANG_OFFLOAD_BUNDLER_LIB_DEPS
   clangBasic
   )
   
-add_dependencies(clang clang-offload-bundler)
+add_dependencies(${CLANG_EXE_NAME} clang-offload-bundler)
 
 clang_target_link_libraries(clang-offload-bundler
   PRIVATE
   ${CLANG_OFFLOAD_BUNDLER_LIB_DEPS}
   )

clang/tools/clang-offload-wrapper/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS BitWriter Core Support TransformUtils)
 
 add_clang_tool(clang-offload-wrapper
   ClangOffloadWrapper.cpp
 
   DEPENDS
   intrinsics_gen
   )
 
 set(CLANG_OFFLOAD_WRAPPER_LIB_DEPS
   clangBasic
   )
 
-add_dependencies(clang clang-offload-wrapper)
+add_dependencies(${CLANG_EXE_NAME} clang-offload-wrapper)
 
 clang_target_link_libraries(clang-offload-wrapper
   PRIVATE
   ${CLANG_OFFLOAD_WRAPPER_LIB_DEPS}
   )

clang/tools/driver/CMakeLists.txt

set( LLVM_LINK_COMPONENTS
   ObjCARCOpts
   Option
   ScalarOpts
   Support
   TransformUtils
   Vectorize
   )
 
-option(CLANG_PLUGIN_SUPPORT "Build clang with plugin support" ON)
+option(CLANG_PLUGIN_SUPPORT "Build ${CLANG_EXE_NAME} with plugin support" ON)
 
 # Support plugins.
 if(CLANG_PLUGIN_SUPPORT)
   set(support_plugins SUPPORT_PLUGINS)
 endif()
 
-add_clang_tool(clang
+add_clang_tool(${CLANG_EXE_NAME}
   driver.cpp
   cc1_main.cpp
   cc1as_main.cpp
   cc1gen_reproducer_main.cpp
 
   DEPENDS
   intrinsics_gen
   ${support_plugins}
   )
 
-clang_target_link_libraries(clang
+clang_target_link_libraries(${CLANG_EXE_NAME}
   PRIVATE
   clangBasic
   clangCodeGen
   clangDriver
   clangFrontend
   clangFrontendTool
   clangSerialization
   )
 
 if(WIN32 AND NOT CYGWIN)
   # Prevent versioning if the buildhost is targeting for Win32.
 else()
-  set_target_properties(clang PROPERTIES VERSION ${CLANG_EXECUTABLE_VERSION})
+  set_target_properties(${CLANG_EXE_NAME} PROPERTIES VERSION ${CLANG_EXECUTABLE_VERSION})
 endif()
 
 # Support plugins.
 if(CLANG_PLUGIN_SUPPORT)
-  export_executable_symbols_for_plugins(clang)
+  export_executable_symbols_for_plugins(${CLANG_EXE_NAME})
 endif()
 
-add_dependencies(clang clang-resource-headers)
+add_dependencies(${CLANG_EXE_NAME} clang-resource-headers)
 
 if(NOT CLANG_LINKS_TO_CREATE)
-  set(CLANG_LINKS_TO_CREATE clang++ clang-cl clang-cpp)
+  set(CLANG_LINKS_TO_CREATE ${CLANG_EXE_NAME}++ ${CLANG_EXE_NAME}-cl ${CLANG_EXE_NAME}-cpp)
 endif()
 
 foreach(link ${CLANG_LINKS_TO_CREATE})
-  add_clang_symlink(${link} clang)
+  add_clang_symlink(${link} ${CLANG_EXE_NAME})
 endforeach()
 
 # Configure plist creation for OS X.
 set (TOOL_INFO_PLIST "Info.plist" CACHE STRING "Plist name")
 if (APPLE)
   if (CLANG_VENDOR)
-    set(TOOL_INFO_NAME "${CLANG_VENDOR} clang")
+    set(TOOL_INFO_NAME "${CLANG_VENDOR} ${CLANG_EXE_NAME}")
   else()
-    set(TOOL_INFO_NAME "clang")
+    set(TOOL_INFO_NAME "${CLANG_EXE_NAME}")
   endif()
 
   set(TOOL_INFO_UTI "${CLANG_VENDOR_UTI}")
   set(TOOL_INFO_VERSION "${CLANG_VERSION}")
   set(TOOL_INFO_BUILD_VERSION "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}")
 
   set(TOOL_INFO_PLIST_OUT "${CMAKE_CURRENT_BINARY_DIR}/${TOOL_INFO_PLIST}")
-  target_link_libraries(clang
+  target_link_libraries(${CLANG_EXE_NAME}
     PRIVATE
     "-Wl,-sectcreate,__TEXT,__info_plist,${TOOL_INFO_PLIST_OUT}")
   configure_file("${TOOL_INFO_PLIST}.in" "${TOOL_INFO_PLIST_OUT}" @ONLY)
 
   set(TOOL_INFO_UTI)
   set(TOOL_INFO_NAME)
   set(TOOL_INFO_VERSION)
   set(TOOL_INFO_BUILD_VERSION)
if(CLANG_ORDER_FILE AND
   # Passing an empty order file disables some linker layout optimizations.
   # To work around this and enable workflows for re-linking when the order file
   # changes we check during configuration if the file is empty, and make it a
   # configuration dependency.
   file(READ ${CLANG_ORDER_FILE} ORDER_FILE LIMIT 20)
   if("${ORDER_FILE}" STREQUAL "\n")
     set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${CLANG_ORDER_FILE})
   elseif(LINKER_ORDER_FILE_WORKS)
-    target_link_libraries(clang PRIVATE ${LINKER_ORDER_FILE_OPTION})
-    set_target_properties(clang PROPERTIES LINK_DEPENDS ${CLANG_ORDER_FILE})
+    target_link_libraries(${CLANG_EXE_NAME} PRIVATE ${LINKER_ORDER_FILE_OPTION})
+    set_target_properties(${CLANG_EXE_NAME} PROPERTIES LINK_DEPENDS ${CLANG_ORDER_FILE})
   endif()
 endif()

clang/utils/perf-training/CMakeLists.txt

set(CLANG_PGO_TRAINING_DATA "${CMAKE_CURRENT_SOURCE_DIR}" CACHE PATH
   )
 
 if(LLVM_BUILD_INSTRUMENTED)
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/pgo-data/lit.site.cfg
     )
 
-  add_lit_testsuite(generate-profraw "Generating clang PGO data"
+  add_lit_testsuite(generate-profraw "Generating ${CLANG_EXE_NAME} PGO data"
     ${CMAKE_CURRENT_BINARY_DIR}/pgo-data/
     EXCLUDE_FROM_CHECK_ALL
-    DEPENDS clang clear-profraw
+    DEPENDS ${CLANG_EXE_NAME} clear-profraw
     )
 
   add_custom_target(clear-profraw
     COMMAND "${Python3_EXECUTABLE}" ${CMAKE_CURRENT_SOURCE_DIR}/perf-helper.py clean ${CMAKE_CURRENT_BINARY_DIR} profraw
     COMMENT "Clearing old profraw data")
 
   if(NOT LLVM_PROFDATA)
     find_program(LLVM_PROFDATA llvm-profdata)

 
 find_program(DTRACE dtrace)
 if(APPLE AND DTRACE)
   configure_lit_site_cfg(
     ${CMAKE_CURRENT_SOURCE_DIR}/order-files.lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/order-files/lit.site.cfg
     )
 
-  add_lit_testsuite(generate-dtrace-logs "Generating clang dtrace data"
+  add_lit_testsuite(generate-dtrace-logs "Generating ${CLANG_EXE_NAME} dtrace data"
     ${CMAKE_CURRENT_BINARY_DIR}/order-files/
     EXCLUDE_FROM_CHECK_ALL
     ARGS -j 1
-    DEPENDS clang clear-dtrace-logs
+    DEPENDS ${CLANG_EXE_NAME} clear-dtrace-logs
     )
 
   add_custom_target(clear-dtrace-logs
     COMMAND "${Python3_EXECUTABLE}" ${CMAKE_CURRENT_SOURCE_DIR}/perf-helper.py clean ${CMAKE_CURRENT_BINARY_DIR} dtrace
     COMMENT "Clearing old dtrace data")
 
   if(NOT CLANG_ORDER_FILE)
-    message(FATAL_ERROR "Output clang order file is not set")
+    message(FATAL_ERROR "Output ${CLANG_EXE_NAME} order file is not set")
   endif()
 
   add_custom_target(generate-order-file
-    COMMAND "${Python3_EXECUTABLE}" ${CMAKE_CURRENT_SOURCE_DIR}/perf-helper.py gen-order-file --binary $<TARGET_FILE:clang> --output ${CLANG_ORDER_FILE} ${CMAKE_CURRENT_BINARY_DIR}
+    COMMAND "${Python3_EXECUTABLE}" ${CMAKE_CURRENT_SOURCE_DIR}/perf-helper.py gen-order-file --binary $<TARGET_FILE:${CLANG_EXE_NAME}> --output ${CLANG_ORDER_FILE} ${CMAKE_CURRENT_BINARY_DIR}
     COMMENT "Generating order file"
     DEPENDS generate-dtrace-logs)
 endif()

compiler-rt/cmake/Modules/AddCompilerRT.cmake

function(add_compiler_rt_test test_suite test_name arch)
   file(MAKE_DIRECTORY "${output_dir}")
   set(output_bin "${output_dir}/${test_name}")
   if(MSVC)
     set(output_bin "${output_bin}.exe")
   endif()
 
   # Use host compiler in a standalone build, and just-built Clang otherwise.
   if(NOT COMPILER_RT_STANDALONE_BUILD)
-    list(APPEND TEST_DEPS clang)
+    list(APPEND TEST_DEPS ${CLANG_EXE_NAME})
   endif()
 
   get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS)
   list(APPEND TEST_LINK_FLAGS ${TARGET_LINK_FLAGS})
 
   # If we're not on MSVC, include the linker flags from CMAKE but override them
   # with the provided link flags. This ensures that flags which are required to
   # link programs at all are included, but the changes needed for the test

compiler-rt/cmake/base-config-ix.cmake

if (CMAKE_HOST_WIN32)
       set(_host_executable_suffix ".exe")
     else()
       set(_host_executable_suffix "")
     endif()
   else()
     set(_host_executable_suffix ${CMAKE_EXECUTABLE_SUFFIX})
   endif()
   set(COMPILER_RT_TEST_COMPILER
-    ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang${_host_executable_suffix})
+    ${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}${_host_executable_suffix})
   set(COMPILER_RT_TEST_CXX_COMPILER
-    ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++${_host_executable_suffix})
+    ${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}++${_host_executable_suffix})
 else()
     # Take output dir and install path from the user.
   set(COMPILER_RT_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE PATH
     "Path where built compiler-rt libraries should be stored.")
   set(COMPILER_RT_EXEC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/bin CACHE PATH
     "Path where built compiler-rt executables should be stored.")
   set(COMPILER_RT_INSTALL_PATH ${CMAKE_INSTALL_PREFIX} CACHE PATH
     "Path where built compiler-rt libraries should be installed.")
   option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests." OFF)
   option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered" OFF)
   # Use a host compiler to compile/link tests.
   set(COMPILER_RT_TEST_COMPILER ${CMAKE_C_COMPILER} CACHE PATH "Compiler to use for testing")
   set(COMPILER_RT_TEST_CXX_COMPILER ${CMAKE_CXX_COMPILER} CACHE PATH "C++ Compiler to use for testing")
 endif()
 
-if("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang[+]*$")
+if("${COMPILER_RT_TEST_COMPILER}" MATCHES "${CLANG_EXE_NAME}[+]*$")
   set(COMPILER_RT_TEST_COMPILER_ID Clang)
 elseif("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang.*.exe$")
   set(COMPILER_RT_TEST_COMPILER_ID Clang)
 else()
   set(COMPILER_RT_TEST_COMPILER_ID GNU)
 endif()
 
 if(NOT DEFINED COMPILER_RT_OS_DIR)

llvm/cmake/modules/LLVMExternalProjectUtils.cmake

if(NOT ARG_TARGET_TRIPLE)
     set(target_triple ${LLVM_DEFAULT_TARGET_TRIPLE})
   else()
     set(target_triple ${ARG_TARGET_TRIPLE})
   endif()
 
   is_msvc_triple(is_msvc_target ${target_triple})
 
   if(NOT ARG_TOOLCHAIN_TOOLS)
-    set(ARG_TOOLCHAIN_TOOLS clang)
+    set(ARG_TOOLCHAIN_TOOLS ${CLANG_EXE_NAME})
     # AIX 64-bit XCOFF and big AR format is not yet supported in some of these tools.
     if(NOT _cmake_system_name STREQUAL AIX)
       list(APPEND ARG_TOOLCHAIN_TOOLS lld llvm-ar llvm-ranlib llvm-nm llvm-objdump)
       if(_cmake_system_name STREQUAL Darwin)
         list(APPEND ARG_TOOLCHAIN_TOOLS llvm-libtool-darwin llvm-lipo)
       elseif(is_msvc_target)
         list(APPEND ARG_TOOLCHAIN_TOOLS llvm-lib)
       else()
if(TARGET ${lib})
       list(APPEND RUNTIME_LIBRARIES ${lib})
     endif()
   endforeach()
 
   if(ARG_ALWAYS_CLEAN)
     set(always_clean clean)
   endif()
 
-  list(FIND TOOLCHAIN_TOOLS clang FOUND_CLANG)
+  list(FIND TOOLCHAIN_TOOLS ${CLANG_EXE_NAME} FOUND_CLANG)
   if(FOUND_CLANG GREATER -1)
     set(CLANG_IN_TOOLCHAIN On)
   endif()
 
   if(RUNTIME_LIBRARIES AND CLANG_IN_TOOLCHAIN)
     list(APPEND TOOLCHAIN_BINS ${RUNTIME_LIBRARIES})
   endif()
 
foreach(variableName ${variableNames})
           -D${variableName}=${value})
       endif()
     endforeach()
   endforeach()
 
   if(ARG_USE_TOOLCHAIN AND NOT CMAKE_CROSSCOMPILING)
     if(CLANG_IN_TOOLCHAIN)
       if(is_msvc_target)
-        set(compiler_args -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang-cl${CMAKE_EXECUTABLE_SUFFIX}
-                          -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang-cl${CMAKE_EXECUTABLE_SUFFIX}
-                          -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang-cl${CMAKE_EXECUTABLE_SUFFIX})
+        set(compiler_args -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}-cl${CMAKE_EXECUTABLE_SUFFIX}
+                          -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}-cl${CMAKE_EXECUTABLE_SUFFIX}
+                          -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}-cl${CMAKE_EXECUTABLE_SUFFIX})
       else()
-        set(compiler_args -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang${CMAKE_EXECUTABLE_SUFFIX}
-                          -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++${CMAKE_EXECUTABLE_SUFFIX}
-                          -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang${CMAKE_EXECUTABLE_SUFFIX})
+        set(compiler_args -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}${CMAKE_EXECUTABLE_SUFFIX}
+                          -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}++${CMAKE_EXECUTABLE_SUFFIX}
+                          -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/${CLANG_EXE_NAME}${CMAKE_EXECUTABLE_SUFFIX})
       endif()
     endif()
     if(lld IN_LIST TOOLCHAIN_TOOLS)
       if(is_msvc_target)
         list(APPEND compiler_args -DCMAKE_LINKER=${LLVM_RUNTIME_OUTPUT_INTDIR}/lld-link${CMAKE_EXECUTABLE_SUFFIX})
       elseif(NOT _cmake_system_name STREQUAL Darwin)
         list(APPEND compiler_args -DCMAKE_LINKER=${LLVM_RUNTIME_OUTPUT_INTDIR}/ld.lld${CMAKE_EXECUTABLE_SUFFIX})
       endif()
ExternalProject_Add(${name}
     ${exclude}
     CMAKE_ARGS ${${nameCanon}_CMAKE_ARGS}
                ${compiler_args}
                -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
                ${sysroot_arg}
                -DLLVM_BINARY_DIR=${PROJECT_BINARY_DIR}
                -DLLVM_CONFIG_PATH=${llvm_config_path}
                -DLLVM_ENABLE_WERROR=${LLVM_ENABLE_WERROR}
+               -DCLANG_EXE_NAME=${CLANG_EXE_NAME}
                -DLLVM_HOST_TRIPLE=${LLVM_HOST_TRIPLE}
                -DLLVM_HAVE_LINK_VERSION_SCRIPT=${LLVM_HAVE_LINK_VERSION_SCRIPT}
                -DLLVM_USE_RELATIVE_PATHS_IN_DEBUG_INFO=${LLVM_USE_RELATIVE_PATHS_IN_DEBUG_INFO}
                -DLLVM_USE_RELATIVE_PATHS_IN_FILES=${LLVM_USE_RELATIVE_PATHS_IN_FILES}
                -DLLVM_LIT_ARGS=${LLVM_LIT_ARGS}
                -DLLVM_SOURCE_PREFIX=${LLVM_SOURCE_PREFIX}
                -DPACKAGE_VERSION=${PACKAGE_VERSION}
                -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}

llvm/include/llvm/Config/config.h.cmake

 #ifndef CONFIG_H
 #define CONFIG_H
 
 // Include this header only under the llvm source tree.
 // This is a private header.
 
 /* Exported configuration */
 #include "llvm/Config/llvm-config.h"
 
 /* Bug report URL. */
 #define BUG_REPORT_URL "${BUG_REPORT_URL}"
 
+/* Clang executable name. */
+#define CLANG_EXE_NAME "${CLANG_EXE_NAME}"
+
 /* Define to 1 to enable backtraces, and to 0 otherwise. */
 #cmakedefine01 ENABLE_BACKTRACES
 
 /* Define to 1 to enable crash overrides, and to 0 otherwise. */
 #cmakedefine01 ENABLE_CRASH_OVERRIDES
 
 /* Define to 1 to enable crash memory dumps, and to 0 otherwise. */
 #cmakedefine01 LLVM_ENABLE_CRASH_DUMPS

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

 config.host_arch = "@HOST_ARCH@"
 config.have_opt_viewer_modules = @LLVM_HAVE_OPT_VIEWER_MODULES@
 config.libcxx_used = @LLVM_LIBCXX_USED@
 config.has_plugins = @LLVM_ENABLE_PLUGINS@
 config.linked_bye_extension = @LLVM_BYE_LINK_INTO_TOOLS@
 config.have_tf_aot = @LLVM_HAVE_TF_AOT@
 config.have_tf_api = @LLVM_HAVE_TF_API@
 config.expensive_checks = @LLVM_ENABLE_EXPENSIVE_CHECKS@
+config.clang_exe_name = "@CLANG_EXE_NAME@"
 
 # Support substitution of the tools_dir with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_lib_dir = config.llvm_lib_dir % lit_config.params
     config.llvm_shlib_dir = config.llvm_shlib_dir % lit_config.params
 except KeyError:

llvm/tools/llvm-config/llvm-config.cpp

Options:\n\
   --prefix          Print the installation prefix.\n\
   --src-root        Print the source root LLVM was built from.\n\
   --obj-root        Print the object root used to build LLVM.\n\
   --bindir          Directory containing LLVM executables.\n\
   --includedir      Directory containing LLVM headers.\n\
   --libdir          Directory containing LLVM libraries.\n\
   --cmakedir        Directory containing LLVM cmake modules.\n\
   --cppflags        C preprocessor flags for files that include LLVM headers.\n\
+  --clang-exe       The clang executable.\n\
   --cflags          C compiler flags for files that include LLVM headers.\n\
   --cxxflags        C++ compiler flags for files that include LLVM headers.\n\
   --ldflags         Print Linker flags.\n\
   --system-libs     System Libraries needed to link against LLVM components.\n\
   --libs            Libraries needed to link against LLVM components.\n\
   --libnames        Bare library names for in-tree builds.\n\
   --libfiles        Fully qualified library filenames for makefile depends.\n\
   --components      List of all possible components.\n\
if (Arg.startswith("-")) {
       } else if (Arg == "--includedir") {
         OS << ActiveIncludeDir << '\n';
       } else if (Arg == "--libdir") {
         OS << ActiveLibDir << '\n';
       } else if (Arg == "--cmakedir") {
         OS << ActiveCMakeDir << '\n';
       } else if (Arg == "--cppflags") {
         OS << ActiveIncludeOption << ' ' << LLVM_CPPFLAGS << '\n';
+      } else if (Arg == "--clang-exe") {
+        OS << ActiveBinDir << DirSep << CLANG_EXE_NAME << '\n';
       } else if (Arg == "--cflags") {
         OS << ActiveIncludeOption << ' ' << LLVM_CFLAGS << '\n';
       } else if (Arg == "--cxxflags") {
         OS << ActiveIncludeOption << ' ' << LLVM_CXXFLAGS << '\n';
       } else if (Arg == "--ldflags") {
         OS << ((HostTriple.isWindowsMSVCEnvironment()) ? "-LIBPATH:" : "-L")
            << ActiveLibDir << ' ' << LLVM_LDFLAGS << '\n';
       } else if (Arg == "--system-libs") {

llvm/tools/llvm-rc/llvm-rc.cpp

 //===----------------------------------------------------------------------===//
 
 #include "ResourceFileWriter.h"
 #include "ResourceScriptCppFilter.h"
 #include "ResourceScriptParser.h"
 #include "ResourceScriptStmt.h"
 #include "ResourceScriptToken.h"
 
 #include "llvm/ADT/Triple.h"
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Config/config.h"
 
 #include <algorithm>
 #include <system_error>
 
 using namespace llvm;
 using namespace llvm::rc;
 
 namespace {

 }
 
 ErrorOr<std::string> findClang(const char *Argv0) {
   StringRef Parent = llvm::sys::path::parent_path(Argv0);
   ErrorOr<std::string> Path = std::error_code();
   if (!Parent.empty()) {
     // First look for the tool with all potential names in the specific
     // directory of Argv0, if known
-    for (const auto *Name : {"clang", "clang-cl"}) {
+    for (const auto *Name : {"clang", "clang-cl", CLANG_EXE_NAME}) {
       Path = sys::findProgramByName(Name, Parent);
       if (Path)
         return Path;
     }
   }
   // If no parent directory known, or not found there, look everywhere in PATH
-  for (const auto *Name : {"clang", "clang-cl"}) {
+  for (const auto *Name : {"clang", "clang-cl", CLANG_EXE_NAME}) {
     Path = sys::findProgramByName(Name);
     if (Path)
       return Path;
   }
   return Path;
 }
 
 Triple::ArchType getDefaultArch(Triple::ArchType Arch) {

llvm/utils/lit/lit/llvm/config.py

def use_clang(self, additional_tool_dirs=[], additional_flags=[],
         pext = getattr(self.config, 'llvm_plugin_ext', None)
         if shl:
             self.config.substitutions.append(('%llvmshlibdir', shl))
         if pext:
             self.config.substitutions.append(('%pluginext', pext))
 
         # Discover the 'clang' and 'clangcc' to use.
         self.config.clang = self.use_llvm_tool(
-            'clang', search_env='CLANG', required=required,
+            self.config.clang_exe_name, search_env='CLANG', required=required,
             use_installed=use_installed)
         if self.config.clang:
           self.config.available_features.add('clang')
           builtin_include_dir = self.get_clang_builtin_include_dir(
               self.config.clang)
           tool_substitutions = [
               ToolSubst('%clang', command=self.config.clang,
                         extra_args=additional_flags),

llvm/utils/update_cc_test_checks.py

 
 def str_to_commandline(value):
   if not value:
     return []
   return shlex.split(value)
 
 
 def infer_dependent_args(args):
+  if not args.llvm_bin:
+    llvm_config = 'llvm-config'
+  else:
+    llvm_config = os.path.join(args.llvm_bin, 'llvm-config')
+
+  # If the clang executable has a different name and we knoww where to
+  # get llvm-config, we can get the name that way.
+  if not args.clang and distutils.spawn.find_executable(llvm_config):
+    args.clang = subprocess.check_output(
+      [llvm_config, '--clang-exe']).decode().strip()
+
   if not args.clang:
     if not args.llvm_bin:
       args.clang = 'clang'
     else:
       args.clang = os.path.join(args.llvm_bin, 'clang')
   if not args.opt:
     if not args.llvm_bin:
       args.opt = 'opt'