[lldb] Get rid of helper CMake variables for Python

[JDevlieghere]

Summary

This patch is basically just a big sed to update the variables:

s/PYTHON_LIBRARIES/Python3_LIBRARIES/g 
s/PYTHON_INCLUDE_DIRS/Python3_INCLUDE_DIRS/g
s/PYTHON_EXECUTABLE/Python3_EXECUTABLE/g 
s/PYTHON_RPATH/Python3_RPATH/g

I've also renamed the CMake module to better express its purpose and for consistency with FindLuaAndSwig.

lldb/CMakeLists.txt

 endif()
 
 if (WIN32)
   add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)
 endif()
 
 if (LLDB_ENABLE_PYTHON)
   execute_process(
-    COMMAND ${PYTHON_EXECUTABLE}
+    COMMAND ${Python3_EXECUTABLE}
         -c "import distutils.sysconfig; print(distutils.sysconfig.get_python_lib(True, False, ''))"
     OUTPUT_VARIABLE LLDB_PYTHON_DEFAULT_RELATIVE_PATH
     OUTPUT_STRIP_TRAILING_WHITESPACE)
 
   file(TO_CMAKE_PATH ${LLDB_PYTHON_DEFAULT_RELATIVE_PATH} LLDB_PYTHON_DEFAULT_RELATIVE_PATH)
   set(LLDB_PYTHON_RELATIVE_PATH ${LLDB_PYTHON_DEFAULT_RELATIVE_PATH}
     CACHE STRING "Path where Python modules are installed, relative to install prefix")
 endif ()

lldb/bindings/python/CMakeLists.txt

 )
 
 function(create_python_package swig_target working_dir pkg_dir)
   cmake_parse_arguments(ARG "NOINIT" "" "FILES" ${ARGN})
   if(ARG_FILES)
     set(copy_cmd COMMAND ${CMAKE_COMMAND} -E copy ${ARG_FILES} ${pkg_dir})
   endif()
   if(NOT ARG_NOINIT)
-    set(init_cmd COMMAND ${PYTHON_EXECUTABLE}
+    set(init_cmd COMMAND ${Python3_EXECUTABLE}
         "${LLDB_SOURCE_DIR}/bindings/python/createPythonInit.py"
         "${pkg_dir}" ${ARG_FILES})
   endif()
   add_custom_command(TARGET ${swig_target} POST_BUILD VERBATIM
     COMMAND ${CMAKE_COMMAND} -E make_directory ${pkg_dir}
     ${copy_cmd}
     ${init_cmd}
     WORKING_DIRECTORY ${working_dir})

lldb/cmake/modules/FindPythonAndSwig.cmake

 #.rst:
-# FindPythonInterpAndLibs
+# FindPythonAndSwig
 # -----------
 #
 # Find the python interpreter and libraries as a whole.
 
 macro(FindPython3)
   # Use PYTHON_HOME as a hint to find Python 3.
   set(Python3_ROOT_DIR "${PYTHON_HOME}")
   find_package(Python3 COMPONENTS Interpreter Development)
   if(Python3_FOUND AND Python3_Interpreter_FOUND)
-    set(PYTHON_LIBRARIES ${Python3_LIBRARIES})
-    set(PYTHON_INCLUDE_DIRS ${Python3_INCLUDE_DIRS})
-    set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE})
 
     # The install name for the Python 3 framework in Xcode is relative to
     # the framework's location and not the dylib itself.
     #
     #   @rpath/Python3.framework/Versions/3.x/Python3
     #
     # This means that we need to compute the path to the Python3.framework
     # and use that as the RPATH instead of the usual dylib's directory.
     #
     # The check below shouldn't match Homebrew's Python framework as it is
     # called Python.framework instead of Python3.framework.
     if (APPLE AND Python3_LIBRARIES MATCHES "Python3.framework")
       string(FIND "${Python3_LIBRARIES}" "Python3.framework" python_framework_pos)
