build: use `find_package(Python3)` if available

[compnerd]

Summary

This is primarily motivated by the desire to move from Python2 to
Python3. PYTHON_EXECUTABLE is ambiguous. This explicitly identifies
the python interpreter in use. Since the LLVM build seems to be able to
completed successfully with python3, use that across the build. The old
path aliases PYTHON_EXECUTABLE to be treated as Python3.

[compnerd]

After a discussion with @smeenai switch immediately to python3 as this may otherwise be treated as a regression for people on CMake>=3.12 and already using python3. For those who are using older releases, the old behaviour is preserved with an alternate variable name being referenced.

[smeenai]

Although I'd be happy to move everything over to Python 3, the consensus from http://lists.llvm.org/pipermail/llvm-dev/2020-January/138730.html was to still support Python 2.7 till Jan 2021 or so, so it's important to have a fallback to Python 2 here if Python 3 isn't found, I think.

[ldionne]

llvm/CMakeLists.txt

697

We need to fall back to Python 2 here per @smeenai 's comment.

[compnerd]

Add fallback to python2 in case python3 is not found.

[compnerd]

Include clang as some of the CI uses the unified build which fails without the update.

[JDevlieghere]

I would strongly prefer to do this differently. While we hope to drop Python 2 support in LLDB as soon as possible, we are not there yet. This patch as it stands will make it really hard for us to keep doing so (even internally) if upstream decides to drop support. I have looked into this change myself a while ago with these limitations in mind, and believe we can achieve the same in a way that would make this easier.

My suggestion is to have 4 new CMake variable that abstract over this: LLVM_PYTHON_EXECUTABLE, LLVM_PYTHON_LIBRARIES, LLVM_PYTHON_INCLUDE_DIRS and finally LLVM_PYTHON_HINT. We can then populate the first three depending on what machinery we want to use, i.e. the old CMake way of finding Python (until we bump the requirement across llvm), as well as the new FindPython3 and FindPython2. Similarly for the HINT variable, having our own abstraction means we don't clobber any of the variables used internally by CMake.

What do you think?

[compnerd]

@JDevlieghere I think that adding another mechanism for finding the python executable is not the right approach. You already have the variables that you are talking about, you just need to specify it in triplicate if you want compatibility across all the versions, but specifying -DPython3_EXECUTABLE= gives you the control over the executable for python3. If you want to use python2, -DPython3_EXECUTABLE= and -DPython2_EXECUTABLE= will ensure that python2 is always used. If you are using an older CMake, specifying -DPython3_EXECUTABLE=, -DPython2_EXECUTABLE= and -DPYTHON_EXECUTABLE= will ensure that the specified version is used. I'm not sure what the scenario is that you believe will be made more difficult with this approach.

[compnerd]

Adjust clang-tools-extra at the same time

[compnerd]

Add missed case of PYTHON_EXECUTABLE

[ldionne]

In D78762#2002305, @JDevlieghere wrote:

My suggestion is to have 4 new CMake variable that abstract over this: LLVM_PYTHON_EXECUTABLE, LLVM_PYTHON_LIBRARIES, LLVM_PYTHON_INCLUDE_DIRS and finally LLVM_PYTHON_HINT. We can then populate the first three depending on what machinery we want to use, i.e. the old CMake way of finding Python (until we bump the requirement across llvm), as well as the new FindPython3 and FindPython2. Similarly for the HINT variable, having our own abstraction means we don't clobber any of the variables used internally by CMake.

What do you think?

This is not better IMHO since it assumes that all subprojects are using the LLVM_meow variable to refer to the Python executable.

[JDevlieghere]

In D78762#2002390, @compnerd wrote:

@JDevlieghere I think that adding another mechanism for finding the python executable is not the right approach. You already have the variables that you are talking about, you just need to specify it in triplicate if you want compatibility across all the versions, but specifying -DPython3_EXECUTABLE= gives you the control over the executable for python3. If you want to use python2, -DPython3_EXECUTABLE= and -DPython2_EXECUTABLE= will ensure that python2 is always used. If you are using an older CMake, specifying -DPython3_EXECUTABLE=, -DPython2_EXECUTABLE= and -DPYTHON_EXECUTABLE= will ensure that the specified version is used. I'm not sure what the scenario is that you believe will be made more difficult with this approach.

