utils: attempt to replace custom variables

CMake defaults to using a special <package>_DIR for finding packages.
Prefer this to import the CMake package for LLVM/Clang/Swift rather than
custom paths.

Author: compnerd

CMakeLists.txt

@@ -496,15 +496,11 @@ include(SwiftSharedCMakeConfig)
 # Support building Swift as a standalone project, using LLVM as an
 # external library.
 if(SWIFT_BUILT_STANDALONE)
-  swift_common_standalone_build_config(SWIFT SWIFT_CROSS_COMPILING)
+  swift_common_standalone_build_config(SWIFT)
 else()
   swift_common_unified_build_config(SWIFT)
 endif()
 
-if(NOT EXISTS "${CLANG_MAIN_INCLUDE_DIR}/clang/AST/Decl.h")
-  message(FATAL_ERROR "Clang is missing from llvm/tools subdirectory.")
-endif()
-
 set(SWIFT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
 set(SWIFT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
 set(SWIFT_CMAKE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
@@ -902,8 +898,8 @@ if(SWIFT_NEED_EXPLICIT_LIBDISPATCH)
     set(SWIFT_LIBDISPATCH_C_COMPILER ${CMAKE_C_COMPILER})
     set(SWIFT_LIBDISPATCH_CXX_COMPILER ${CMAKE_CXX_COMPILER})
   elseif(${CMAKE_SYSTEM_NAME} STREQUAL ${CMAKE_HOST_SYSTEM_NAME})
-    set(SWIFT_LIBDISPATCH_C_COMPILER ${PATH_TO_CLANG_BUILD}/bin/clang)
-    set(SWIFT_LIBDISPATCH_CXX_COMPILER ${PATH_TO_CLANG_BUILD}/bin/clang++)
+    set(SWIFT_LIBDISPATCH_C_COMPILER $<TARGET_PROPERTY:clang,LOCATION>)
+    set(SWIFT_LIBDISPATCH_CXX_COMPILER $<TARGET_PROPERTY:clang,LOCATION>)
   else()
     message(SEND_ERROR "libdispatch requires a newer clang compiler (${CMAKE_C_COMPILER_VERSION} < 3.9)")
   endif()

cmake/modules/StandaloneOverlay.cmake

@@ -22,16 +22,11 @@ set(SWIFT_DARWIN_DEPLOYMENT_VERSION_WATCHOS "2.0" CACHE STRING "")
 set(SWIFT_ENABLE_PARSEABLE_MODULE_INTERFACES TRUE)
 
 set(SWIFT_SOURCE_DIR "${SWIFT_SOURCE_ROOT}/src/swift" CACHE PATH "")
-set(SWIFT_PATH_TO_LLVM_SOURCE "${SWIFT_SOURCE_ROOT}/src/llvm" CACHE PATH "")
 set(SWIFT_NATIVE_SWIFT_TOOLS_PATH "${TOOLCHAIN_DIR}/usr/bin" CACHE PATH "")
 set(SWIFT_SDKS ${SWIFT_HOST_VARIANT_SDK})
 
-set(LLVM_CMAKE_MODULES_PATH "${SWIFT_PATH_TO_LLVM_SOURCE}/cmake/modules")
-
-list(APPEND CMAKE_MODULE_PATH
-  "${PROJECT_SOURCE_DIR}/../../../../cmake/modules"
-  ${LLVM_CMAKE_MODULES_PATH}
-)
+find_package(LLVM CONFIG REQUIRED NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}" "${PROJECT_SOURCE_DIR}/../../../../cmake/modules")
 
 set(SWIFT_DARWIN_XCRUN_TOOLCHAIN "XcodeDefault" CACHE STRING
     "The name of the toolchain to pass to 'xcrun'")

cmake/modules/SwiftExternalBenchmarkBuild.cmake

@@ -74,6 +74,14 @@ function (add_external_benchmark_suite)
     list(APPEND all_stdlib_dependencies ${stdlib_dependencies})
   endforeach()
 
+  if(CMAKE_SYSTEM_NAME STREQUAL Windows)
+    set(CC $<TARGET_PROPERTY:clang-cl,LOCATION>)
+    set(CXX $<TARGET_PROPERTY:clang-cl,LOCATION>)
+  else()
+    set(CC $<TARGET_PROPERTY:clang,LOCATION>)
+    set(CXX $<TARGET_PROPERTY:clang,LOCATION>++)
+  endif()
+
   llvm_ExternalProject_add(swift-bench ${src_dir}
     SOURCE_DIR ${src_dir}
     EXCLUDE_FROM_ALL
@@ -82,9 +90,9 @@ function (add_external_benchmark_suite)
     CMAKE_ARGS
       -DSWIFT_EXEC=${SWIFT_BINARY_DIR}/bin/swiftc
       -DSWIFT_LIBRARY_PATH=${SWIFT_BINARY_DIR}/lib/swift
-      -DCMAKE_C_COMPILER=${PATH_TO_CLANG_BUILD}/bin/clang
-      -DCMAKE_CXX_COMPILER=${PATH_TO_CLANG_BUILD}/bin/clang++
-      -DCLANG_EXEC=${PATH_TO_CLANG_BUILD}/bin/clang
+      -DCMAKE_C_COMPILER=${CC}
+      -DCMAKE_CXX_COMPILER=${CXX}
+      -DCLANG_EXEC=${CC}
       -DSWIFT_BENCHMARK_SUBCMAKE_BUILD=TRUE
     PASSTHROUGH_PREFIXES SWIFT_BENCHMARK
     )

cmake/modules/SwiftSharedCMakeConfig.cmake

@@ -3,37 +3,28 @@ include(SwiftXcodeSupport)
 
 include(CheckCXXCompilerFlag)
 
-macro(swift_common_standalone_build_config_llvm product is_cross_compiling)
+macro(swift_common_standalone_build_config_llvm product)
   option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
 
-  precondition_translate_flag(${product}_PATH_TO_LLVM_SOURCE PATH_TO_LLVM_SOURCE)
-  precondition_translate_flag(${product}_PATH_TO_LLVM_BUILD PATH_TO_LLVM_BUILD)
-
-  file(TO_CMAKE_PATH "${PATH_TO_LLVM_BUILD}" PATH_TO_LLVM_BUILD)
-
-  set(SWIFT_LLVM_CMAKE_PATHS
-      "${PATH_TO_LLVM_BUILD}/share/llvm/cmake"
-      "${PATH_TO_LLVM_BUILD}/lib/cmake/llvm")
-
-  # Add all LLVM CMake paths to our cmake module path.
-  foreach(path ${SWIFT_LLVM_CMAKE_PATHS})
-    list(APPEND CMAKE_MODULE_PATH ${path})
-  endforeach()
-
   # If we already have a cached value for LLVM_ENABLE_ASSERTIONS, save the value.
-  if (DEFINED LLVM_ENABLE_ASSERTIONS)
+  if(DEFINED LLVM_ENABLE_ASSERTIONS)
     set(LLVM_ENABLE_ASSERTIONS_saved "${LLVM_ENABLE_ASSERTIONS}")
   endif()
 
   # Then we import LLVMConfig. This is going to override whatever cached value
   # we have for LLVM_ENABLE_ASSERTIONS.
-  find_package(LLVM REQUIRED CONFIG
-    HINTS "${PATH_TO_LLVM_BUILD}" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+  find_package(LLVM CONFIG REQUIRED NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+  list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
+
+  set(LLVM_MAIN_SRC_DIR "${LLVM_BUILD_MAIN_SRC_DIR}"
+    CACHE PATH "Path to LLVM source tree")
+  set(LLVM_MAIN_INCLUDE_DIR "${LLVM_BUILD_MAIN_INCLUDE_DIR}"
+    CACHE PATH "Path to llvm/include")
 
   # If we did not have a cached value for LLVM_ENABLE_ASSERTIONS, set
   # LLVM_ENABLE_ASSERTIONS_saved to be the ENABLE_ASSERTIONS value from LLVM so
   # we follow LLVMConfig.cmake's value by default if nothing is provided.
-  if (NOT DEFINED LLVM_ENABLE_ASSERTIONS_saved)
+  if(NOT DEFINED LLVM_ENABLE_ASSERTIONS_saved)
     set(LLVM_ENABLE_ASSERTIONS_saved "${LLVM_ENABLE_ASSERTIONS}")
   endif()
 
@@ -49,11 +40,10 @@ macro(swift_common_standalone_build_config_llvm product is_cross_compiling)
 
   precondition(LLVM_TOOLS_BINARY_DIR)
   escape_path_for_xcode("${LLVM_BUILD_TYPE}" "${LLVM_TOOLS_BINARY_DIR}" LLVM_TOOLS_BINARY_DIR)
+
   precondition_translate_flag(LLVM_BUILD_LIBRARY_DIR LLVM_LIBRARY_DIR)
   escape_path_for_xcode("${LLVM_BUILD_TYPE}" "${LLVM_LIBRARY_DIR}" LLVM_LIBRARY_DIR)
-  precondition_translate_flag(LLVM_BUILD_MAIN_INCLUDE_DIR LLVM_MAIN_INCLUDE_DIR)
-  precondition_translate_flag(LLVM_BUILD_BINARY_DIR LLVM_BINARY_DIR)
-  precondition_translate_flag(LLVM_BUILD_MAIN_SRC_DIR LLVM_MAIN_SRC_DIR)
+
   precondition(LLVM_LIBRARY_DIRS)
   escape_path_for_xcode("${LLVM_BUILD_TYPE}" "${LLVM_LIBRARY_DIRS}" LLVM_LIBRARY_DIRS)
 
@@ -64,18 +54,41 @@ macro(swift_common_standalone_build_config_llvm product is_cross_compiling)
   set(LLVM_BINARY_OUTPUT_INTDIR "${LLVM_TOOLS_BINARY_DIR}")
   set(LLVM_LIBRARY_OUTPUT_INTDIR "${LLVM_LIBRARY_DIR}")
 
-  if (XCODE)
+  if(XCODE)
     fix_imported_targets_for_xcode("${LLVM_EXPORTED_TARGETS}")
   endif()
 
-  if(NOT ${is_cross_compiling})
+  if(NOT CMAKE_CROSSCOMPILING)
     set(${product}_NATIVE_LLVM_TOOLS_PATH "${LLVM_TOOLS_BINARY_DIR}")
   endif()
 
-  find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" "${${product}_NATIVE_LLVM_TOOLS_PATH}"
-    NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
-  if ("${LLVM_TABLEGEN_EXE}" STREQUAL "LLVM_TABLEGEN_EXE-NOTFOUND")
-    message(FATAL_ERROR "Failed to find tablegen in ${${product}_NATIVE_LLVM_TOOLS_PATH}")
+  if(CMAKE_CROSSCOMPILING)
+    set(LLVM_NATIVE_BUILD "${LLVM_BINARY_DIR}/NATIVE")
+    if(NOT EXISTS "${LLVM_NATIVE_BUILD}")
+      message(FATAL_ERROR
+        "Attempting to cross-compile swift standalone but no native LLVM build
+        found.  Please cross-compile LLVM as well.")
+    endif()
+
+    if(CMAKE_HOST_SYSTEM_NAME MATCHES Windows)
+      set(HOST_EXECUTABLE_SUFFIX ".exe")
+    endif()
+
+    if(NOT CMAKE_CONFIGURATION_TYPES)
+      set(LLVM_TABLEGEN_EXE
+        "${LLVM_NATIVE_BUILD_DIR}/bin/llvm-tblgen${HOST_EXECUTABLE_SUFFIX}")
+    else()
+      # NOTE: LLVM NATIVE build is always built Release, as is specified in
+      # CrossCompile.cmake
+      set(LLVM_TABLEGEN_EXE
+        "${LLVM_NATIVE_BUILD_DIR}/Release/bin/llvm-tblgen${HOST_EXECUTABLE_SUFFIX}")
+    endif()
+  else()
+    find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" HINTS ${LLVM_TOOLS_BINARY_DIR}
+      NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+    if(LLVM_TABLEGEN_EXE STREQUAL "LLVM_TABLEGEN_EXE-NOTFOUND")
+      message(FATAL_ERROR "Failed to find tablegen in ${LLVM_TOOLS_BINARY_DIR}")
+    endif()
   endif()
 
   include(AddLLVM)
@@ -106,7 +119,7 @@ macro(swift_common_standalone_build_config_llvm product is_cross_compiling)
     "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}" CACHE STRING
     "Version number that will be placed into the libclang library , in the form XX.YY")
 
-  foreach (INCLUDE_DIR ${LLVM_INCLUDE_DIRS})
+  foreach(INCLUDE_DIR ${LLVM_INCLUDE_DIRS})
     escape_path_for_xcode("${LLVM_BUILD_TYPE}" "${INCLUDE_DIR}" INCLUDE_DIR)
     include_directories(${INCLUDE_DIR})
   endforeach ()
@@ -134,52 +147,18 @@ macro(swift_common_standalone_build_config_llvm product is_cross_compiling)
   endif()
 endmacro()
 
-macro(swift_common_standalone_build_config_clang product is_cross_compiling)
-  set(${product}_PATH_TO_CLANG_SOURCE "${PATH_TO_LLVM_SOURCE}/tools/clang"
-      CACHE PATH "Path to Clang source code.")
-  set(${product}_PATH_TO_CLANG_BUILD "${PATH_TO_LLVM_BUILD}" CACHE PATH
-    "Path to the directory where Clang was built or installed.")
-
-  set(PATH_TO_CLANG_SOURCE "${${product}_PATH_TO_CLANG_SOURCE}")
-  set(PATH_TO_CLANG_BUILD "${${product}_PATH_TO_CLANG_BUILD}")
-
-  file(TO_CMAKE_PATH "${PATH_TO_CLANG_SOURCE}" PATH_TO_CLANG_SOURCE)
-  file(TO_CMAKE_PATH "${PATH_TO_CLANG_BUILD}" PATH_TO_CLANG_BUILD)
-
-  # Add all Clang CMake paths to our cmake module path.
-  set(SWIFT_CLANG_CMAKE_PATHS
-    "${PATH_TO_CLANG_BUILD}/share/clang/cmake"
-    "${PATH_TO_CLANG_BUILD}/lib/cmake/clang")
-  foreach(path ${SWIFT_CLANG_CMAKE_PATHS})
-    list(APPEND CMAKE_MODULE_PATH ${path})
-  endforeach()
-
-  # Then include Clang.
-  find_package(Clang REQUIRED CONFIG
-    HINTS "${PATH_TO_CLANG_BUILD}" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
+macro(swift_common_standalone_build_config_clang product)
+  find_package(Clang CONFIG REQUIRED NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
 
-  if(NOT EXISTS "${PATH_TO_CLANG_SOURCE}/include/clang/AST/Decl.h")
-    message(FATAL_ERROR "Please set ${product}_PATH_TO_CLANG_SOURCE to the root directory of Clang's source code.")
-  endif()
-  get_filename_component(CLANG_MAIN_SRC_DIR "${PATH_TO_CLANG_SOURCE}" ABSOLUTE)
-
-  if(NOT EXISTS "${PATH_TO_CLANG_BUILD}/tools/clang/include/clang/Basic/Version.inc")
-    message(FATAL_ERROR "Please set ${product}_PATH_TO_CLANG_BUILD to a directory containing a Clang build.")
-  endif()
-  set(CLANG_BUILD_INCLUDE_DIR "${PATH_TO_CLANG_BUILD}/tools/clang/include")
-
-  if (NOT ${is_cross_compiling})
+  if (NOT CMAKE_CROSSCOMPILING)
     set(${product}_NATIVE_CLANG_TOOLS_PATH "${LLVM_TOOLS_BINARY_DIR}")
   endif()
 
-  set(CLANG_MAIN_INCLUDE_DIR "${CLANG_MAIN_SRC_DIR}/include")
-
-  if (XCODE)
+  if(XCODE)
     fix_imported_targets_for_xcode("${CLANG_EXPORTED_TARGETS}")
   endif()
 
-  include_directories("${CLANG_BUILD_INCLUDE_DIR}"
-                      "${CLANG_MAIN_INCLUDE_DIR}")
+  include_directories(${CLANG_INCLUDE_DIRS})
 endmacro()
 
 macro(swift_common_standalone_build_config_cmark product)
@@ -218,9 +197,9 @@ endmacro()
 #
 #   is_cross_compiling
 #     Whether this is cross-compiling host tools.
-macro(swift_common_standalone_build_config product is_cross_compiling)
-  swift_common_standalone_build_config_llvm(${product} ${is_cross_compiling})
-  swift_common_standalone_build_config_clang(${product} ${is_cross_compiling})
+macro(swift_common_standalone_build_config product)
+  swift_common_standalone_build_config_llvm(${product})
+  swift_common_standalone_build_config_clang(${product})
   swift_common_standalone_build_config_cmark(${product})
 
   # Enable groups for IDE generators (Xcode and MSVC).

test/CMakeLists.txt

@@ -88,15 +88,7 @@ function(get_test_dependencies SDK result_var_name)
   set("${result_var_name}" "${deps}" PARENT_SCOPE)
 endfunction()
 
-if(PATH_TO_LLVM_SOURCE)
-  set(LIT "${PATH_TO_LLVM_SOURCE}/utils/lit/lit.py")
-else()
-  set(LIT "${PATH_TO_LLVM_BUILD}/${CMAKE_CFG_INTDIR}/bin/llvm-lit")
-  # Installed LLVM does not contain ${CMAKE_CFG_INTDIR} in paths.
-  if(NOT EXISTS "${LIT}")
-    set(LIT "${PATH_TO_LLVM_BUILD}/llvm-lit/bin")
-  endif()
-endif()
+set(LIT "${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py")
 
 # Incremental mode in lit orders test files by the last modification time
 # instead of by the path, which is good for CI. In this mode lit also updates

utils/CMakeLists.txt

@@ -10,7 +10,7 @@ swift_install_in_component(tools
     DESTINATION bin)
 
 # We install LLVM's FileCheck, if requested.
-file(TO_CMAKE_PATH "${SWIFT_PATH_TO_LLVM_BUILD}/bin/FileCheck${CMAKE_EXECUTABLE_SUFFIX}" _SWIFT_UTILS_FILECHECK)
+file(TO_CMAKE_PATH "${LLVM_BUILD_BINARY_DIR}/bin/FileCheck${CMAKE_EXECUTABLE_SUFFIX}" _SWIFT_UTILS_FILECHECK)
 swift_install_in_component(toolchain-dev-tools
   FILES "${_SWIFT_UTILS_FILECHECK}"
   DESTINATION bin)

utils/build-script-impl

@@ -2370,10 +2370,8 @@ for host in "${ALL_HOSTS[@]}"; do
                 cmake_options=(
                     "${cmake_options[@]}"
                     -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})"
-                    -DSWIFT_PATH_TO_CLANG_SOURCE:PATH="${CLANG_SOURCE_DIR}"
-                    -DSWIFT_PATH_TO_CLANG_BUILD:PATH="${llvm_build_dir}"
-                    -DSWIFT_PATH_TO_LLVM_SOURCE:PATH="${LLVM_SOURCE_DIR}"
-                    -DSWIFT_PATH_TO_LLVM_BUILD:PATH="${llvm_build_dir}"
+                    -DClang_DIR:PATH=${llvm_build_dir}/lib/cmake/clang
+                    -DLLVM_DIR:PATH=${llvm_build_dir}/lib/cmake/llvm
                     -DSWIFT_PATH_TO_CMARK_SOURCE:PATH="${CMARK_SOURCE_DIR}"
                     -DSWIFT_PATH_TO_CMARK_BUILD:PATH="$(build_directory ${host} cmark)"
                     -DSWIFT_PATH_TO_LIBDISPATCH_SOURCE:PATH="${LIBDISPATCH_SOURCE_DIR}"
@@ -2512,9 +2510,9 @@ for host in "${ALL_HOSTS[@]}"; do
                       -DLLDB_SWIFTC:PATH="$(build_directory ${LOCAL_HOST} swift)/bin/swiftc"
                       -DLLDB_SWIFT_LIBS:PATH="$(build_directory ${LOCAL_HOST} swift)/lib/swift"
                       -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})"
+                      -DClang_DIR:PATH=${llvm_build_dir}/lib/cmake/clang
+                      -DLLVM_DIR:PATH=${llvm_build_dir}/lib/cmake/llvm
                       -DLLDB_PATH_TO_SWIFT_SOURCE:PATH="${SWIFT_SOURCE_DIR}"
-                      -DLLDB_PATH_TO_LLVM_BUILD:PATH="${llvm_build_dir}"
-                      -DLLDB_PATH_TO_CLANG_BUILD:PATH="${llvm_build_dir}"
                       -DLLDB_PATH_TO_SWIFT_BUILD:PATH="${swift_build_dir}"
                       -DLLDB_IS_BUILDBOT_BUILD:BOOL="${LLDB_IS_BUILDBOT_BUILD}"
                       -DLLDB_BUILD_DATE:STRING="\"${LLDB_BUILD_DATE}\""