-      string(SUBSTRING "${Python3_LIBRARIES}" "0" ${python_framework_pos} PYTHON_RPATH)
+      string(SUBSTRING "${Python3_LIBRARIES}" "0" ${python_framework_pos} Python3_RPATH)
     endif()
 
     set(PYTHON3_FOUND TRUE)
     mark_as_advanced(
-      PYTHON_LIBRARIES
-      PYTHON_INCLUDE_DIRS
-      PYTHON_EXECUTABLE
-      PYTHON_RPATH
+      Python3_LIBRARIES
+      Python3_INCLUDE_DIRS
+      Python3_EXECUTABLE
+      Python3_RPATH
       SWIG_EXECUTABLE)
   endif()
 endmacro()
 
-if(PYTHON_LIBRARIES AND PYTHON_INCLUDE_DIRS AND PYTHON_EXECUTABLE AND SWIG_EXECUTABLE)
-  set(PYTHONINTERPANDLIBS_FOUND TRUE)
+if(Python3_LIBRARIES AND Python3_INCLUDE_DIRS AND Python3_EXECUTABLE AND SWIG_EXECUTABLE)
+  set(PYTHONANDSWIG_FOUND TRUE)
 else()
   find_package(SWIG 2.0)
   if (SWIG_FOUND)
       FindPython3()
   else()
     message(STATUS "SWIG 2 or later is required for Python support in LLDB but could not be found")
   endif()
 
   include(FindPackageHandleStandardArgs)