It only works because you're setting Python3_EXECUTABLE to Python2_EXECUTABLE.

set(Python3_EXECUTABLE ${Python2_EXECUTABLE})

This will be completely opaque to lldb and we'll have to struggle again to reverse engineer which Python is used, leaving us in the same situation as today. How are we going to choose between Python 2 and Python 3 based on that variable? What I envision is to find Python once, like we do with other dependencies in the LLVM project, and then use that (interpreter, libraries, include paths) in LLDB. This has to work for in-tree-builds as well as out-of-tree builds (I'm not a fan but hey they're still supported).

In D78762#2005407, @ldionne wrote:

In D78762#2002305, @JDevlieghere wrote:

My suggestion is to have 4 new CMake variable that abstract over this: LLVM_PYTHON_EXECUTABLE, LLVM_PYTHON_LIBRARIES, LLVM_PYTHON_INCLUDE_DIRS and finally LLVM_PYTHON_HINT. We can then populate the first three depending on what machinery we want to use, i.e. the old CMake way of finding Python (until we bump the requirement across llvm), as well as the new FindPython3 and FindPython2. Similarly for the HINT variable, having our own abstraction means we don't clobber any of the variables used internally by CMake.

What do you think?

This is not better IMHO since it assumes that all subprojects are using the LLVM_meow variable to refer to the Python executable.

This patch is already changing the variable. How is this different/worse from using Python3_EXECUTABLE and having it maybe point to a Python 2 interpreter?

clang/CMakeLists.txt

154

Python2?

[compnerd]

@JDevlieghere I think that for LLDB, which this patch does not touch, the proper thing to do is to have 2 different paths with the ability to explicitly opt into the path, i.e. LLDB_USE_PYTHON2:BOOL and LLDB_USE_PYTHON3:BOOL with CMakeDependentOption to prevent the two from being set to TRUE simultaneously. If two paths need to be supported, then you must have two paths.

[JDevlieghere]

I talked to Saleem and he cleared up some of my concerns. Given that the community seems to have agreed to support only Python 3, this change seems a lot more reasonable. My earlier comment was made under the impression that we were going to continue supporting Python 2. With that in mind, the burden should fall on LLDB if we want to continue supporting it. Python 2 will be a "special case" then, rather than another first class citizen. With all that said, this LGTM.

[smeenai]

In D78762#2006406, @JDevlieghere wrote:

I talked to Saleem and he cleared up some of my concerns. Given that the community seems to have agreed to support only Python 3, this change seems a lot more reasonable. My earlier comment was made under the impression that we were going to continue supporting Python 2. With that in mind, the burden should fall on LLDB if we want to continue supporting it. Python 2 will be a "special case" then, rather than another first class citizen. With all that said, this LGTM.

To be clear, the plan is to support Python 2 till Jan 2021 or so. Given that this has the fallback though, it LGTM (with the comments addressed).

http://lists.llvm.org/pipermail/llvm-dev/2020-January/138730.html is the discussion for LLVM's Python 2/3 plans.

llvm/CMakeLists.txt

696

Python2

[compnerd]

llvm/CMakeLists.txt

696

Yeah, I have that fixed locally, there are 2 instances of it.

[compnerd]

rGcd84bfb8142bc7ff3a07a188ffb809f1d86d1fd7 (with the Python2 fixes)

[thakis]

Is there more background on this somewhere? What's the advantage of using Python3_EXECUTABLE instead of just PYTHON_EXECUTABLE? Having Python3_EXECUTABLE be python 2 seems pretty surprising to me.

Also, this doesn't update some PYTHON_EXECUTABLEs, e.g. the one in lld/test. Is that intentional?

[compnerd]

I was trying to do the minimal change to cover llvm. I definitely care about LLD and will do that in a subsequent change.

As to the benefit of this, it is primarily that the detection here explicitly ensures that python3 is used rather than python2. The fallback of aliasing is the easiest way to achieve this without having a lot of complicated logic at each site:

if(NOT Python3_Interpreter_FOUND)
  add_custom_command(...)
else()
  add_custom_command(...)
endif()

which would be the way to handle that. Creating another wrapper function is a terrible thing just to filter out incidental python usage would not only be extremely complicated but a large amount of logic that would also increase configure times unnecessarily.

The detection here is far more robust and precise. Python3_EXECUTABLE is the CMake variable name, not something that I chose.

[thakis]

I believe this breaks check-builtins on macOS. See https://bugs.chromium.org/p/chromium/issues/detail?id=1076480 for details.

The split() on the subprocess output throws since it wants a b'.' on py3, but that code has an unqualified except block. That means (I think) we always believe we run on macOS 10.0.0 under py3. I don't understand how we then fail to convert that back to an int (see linked bug).

Anyhoo, please take a look, and if it takes a while to fix we might have to go through yet another reland cycled :/

In D78762#2006872, @compnerd wrote:

I was trying to do the minimal change to cover llvm. I definitely care about LLD and will do that in a subsequent change.

As to the benefit of this, it is primarily that the detection here explicitly ensures that python3 is used rather than python2. The fallback of aliasing is the easiest way to achieve this without having a lot of complicated logic at each site:

if(NOT Python3_Interpreter_FOUND)
  add_custom_command(...)
else()
  add_custom_command(...)
endif()

I would've expected we'd just set some new variable, eg LLVM_PYTHON_INTERPRETER to either the py2 or py3 interpreter and use that everywhere. Seems a bit less confusing, and shouldn't make anything else more complicated. But it's all going away in a few months anyways, so I don't have a strong opinion.

[thakis]

I attempted a fix in e071ea48e923651ae21b9b684b0473248630322c

[hans]

What's the new cmake flag to set the python executable, and should we update llvm/docs/GettingStarted.rst to not refer to PYTHON_EXECUTABLE anymore?

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 = "@PYTHON_EXECUTABLE@"
+config.python_executable = "@Python3_EXECUTABLE@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.clang_staticanalyzer = @CLANG_ENABLE_STATIC_ANALYZER@
 
 # 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

clang/CMakeLists.txt

if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR )
   include_directories("${LLVM_BINARY_DIR}/include" "${LLVM_MAIN_INCLUDE_DIR}")
   link_directories("${LLVM_LIBRARY_DIR}")
 
   set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin )
   set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
   set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
 
   if(LLVM_INCLUDE_TESTS)