-  find_package_handle_standard_args(PythonInterpAndLibs
+  find_package_handle_standard_args(PythonAndSwig
                                     FOUND_VAR
-                                      PYTHONINTERPANDLIBS_FOUND
+                                      PYTHONANDSWIG_FOUND
                                     REQUIRED_VARS
-                                      PYTHON_LIBRARIES
-                                      PYTHON_INCLUDE_DIRS
-                                      PYTHON_EXECUTABLE
+                                      Python3_LIBRARIES
+                                      Python3_INCLUDE_DIRS
+                                      Python3_EXECUTABLE
                                       SWIG_EXECUTABLE)
 endif()

lldb/cmake/modules/LLDBConfig.cmake

macro(add_optional_dependency variable description package found)
 
   message(STATUS "${description}: ${${variable}}")
 endmacro()
 
 add_optional_dependency(LLDB_ENABLE_LIBEDIT "Enable editline support in LLDB" LibEdit LibEdit_FOUND)
 add_optional_dependency(LLDB_ENABLE_CURSES "Enable curses support in LLDB" CursesAndPanel CURSESANDPANEL_FOUND)
 add_optional_dependency(LLDB_ENABLE_LZMA "Enable LZMA compression support in LLDB" LibLZMA LIBLZMA_FOUND)
 add_optional_dependency(LLDB_ENABLE_LUA "Enable Lua scripting support in LLDB" LuaAndSwig LUAANDSWIG_FOUND)
-add_optional_dependency(LLDB_ENABLE_PYTHON "Enable Python scripting support in LLDB" PythonInterpAndLibs PYTHONINTERPANDLIBS_FOUND)
+add_optional_dependency(LLDB_ENABLE_PYTHON "Enable Python scripting support in LLDB" PythonAndSwig PYTHONANDSWIG_FOUND)
 add_optional_dependency(LLDB_ENABLE_LIBXML2 "Enable Libxml 2 support in LLDB" LibXml2 LIBXML2_FOUND VERSION 2.8)
 
 option(LLDB_USE_SYSTEM_SIX "Use six.py shipped with system and do not install a copy of it" OFF)
 option(LLDB_USE_ENTITLEMENTS "When codesigning, use entitlements if available" ON)
 option(LLDB_BUILD_FRAMEWORK "Build LLDB.framework (Darwin only)" OFF)
 option(LLDB_NO_INSTALL_DEFAULT_RPATH "Disable default RPATH settings in binaries" OFF)
 option(LLDB_USE_SYSTEM_DEBUGSERVER "Use the system's debugserver for testing (Darwin only)." OFF)
 option(LLDB_SKIP_STRIP "Whether to skip stripping of binaries when installing lldb." OFF)
if(CMAKE_SYSTEM_NAME MATCHES "Windows")
     set(default_embed_python_home ON)
   else()
     set(default_embed_python_home OFF)
   endif()
   option(LLDB_EMBED_PYTHON_HOME
     "Embed PYTHONHOME in the binary. If set to OFF, PYTHONHOME environment variable will be used to to locate Python."
     ${default_embed_python_home})
 
-  include_directories(${PYTHON_INCLUDE_DIRS})
+  include_directories(${Python3_INCLUDE_DIRS})
   if (LLDB_EMBED_PYTHON_HOME)
-    get_filename_component(PYTHON_HOME "${PYTHON_EXECUTABLE}" DIRECTORY)
+    get_filename_component(PYTHON_HOME "${Python3_EXECUTABLE}" DIRECTORY)
     set(LLDB_PYTHON_HOME "${PYTHON_HOME}" CACHE STRING
       "Path to use as PYTHONHOME in lldb. If a relative path is specified, it will be resolved at runtime relative to liblldb directory.")
   endif()
 endif()
 
 if (LLVM_EXTERNAL_CLANG_SOURCE_DIR)
   include_directories(${LLVM_EXTERNAL_CLANG_SOURCE_DIR}/include)
 else ()

lldb/source/API/CMakeLists.txt

 # lib/pythonX.Y/dist-packages/lldb/_lldb.so is a symlink to lib/liblldb.so,
 # which depends on lib/libLLVM*.so (BUILD_SHARED_LIBS) or lib/libLLVM-10git.so
 # (LLVM_LINK_LLVM_DYLIB). Add an additional rpath $ORIGIN/../../../../lib so
 # that _lldb.so can be loaded from Python.
 if(LLDB_ENABLE_PYTHON AND (BUILD_SHARED_LIBS OR LLVM_LINK_LLVM_DYLIB) AND UNIX AND NOT APPLE)
   set_property(TARGET liblldb APPEND PROPERTY INSTALL_RPATH "\$ORIGIN/../../../../lib${LLVM_LIBDIR_SUFFIX}")
 endif()
 
-if(PYTHON_RPATH)
-  set_property(TARGET liblldb APPEND PROPERTY INSTALL_RPATH "${PYTHON_RPATH}")
-  set_property(TARGET liblldb APPEND PROPERTY BUILD_RPATH   "${PYTHON_RPATH}")
+if(Python3_RPATH)
+  set_property(TARGET liblldb APPEND PROPERTY INSTALL_RPATH "${Python3_RPATH}")
+  set_property(TARGET liblldb APPEND PROPERTY BUILD_RPATH   "${Python3_RPATH}")
 endif()
 
 
 if(LLDB_ENABLE_PYTHON)
   add_dependencies(liblldb swig_wrapper_python)
 
   if (MSVC)
     set_property(SOURCE ${lldb_python_wrapper} APPEND_STRING PROPERTY COMPILE_FLAGS " /W0")
else()
     MESSAGE("-- Symbols (liblldb): exporting all symbols from the lldb and lldb_private namespaces")
     add_llvm_symbol_exports(liblldb ${CMAKE_CURRENT_SOURCE_DIR}/liblldb-private.exports)
   endif()
   set_target_properties(liblldb_exports PROPERTIES FOLDER "lldb misc")
 endif()
 
 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   # Only MSVC has the ABI compatibility problem and avoids using FindPythonLibs,
-  # so only it needs to explicitly link against ${PYTHON_LIBRARIES}
+  # so only it needs to explicitly link against ${Python3_LIBRARIES}
   if (MSVC AND LLDB_ENABLE_PYTHON)
-    target_link_libraries(liblldb PRIVATE ${PYTHON_LIBRARIES})
+    target_link_libraries(liblldb PRIVATE ${Python3_LIBRARIES})
   endif()
 else()
   set_target_properties(liblldb
     PROPERTIES
     OUTPUT_NAME lldb
   )
 endif()
 
 if (NOT LLDB_BUILT_STANDALONE)
   add_dependencies(liblldb clang-resource-headers)
 endif()
 
 if(LLDB_BUILD_FRAMEWORK)
   include(LLDBFramework)
 endif()

lldb/source/Plugins/ObjectFile/CMakeLists.txt

 add_subdirectory(Breakpad)
 add_subdirectory(ELF)
 add_subdirectory(Mach-O)
 add_subdirectory(PECOFF)
 add_subdirectory(JIT)
-add_subdirectory(wasm)
+add_subdirectory(wasm)
 

lldb/source/Plugins/ScriptInterpreter/None/CMakeLists.txt

 add_lldb_library(lldbPluginScriptInterpreterNone PLUGIN
   ScriptInterpreterNone.cpp
 
   LINK_LIBS
     lldbCore
     lldbInterpreter
-  )
+  )
 