+    if(CMAKE_VERSION VERSION_LESS 3.12)
       include(FindPythonInterp)
       if(NOT PYTHONINTERP_FOUND)
         message(FATAL_ERROR
   "Unable to find Python interpreter, required for builds and testing.
 
   Please install Python or specify the PYTHON_EXECUTABLE CMake variable.")
       endif()
 
       if( ${PYTHON_VERSION_STRING} VERSION_LESS 2.7 )
         message(FATAL_ERROR "Python 2.7 or newer is required")
       endif()
 
+      add_executable(Python3::Interpreter IMPORTED)
+      set_target_properties(Python3::Interpreter PROPERTIES
+        IMPORTED_LOCATION ${PYTHON_EXECUTABLE})
+      set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
+    else()
+      find_package(Python3 COMPONENTS Interpreter)
+      if(NOT Python3_Interpreter_FOUND)
+        message(WARNING "Python3 not found, using python2 as a fallback")
+        find_package(Python3 COMPONENTS Interpreter REQUIRED)
+        if(Python2_VERSION VERSION_LESS 2.7)
+          message(SEND_ERROR "Python 2.7 or newer is required")
+        endif()
+
+        # Treat python2 as python3
+        add_executable(Python3::Interpreter IMPORTED)
+        set_target_properties(Python3::Interpreter PROPERTIES
+          IMPORTED_LOCATION ${Python2_EXECUTABLE})
+        set(Python3_EXECUTABLE ${Python2_EXECUTABLE})
+      endif()
+    endif()
+
     # Check prebuilt llvm/utils.
     if(EXISTS ${LLVM_TOOLS_BINARY_DIR}/FileCheck${CMAKE_EXECUTABLE_SUFFIX}
         AND EXISTS ${LLVM_TOOLS_BINARY_DIR}/count${CMAKE_EXECUTABLE_SUFFIX}
         AND EXISTS ${LLVM_TOOLS_BINARY_DIR}/not${CMAKE_EXECUTABLE_SUFFIX})
       set(LLVM_UTILS_PROVIDED ON)
     endif()
 
     if(EXISTS ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)

clang/bindings/python/tests/CMakeLists.txt

 # Test target to run Python test suite from main build.
 
 add_custom_target(check-clang-python
     COMMAND ${CMAKE_COMMAND} -E env
             CLANG_LIBRARY_PATH=$<TARGET_FILE_DIR:libclang>
-            ${PYTHON_EXECUTABLE} -m unittest discover
+            "${Python3_EXECUTABLE}" -m unittest discover
     DEPENDS libclang
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/..)
 
 set(RUN_PYTHON_TESTS TRUE)
 set_target_properties(check-clang-python PROPERTIES FOLDER "Clang tests")
 
 # Tests require libclang.so which is only built with LLVM_ENABLE_PIC=ON
 if(NOT LLVM_ENABLE_PIC)

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

 config.clang_staticanalyzer = @CLANG_ENABLE_STATIC_ANALYZER@
 config.clang_staticanalyzer_z3 = "@LLVM_WITH_Z3@"
 config.clang_examples = @CLANG_BUILD_EXAMPLES@
 config.enable_shared = @ENABLE_SHARED@
 config.enable_backtrace = @ENABLE_BACKTRACES@
 config.enable_experimental_new_pass_manager = @ENABLE_EXPERIMENTAL_NEW_PASS_MANAGER@
 config.enable_threads = @LLVM_ENABLE_THREADS@
 config.host_arch = "@HOST_ARCH@"
-config.python_executable = "@PYTHON_EXECUTABLE@"
+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@
 
 # 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

clang/utils/perf-training/CMakeLists.txt

if(LLVM_BUILD_INSTRUMENTED)
 
   add_lit_testsuite(generate-profraw "Generating clang PGO data"
     ${CMAKE_CURRENT_BINARY_DIR}/pgo-data/
     EXCLUDE_FROM_CHECK_ALL
     DEPENDS clang clear-profraw
     )
 
   add_custom_target(clear-profraw
-    COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/perf-helper.py clean ${CMAKE_CURRENT_BINARY_DIR} 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)
   endif()
 
   if(NOT LLVM_PROFDATA)
     message(STATUS "To enable merging PGO data LLVM_PROFDATA has to point to llvm-profdata")
   else()
     add_custom_target(generate-profdata
-      COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/perf-helper.py merge ${LLVM_PROFDATA} ${CMAKE_CURRENT_BINARY_DIR}/clang.profdata ${CMAKE_CURRENT_BINARY_DIR}
+      COMMAND "${Python3_EXECUTABLE}" ${CMAKE_CURRENT_SOURCE_DIR}/perf-helper.py merge ${LLVM_PROFDATA} ${CMAKE_CURRENT_BINARY_DIR}/clang.profdata ${CMAKE_CURRENT_BINARY_DIR}
       COMMENT "Merging profdata"
       DEPENDS generate-profraw)
   endif()
 endif()
 
 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"
     ${CMAKE_CURRENT_BINARY_DIR}/order-files/
     EXCLUDE_FROM_CHECK_ALL
     ARGS -j 1
     DEPENDS clang clear-dtrace-logs
     )
 
   add_custom_target(clear-dtrace-logs
-    COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/perf-helper.py clean ${CMAKE_CURRENT_BINARY_DIR} dtrace
+    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")
   endif()
 
   add_custom_target(generate-order-file
-    COMMAND ${PYTHON_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> --output ${CLANG_ORDER_FILE} ${CMAKE_CURRENT_BINARY_DIR}
     COMMENT "Generating order file"
     DEPENDS generate-dtrace-logs)
 endif()

clang/utils/perf-training/lit.site.cfg.in

 @LIT_SITE_CFG_IN_HEADER@
 
 import sys
 
 config.clang_tools_dir = "@CLANG_TOOLS_DIR@"
 config.perf_helper_dir = "@CMAKE_CURRENT_SOURCE_DIR@"
 config.test_exec_root = "@CMAKE_CURRENT_BINARY_DIR@"
 config.test_source_root = "@CLANG_PGO_TRAINING_DATA@"
 config.target_triple = "@TARGET_TRIPLE@"
-config.python_exe = "@PYTHON_EXECUTABLE@"
+config.python_exe = "@Python3_EXECUTABLE@"
 
 # 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
 except KeyError:
     e = sys.exc_info()[1]
     key, = e.args
     lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@CLANG_SOURCE_DIR@/utils/perf-training/lit.cfg")

clang/utils/perf-training/order-files.lit.site.cfg.in

 @LIT_SITE_CFG_IN_HEADER@
 
 import sys
 
 config.clang_tools_dir = "@CLANG_TOOLS_DIR@"
 config.perf_helper_dir = "@CMAKE_CURRENT_SOURCE_DIR@"
 config.test_exec_root = "@CMAKE_CURRENT_BINARY_DIR@"
 config.test_source_root = "@CLANG_PGO_TRAINING_DATA@"
 config.target_triple = "@TARGET_TRIPLE@"
-config.python_exe = "@PYTHON_EXECUTABLE@"
+config.python_exe = "@Python3_EXECUTABLE@"
 
 # 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
 except KeyError:
     e = sys.exc_info()[1]
     key, = e.args
     lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@CLANG_SOURCE_DIR@/utils/perf-training/order-files.lit.cfg")

llvm/CMakeLists.txt

if(WIN32 OR CYGWIN)
   endif()
 else()
   set(LLVM_ENABLE_PLUGINS_default ${LLVM_ENABLE_PIC})
 endif()
 option(LLVM_ENABLE_PLUGINS "Enable plugin support" ${LLVM_ENABLE_PLUGINS_default})
 
 include(HandleLLVMOptions)
 
+if(CMAKE_VERSION VERSION_LESS 3.12)
   include(FindPythonInterp)
   if( NOT PYTHONINTERP_FOUND )
     message(FATAL_ERROR
   "Unable to find Python interpreter, required for builds and testing.
 
   Please install Python or specify the PYTHON_EXECUTABLE CMake variable.")
   endif()
 
   if( ${PYTHON_VERSION_STRING} VERSION_LESS 2.7 )
     message(FATAL_ERROR "Python 2.7 or newer is required")
   endif()
 
+  add_executable(Python3::Interpreter IMPORTED)
+  set_target_properties(Python3::Interpreter PROPERTIES
+    IMPORTED_LOCATION ${PYTHON_EXECUTABLE})
+  set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
+else()
+  find_package(Python3 COMPONENTS Interpreter)
+  if(NOT Python3_Interpreter_FOUND)
+    message(WARNING "Python3 not found, using python2 as a fallback")
+    find_package(Python3 COMPONENTS Interpreter REQUIRED)
+    if(Python2_VERSION VERSION_LESS 2.7)
+      message(SEND_ERROR "Python 2.7 or newer is required")
+    endif()
+
+    # Treat python2 as python3
+    add_executable(Python3::Interpreter IMPORTED)
+    set_target_properties(Python3::Interpreter PROPERTIES
+      IMPORTED_LOCATION ${Python2_EXECUTABLE})
+    set(Python3_EXECUTABLE ${Python2_EXECUTABLE})
+  endif()
+endif()
+
 ######
 # LLVMBuild Integration
 #
 # We use llvm-build to generate all the data required by the CMake based
 # build system in one swoop:
 #
 #  - We generate a file (a CMake fragment) in the object root which contains
 #    all the definitions that are required by CMake.
if (LLVM_USE_OPROFILE)
   set(LLVMOPTIONALCOMPONENTS ${LLVMOPTIONALCOMPONENTS} OProfileJIT)
 endif (LLVM_USE_OPROFILE)
 if (LLVM_USE_PERF)
   set(LLVMOPTIONALCOMPONENTS ${LLVMOPTIONALCOMPONENTS} PerfJITEvents)
 endif (LLVM_USE_PERF)
 
 message(STATUS "Constructing LLVMBuild project information")
 execute_process(
-  COMMAND ${PYTHON_EXECUTABLE} -B ${LLVMBUILDTOOL}
+  COMMAND "${Python3_EXECUTABLE}" -B ${LLVMBUILDTOOL}
             --native-target "${LLVM_NATIVE_ARCH}"
             --enable-targets "${LLVM_TARGETS_TO_BUILD}"
             --enable-optional-components "${LLVMOPTIONALCOMPONENTS}"
             --write-library-table ${LLVMCONFIGLIBRARYDEPENDENCIESINC}
             --write-cmake-fragment ${LLVMBUILDCMAKEFRAG}
             OUTPUT_VARIABLE LLVMBUILDOUTPUT
             ERROR_VARIABLE LLVMBUILDERRORS
             OUTPUT_STRIP_TRAILING_WHITESPACE

llvm/cmake/config-ix.cmake

 function(find_python_module module)
   string(REPLACE "." "_" module_name ${module})
   string(TOUPPER ${module_name} module_upper)
   set(FOUND_VAR PY_${module_upper}_FOUND)
   if (DEFINED ${FOUND_VAR})
     return()
   endif()
 
-  execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c" "import ${module}"
+  execute_process(COMMAND "${Python3_EXECUTABLE}" "-c" "import ${module}"
     RESULT_VARIABLE status
     ERROR_QUIET)
 
   if(status)
     set(${FOUND_VAR} OFF CACHE BOOL "Failed to find python module '${module}'")
     message(STATUS "Could NOT find Python module ${module}")
   else()
   set(${FOUND_VAR} ON CACHE BOOL "Found python module '${module}'")

llvm/cmake/modules/AddLLVM.cmake

elseif(LLVM_HAVE_LINK_VERSION_SCRIPT)
     else()
       set_property(TARGET ${target_name} APPEND_STRING PROPERTY
                    LINK_FLAGS "  -Wl,--version-script,\"${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}\"")
     endif()
   else()
     set(native_export_file "${target_name}.def")
 
     add_custom_command(OUTPUT ${native_export_file}
-      COMMAND ${PYTHON_EXECUTABLE} -c "import sys;print(''.join(['EXPORTS\\n']+sys.stdin.readlines(),))"
+      COMMAND "${Python3_EXECUTABLE}" -c "import sys;print(''.join(['EXPORTS\\n']+sys.stdin.readlines(),))"
         < ${export_file} > ${native_export_file}
       DEPENDS ${export_file}
       VERBATIM
       COMMENT "Creating export file for ${target_name}")
     set(export_file_linker_flag "${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
     if(MSVC)
       set(export_file_linker_flag "/DEF:\"${export_file_linker_flag}\"")
     endif()
elseif (LLVM_EXPORT_SYMBOLS_FOR_PLUGINS)
     endwhile()
     list(REMOVE_DUPLICATES static_libs)
     if (MSVC)
       set(mangling microsoft)
     else()
       set(mangling itanium)
     endif()
     add_custom_command(OUTPUT ${exported_symbol_file}
-                       COMMAND ${PYTHON_EXECUTABLE} ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py --mangling=${mangling} ${static_libs} -o ${exported_symbol_file}
+                       COMMAND "${Python3_EXECUTABLE}" ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py --mangling=${mangling} ${static_libs} -o ${exported_symbol_file}
                        WORKING_DIRECTORY ${LLVM_LIBRARY_OUTPUT_INTDIR}
                        DEPENDS ${LLVM_MAIN_SRC_DIR}/utils/extract_symbols.py ${static_libs}
                        VERBATIM
                        COMMENT "Generating export list for ${target}")
     add_llvm_symbol_exports( ${target} ${exported_symbol_file} )
     # If something links against this executable then we want a
     # transitive link against only the libraries whose symbols
     # we aren't exporting.

 # Paths that are on a different drive than the basedir (on Windows) or that
 # contain symlinks are returned absolute.
 # Use with LLVM_LIT_PATH_FUNCTION below.
 function(make_paths_relative out_pathlist basedir pathlist)
   # Passing ARG_PATH_VALUES as-is to execute_process() makes cmake strip
   # empty list entries. So escape the ;s in the list and do the splitting
   # ourselves. cmake has no relpath function, so use Python for that.
   string(REPLACE ";" "\\;" pathlist_escaped "${pathlist}")
-  execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c" "\n
+  execute_process(COMMAND "${Python3_EXECUTABLE}" "-c" "\n
 import os, sys\n
 base = sys.argv[1]
 def haslink(p):\n
     if not p or p == os.path.dirname(p): return False\n
     return os.path.islink(p) or haslink(os.path.dirname(p))\n
 def relpath(p):\n
     if not p: return ''\n
     if os.path.splitdrive(p)[0] != os.path.splitdrive(base)[0]: return p\n
function(configure_lit_site_cfg site_in site_out)
   set(LLVM_SOURCE_DIR ${LLVM_MAIN_SRC_DIR})
   set(LLVM_BINARY_DIR ${LLVM_BINARY_DIR})
   string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" LLVM_TOOLS_DIR "${LLVM_TOOLS_BINARY_DIR}")
   string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} LLVM_LIBS_DIR  "${LLVM_LIBRARY_DIR}")
 
   # SHLIBDIR points the build tree.
   string(REPLACE "${CMAKE_CFG_INTDIR}" "${LLVM_BUILD_MODE}" SHLIBDIR "${LLVM_SHLIB_OUTPUT_INTDIR}")
 
-  set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})
   # FIXME: "ENABLE_SHARED" doesn't make sense, since it is used just for
   # plugins. We may rename it.
   if(LLVM_ENABLE_PLUGINS)
     set(ENABLE_SHARED "1")
   else()
     set(ENABLE_SHARED "0")
   endif()
 
function(add_lit_target target comment)
   # Get the path to the lit to *run* tests with.  This can be overriden by
   # the user by specifying -DLLVM_EXTERNAL_LIT=<path-to-lit.py>
   get_llvm_lit_path(
     lit_base_dir
     lit_file_name
     ALLOW_EXTERNAL
     )
 
-  set(LIT_COMMAND "${PYTHON_EXECUTABLE};${lit_base_dir}/${lit_file_name}")
+  set(LIT_COMMAND "${Python3_EXECUTABLE};${lit_base_dir}/${lit_file_name}")
   list(APPEND LIT_COMMAND ${LIT_ARGS})
   foreach(param ${ARG_PARAMS})
     list(APPEND LIT_COMMAND --param ${param})
   endforeach()
   if (ARG_UNPARSED_ARGUMENTS)
     add_custom_target(${target}
       COMMAND ${LIT_COMMAND} ${ARG_UNPARSED_ARGUMENTS}
       COMMENT "${comment}"

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

 @LIT_SITE_CFG_IN_HEADER@
 
 import sys
 
 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.llvm_src_root = path(r"@LLVM_SOURCE_DIR@")
 config.llvm_obj_root = path(r"@LLVM_BINARY_DIR@")
 config.llvm_tools_dir = path(r"@LLVM_TOOLS_DIR@")
 config.llvm_lib_dir = path(r"@LLVM_LIBRARY_DIR@")
 config.llvm_shlib_dir = path(r"@SHLIBDIR@")
 config.llvm_shlib_ext = "@SHLIBEXT@"
 config.llvm_exe_ext = "@EXEEXT@"
 config.lit_tools_dir = path(r"@LLVM_LIT_TOOLS_DIR@")
-config.python_executable = "@PYTHON_EXECUTABLE@"
+config.python_executable = "@Python3_EXECUTABLE@"
 config.gold_executable = "@GOLD_EXECUTABLE@"
 config.ld64_executable = "@LD64_EXECUTABLE@"
 config.ocamlfind_executable = "@OCAMLFIND@"
 config.have_ocamlopt = @HAVE_OCAMLOPT@
 config.have_ocaml_ounit = @HAVE_OCAML_OUNIT@
 config.ocaml_flags = "@OCAMLFLAGS@"
 config.include_go_tests = @LLVM_INCLUDE_GO_TESTS@
 config.go_executable = "@GO_EXECUTABLE@"

llvm/tools/llvm-shlib/CMakeLists.txt

if(CMAKE_CROSSCOMPILING)
     build_native_tool(llvm-nm llvm_nm)
     set(llvm_nm_target "${llvm_nm}")
   else()
     set(llvm_nm $<TARGET_FILE:llvm-nm>)
     set(llvm_nm_target llvm-nm)
   endif()
 
   add_custom_command(OUTPUT ${LLVM_EXPORTED_SYMBOL_FILE}
-    COMMAND ${PYTHON_EXECUTABLE} ${GEN_SCRIPT} --libsfile ${LIBSFILE} ${GEN_UNDERSCORE} --nm "${llvm_nm}" -o ${LLVM_EXPORTED_SYMBOL_FILE}
+    COMMAND "${Python3_EXECUTABLE}" ${GEN_SCRIPT} --libsfile ${LIBSFILE} ${GEN_UNDERSCORE} --nm "${llvm_nm}" -o ${LLVM_EXPORTED_SYMBOL_FILE}
     DEPENDS ${LIB_NAMES} ${llvm_nm_target}
     COMMENT "Generating export list for LLVM-C"
     VERBATIM )
 
   # Finally link the target.
   add_llvm_library(LLVM-C SHARED INSTALL_WITH_TOOLCHAIN ${SOURCES} DEPENDS intrinsics_gen)
 
 endif()