lldb/source/Plugins/ScriptInterpreter/Python/CMakeLists.txt

add_lldb_library(lldbPluginScriptInterpreterPython PLUGIN
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbDataFormatters
     lldbHost
     lldbInterpreter
     lldbTarget
-    ${PYTHON_LIBRARIES}
+    ${Python3_LIBRARIES}
     ${LLDB_LIBEDIT_LIBS}
 
   LINK_COMPONENTS
     Support
   )
 
 if (LLDB_ENABLE_LIBEDIT)
   target_include_directories(lldbPluginScriptInterpreterPython PUBLIC
     ${LibEdit_INCLUDE_DIRS}
   )
 endif()

lldb/test/API/CMakeLists.txt

 function(add_python_test_target name test_script args comment)
   set(PYTHON_TEST_COMMAND
-    ${PYTHON_EXECUTABLE}
+    ${Python3_EXECUTABLE}
     ${test_script}
     ${args}
     )
 
   add_custom_target(${name}
     COMMAND ${PYTHON_TEST_COMMAND} ${ARG_DEFAULT_ARGS}
     COMMENT "${comment}"
     USES_TERMINAL

lldb/test/API/lit.site.cfg.py.in

 config.cmake_cxx_compiler = "@CMAKE_CXX_COMPILER@"
 config.host_os = "@HOST_OS@"
 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.shared_libs = @LLVM_ENABLE_SHARED_LIBS@
 config.llvm_use_sanitizer = "@LLVM_USE_SANITIZER@"
 config.target_triple = "@TARGET_TRIPLE@"
 config.lldb_build_directory = "@LLDB_TEST_BUILD_DIRECTORY@"
 config.lldb_reproducer_directory = os.path.join("@LLDB_TEST_BUILD_DIRECTORY@", "reproducers")
-config.python_executable = "@PYTHON_EXECUTABLE@"
+config.python_executable = "@Python3_EXECUTABLE@"
 config.dotest_path = "@LLDB_SOURCE_DIR@/test/API/dotest.py"
 config.dotest_args_str = "@LLDB_DOTEST_ARGS@"
 config.lldb_enable_python = @LLDB_ENABLE_PYTHON@
 config.dotest_lit_args_str = None
 config.enabled_plugins = []
 config.lldb_executable = '@LLDB_TEST_EXECUTABLE@'
 config.test_arch = '@LLDB_TEST_ARCH@'
 config.test_compiler = '@LLDB_TEST_COMPILER@'

lldb/test/CMakeLists.txt

add_lit_testsuite(check-lldb-reproducers
   DEPENDS lldb-test-deps)
 add_dependencies(check-lldb-reproducers check-lldb-reproducers-capture)
 
 if(LLDB_BUILT_STANDALONE)
   # This has to happen *AFTER* add_lit_testsuite.
   if (EXISTS ${LLVM_MAIN_SRC_DIR}/utils/llvm-lit)
     # LLVM's make_paths_relative uses Python3_EXECUTABLE which isn't set in a
     # standalone LLDB build.
-    set(Python3_EXECUTABLE ${PYTHON_EXECUTABLE})
+    set(Python3_EXECUTABLE ${Python3_EXECUTABLE})
     add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/llvm-lit ${CMAKE_CURRENT_BINARY_DIR}/llvm-lit)
   endif()
 endif()

lldb/test/Shell/lit.site.cfg.py.in

 @LIT_SITE_CFG_IN_HEADER@
 
 config.llvm_src_root = "@LLVM_SOURCE_DIR@"
 config.llvm_obj_root = "@LLVM_BINARY_DIR@"
 config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
 config.llvm_shlib_dir = "@SHLIBDIR@"
 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.lldb_obj_root = "@LLDB_BINARY_DIR@"
 config.lldb_libs_dir = "@LLDB_LIBS_DIR@"
 config.lldb_tools_dir = "@LLDB_TOOLS_DIR@"
 # Since it comes from the command line, it may have backslashes which
 # should not need to be escaped.
 config.lldb_lit_tools_dir = r"@LLDB_LIT_TOOLS_DIR@"
 config.target_triple = "@TARGET_TRIPLE@"
-config.python_executable = "@PYTHON_EXECUTABLE@"
+config.python_executable = "@Python3_EXECUTABLE@"
 config.have_zlib = @LLVM_ENABLE_ZLIB@
 config.lldb_enable_lzma = @LLDB_ENABLE_LZMA@
 config.host_triple = "@LLVM_HOST_TRIPLE@"
 config.lldb_bitness = 64 if @LLDB_IS_64_BITS@ else 32
 config.lldb_enable_python = @LLDB_ENABLE_PYTHON@
 config.lldb_enable_lua = @LLDB_ENABLE_LUA@
 config.lldb_build_directory = "@LLDB_TEST_BUILD_DIRECTORY@"
 # The shell tests use their own module caches.

lldb/test/Unit/lit.site.cfg.py.in

 @LIT_SITE_CFG_IN_HEADER@
 
 config.test_exec_root = "@LLDB_BINARY_DIR@"
 config.llvm_src_root = "@LLVM_SOURCE_DIR@"
 config.llvm_obj_root = "@LLVM_BINARY_DIR@"
 config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
 config.llvm_build_mode = "@LLVM_BUILD_MODE@"
 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.lldb_obj_root = "@LLDB_BINARY_DIR@"
 config.lldb_src_root = "@LLDB_SOURCE_DIR@"
 config.target_triple = "@TARGET_TRIPLE@"
-config.python_executable = "@PYTHON_EXECUTABLE@"
+config.python_executable = "@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.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
     config.llvm_build_mode = config.llvm_build_mode % lit_config.params
 except KeyError as e:
     key, = e.args
     lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
 
 import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LLDB_SOURCE_DIR@/test/Unit/lit.cfg.py")

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

 @LIT_SITE_CFG_IN_HEADER@
 
 config.test_exec_root = "@LLDB_BINARY_DIR@"
 config.llvm_src_root = "@LLVM_SOURCE_DIR@"
 config.llvm_obj_root = "@LLVM_BINARY_DIR@"
 config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
 config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
 config.llvm_build_mode = "@LLVM_BUILD_MODE@"
 config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.lldb_obj_root = "@LLDB_BINARY_DIR@"
 config.lldb_src_root = "@LLDB_SOURCE_DIR@"
 config.target_triple = "@TARGET_TRIPLE@"
-config.python_executable = "@PYTHON_EXECUTABLE@"
+config.python_executable = "@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.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
     config.llvm_build_mode = config.llvm_build_mode % lit_config.params
 except KeyError as e:
     key, = e.args
     lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
 
 import lit.llvm
 lit.llvm.initialize(lit_config, config)
 
 # Let the main config do the real work.
 lit_config.load_config(config, "@LLDB_SOURCE_DIR@/test/lit.cfg.py")

lldb/tools/intel-features/CMakeLists.txt

set_source_files_properties(cli-wrapper.cpp PROPERTIES
                             COMPILE_FLAGS ${CLI_WRAPPER_PREPROCESSORS})
 
 add_lldb_library(lldbIntelFeatures SHARED
   cli-wrapper.cpp
   ${LLDB_INTEL_FEATURES_PYTHON_WRAP}
 
   LINK_LIBS
     ${FEATURE_LIBS}
-    ${PYTHON_LIBRARIES}
+    ${Python3_LIBRARIES}
   )
 
 # Add link dependencies for python wrapper
 if (LLDB_ENABLE_PYTHON AND LLDB_BUILD_INTEL_PT)
   add_dependencies(lldbIntelFeatures intel-features-swig_wrapper)
 endif()
 
 install(TARGETS lldbIntelFeatures
   LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX})

lldb/tools/lldb-test/CMakeLists.txt

LINK_LIBS
     lldbUtility
     ${LLDB_ALL_PLUGINS}
     ${host_lib}
 
   LINK_COMPONENTS
     Support
   )
 
-if(PYTHON_RPATH)
-  set_property(TARGET lldb-test APPEND PROPERTY INSTALL_RPATH "${PYTHON_RPATH}")
-  set_property(TARGET lldb-test APPEND PROPERTY BUILD_RPATH   "${PYTHON_RPATH}")
+if(Python3_RPATH)
+  set_property(TARGET lldb-test APPEND PROPERTY INSTALL_RPATH "${Python3_RPATH}")
+  set_property(TARGET lldb-test APPEND PROPERTY BUILD_RPATH   "${Python3_RPATH}")
 endif()
 
 target_include_directories(lldb-test PRIVATE ${LLDB_SOURCE_DIR}/source)
 target_include_directories(lldb-test PRIVATE ${LLDB_BINARY_DIR}/source)

lldb/unittests/API/CMakeLists.txt

 add_lldb_unittest(APITests
   SBCommandInterpreterTest.cpp
 
   LINK_LIBS
     liblldb
   )
 
-if(PYTHON_RPATH)
-  set_property(TARGET APITests APPEND PROPERTY BUILD_RPATH "${PYTHON_RPATH}")
+if(Python3_RPATH)
+  set_property(TARGET APITests APPEND PROPERTY BUILD_RPATH "${Python3_RPATH}")
 endif()

lldb/unittests/Process/Linux/CMakeLists.txt

 add_lldb_unittest(ProcessorTraceTests
   ProcessorTraceTest.cpp
 
   LINK_LIBS
     lldbPluginProcessLinux
   )
 
 target_include_directories(ProcessorTraceTests PRIVATE
-  ${LLDB_SOURCE_DIR}/source/Plugins/Process/Linux)
+  ${LLDB_SOURCE_DIR}/source/Plugins/Process/Linux)
 

lldb/unittests/ScriptInterpreter/Lua/CMakeLists.txt

 add_lldb_unittest(ScriptInterpreterLuaTests
   LuaTests.cpp
   ScriptInterpreterTests.cpp
 
   LINK_LIBS
     lldbHost
     lldbPluginScriptInterpreterLua
     lldbPluginPlatformLinux
     LLVMTestingSupport
   LINK_COMPONENTS
     Support
-  )
+  )
 

lldb/unittests/ScriptInterpreter/Python/CMakeLists.txt

 add_lldb_unittest(ScriptInterpreterPythonTests
   PythonDataObjectsTests.cpp
   PythonTestSuite.cpp
 
   LINK_LIBS
     lldbHost
     lldbPluginScriptInterpreterPython
     LLVMTestingSupport
   LINK_COMPONENTS
     Support
   )
 
-if(PYTHON_RPATH)
-  set_property(TARGET ScriptInterpreterPythonTests APPEND PROPERTY BUILD_RPATH "${PYTHON_RPATH}")
-endif()
+if(Python3_RPATH)
+  set_property(TARGET ScriptInterpreterPythonTests APPEND PROPERTY BUILD_RPATH "${Python3_RPATH}")
+endif()
 

lldb/utils/lldb-dotest/lldb-dotest.in

-#!@PYTHON_EXECUTABLE@
+#!@Python3_EXECUTABLE@
 import subprocess
 import sys
 
 dotest_path = '@LLDB_SOURCE_DIR_CONFIGURED@/test/API/dotest.py'
 build_dir = '@LLDB_TEST_BUILD_DIRECTORY_CONFIGURED@'
 dotest_args_str = '@LLDB_DOTEST_ARGS_CONFIGURED@'
 arch = '@LLDB_TEST_ARCH@'
 executable = '@LLDB_TEST_EXECUTABLE_CONFIGURED@'