From 6de28634685ea51b5698b8cce2b2b83951dd2920 Mon Sep 17 00:00:00 2001
From: Saleem Abdulrasool <compnerd@compnerd.org>
Date: Sat, 18 Apr 2020 11:22:39 -0700
Subject: [PATCH 1/7] build: CVP some of the flags handling

Apply constant value propagation to the host flag variant operations.
This reduces the parameters needed for the invocations and enables
further cleaning in the hopes that we can apply these per-target using
CMake instead.
---
 cmake/modules/AddSwift.cmake                  | 198 +++++++-----------
 .../cmake/modules/AddSwiftSourceKit.cmake     |  22 +-
 2 files changed, 81 insertions(+), 139 deletions(-)

diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index 550b459848483..f2f2fab3b3e3e 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -73,10 +73,6 @@ endfunction()
 
 # Usage:
 # _add_host_variant_c_compile_link_flags(
-#   SDK sdk
-#   ARCH arch
-#   BUILD_TYPE build_type
-#   ENABLE_LTO enable_lto
 #   ANALYZE_CODE_COVERAGE analyze_code_coverage
 #   RESULT_VAR_NAME result_var_name
 #   DEPLOYMENT_VERSION_OSX version # If provided, overrides the default value of the OSX deployment target set by the Swift project for this compilation only.
@@ -84,10 +80,9 @@ endfunction()
 #   DEPLOYMENT_VERSION_IOS version
 #   DEPLOYMENT_VERSION_TVOS version
 #   DEPLOYMENT_VERSION_WATCHOS version
-#
 # )
 function(_add_host_variant_c_compile_link_flags)
-  set(oneValueArgs SDK ARCH BUILD_TYPE RESULT_VAR_NAME ENABLE_LTO ANALYZE_CODE_COVERAGE
+  set(oneValueArgs RESULT_VAR_NAME ANALYZE_CODE_COVERAGE
     DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_MACCATALYST DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS
     MACCATALYST_BUILD_FLAVOR
   )
@@ -98,36 +93,35 @@ function(_add_host_variant_c_compile_link_flags)
     ${ARGN})
 
   get_maccatalyst_build_flavor(maccatalyst_build_flavor
-      "${CFLAGS_SDK}" "${CFLAGS_MACCATALYST_BUILD_FLAVOR}")
+    "${SWFIT_HOST_VARIANT_SDK}" "${CFLAGS_MACCATALYST_BUILD_FLAVOR}")
 
   set(result ${${CFLAGS_RESULT_VAR_NAME}})
 
-  is_darwin_based_sdk("${CFLAGS_SDK}" IS_DARWIN)
+  is_darwin_based_sdk("${SWIFT_HOST_VARIANT_SDK}" IS_DARWIN)
   if(IS_DARWIN)
     # Check if there's a specific OS deployment version needed for this invocation
-    if("${CFLAGS_SDK}" STREQUAL "OSX")
+    if(SWIFT_HOST_VARIANT_SDK STREQUAL OSX)
       if(DEFINED maccatalyst_build_flavor)
         set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_MACCATALYST})
       else()
         set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_OSX})
       endif()
-    elseif("${CFLAGS_SDK}" STREQUAL "IOS" OR "${CFLAGS_SDK}" STREQUAL "IOS_SIMULATOR")
+    elseif(SWIFT_HOST_VARIANT_SDK MATCHES "^IOS")
       set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_IOS})
-    elseif("${CFLAGS_SDK}" STREQUAL "TVOS" OR "${CFLAGS_SDK}" STREQUAL "TVOS_SIMULATOR")
+    elseif(SWIFT_HOST_VARIANT_SDK MATCHES "^TVOS")
       set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_TVOS})
-    elseif("${CFLAGS_SDK}" STREQUAL "WATCHOS" OR "${CFLAGS_SDK}" STREQUAL "WATCHOS_SIMULATOR")
+    elseif(SWIFT_HOST_VARIANT_SDK MATCHES "^WATCHOS")
       set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_WATCHOS})
     endif()
 
     if("${DEPLOYMENT_VERSION}" STREQUAL "")
-      set(DEPLOYMENT_VERSION "${SWIFT_SDK_${CFLAGS_SDK}_DEPLOYMENT_VERSION}")
+      set(DEPLOYMENT_VERSION "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
     endif()
   endif()
 
   # MSVC, clang-cl, gcc don't understand -target.
-  if(CMAKE_C_COMPILER_ID MATCHES "^Clang|AppleClang$" AND
-      NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-    get_target_triple(target target_variant "${CFLAGS_SDK}" "${CFLAGS_ARCH}"
+  if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+    get_target_triple(target target_variant "${SWIFT_HOST_VARIANT_SDK}" "${SWIFT_HOST_VARIANT_ARCH}"
       MACCATALYST_BUILD_FLAVOR "${maccatalyst_build_flavor}"
       DEPLOYMENT_VERSION "${DEPLOYMENT_VERSION}")
     list(APPEND result "-target" "${target}")
@@ -136,18 +130,19 @@ function(_add_host_variant_c_compile_link_flags)
     endif()
   endif()
 
-  set(_sysroot "${SWIFT_SDK_${CFLAGS_SDK}_ARCH_${CFLAGS_ARCH}_PATH}")
+  set(_sysroot
+    "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}")
   if(IS_DARWIN)
     list(APPEND result "-isysroot" "${_sysroot}")
   elseif(NOT SWIFT_COMPILER_IS_MSVC_LIKE AND NOT "${_sysroot}" STREQUAL "/")
     list(APPEND result "--sysroot=${_sysroot}")
   endif()
 
-  if("${CFLAGS_SDK}" STREQUAL "ANDROID")
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
     # lld can handle targeting the android build.  However, if lld is not
     # enabled, then fallback to the linker included in the android NDK.
     if(NOT SWIFT_ENABLE_LLD_LINKER)
-      swift_android_tools_path(${CFLAGS_ARCH} tools_path)
+      swift_android_tools_path(${SWIFT_HOST_VARIANT_ARCH} tools_path)
       list(APPEND result "-B" "${tools_path}")
     endif()
   endif()
@@ -157,8 +152,8 @@ function(_add_host_variant_c_compile_link_flags)
     # of options by target_compile_options -- this way no undesired
     # side effects are introduced should a new search path be added.
     list(APPEND result
-      "-arch" "${CFLAGS_ARCH}"
-      "-F${SWIFT_SDK_${CFLAGS_SDK}_PATH}/../../../Developer/Library/Frameworks")
+      "-arch" "${SWIFT_HOST_VARIANT_ARCH}"
+      "-F${SWIFT_SDK_${SWIFT_HOST_VARIANT_ARCH}_PATH}/../../../Developer/Library/Frameworks")
 
     set(add_explicit_version TRUE)
 
@@ -171,7 +166,7 @@ function(_add_host_variant_c_compile_link_flags)
 
     if(add_explicit_version)
       list(APPEND result
-        "-m${SWIFT_SDK_${CFLAGS_SDK}_VERSION_MIN_NAME}-version-min=${DEPLOYMENT_VERSION}")
+        "-m${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_VERSION_MIN_NAME}-version-min=${DEPLOYMENT_VERSION}")
      endif()
   endif()
 
@@ -180,7 +175,7 @@ function(_add_host_variant_c_compile_link_flags)
                        "-fcoverage-mapping")
   endif()
 
-  _compute_lto_flag("${CFLAGS_ENABLE_LTO}" _lto_flag_out)
+  _compute_lto_flag("${SWIFT_TOOLS_ENABLE_LTO}" _lto_flag_out)
   if (_lto_flag_out)
     list(APPEND result "${_lto_flag_out}")
   endif()
@@ -190,9 +185,9 @@ endfunction()
 
 
 function(_add_host_variant_c_compile_flags)
-  set(oneValueArgs SDK ARCH BUILD_TYPE ENABLE_ASSERTIONS ANALYZE_CODE_COVERAGE
+  set(oneValueArgs
     DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_MACCATALYST DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS
-    RESULT_VAR_NAME ENABLE_LTO
+    RESULT_VAR_NAME
     MACCATALYST_BUILD_FLAVOR)
   cmake_parse_arguments(CFLAGS
     ""
@@ -203,11 +198,6 @@ function(_add_host_variant_c_compile_flags)
   set(result ${${CFLAGS_RESULT_VAR_NAME}})
 
   _add_host_variant_c_compile_link_flags(
-    SDK "${CFLAGS_SDK}"
-    ARCH "${CFLAGS_ARCH}"
-    BUILD_TYPE "${CFLAGS_BUILD_TYPE}"
-    ENABLE_ASSERTIONS "${CFLAGS_ENABLE_ASSERTIONS}"
-    ENABLE_LTO "${CFLAGS_ENABLE_LTO}"
     ANALYZE_CODE_COVERAGE FALSE
     DEPLOYMENT_VERSION_OSX "${CFLAGS_DEPLOYMENT_VERSION_OSX}"
     DEPLOYMENT_VERSION_MACCATALYST "${CFLAGS_DEPLOYMENT_VERSION_MACCATALYST}"
@@ -217,15 +207,15 @@ function(_add_host_variant_c_compile_flags)
     RESULT_VAR_NAME result
     MACCATALYST_BUILD_FLAVOR "${CFLAGS_MACCATALYST_BUILD_FLAVOR}")
 
-  is_build_type_optimized("${CFLAGS_BUILD_TYPE}" optimized)
+  is_build_type_optimized("${CMAKE_BUILD_TYPE}" optimized)
   if(optimized)
     list(APPEND result "-O2")
 
     # Omit leaf frame pointers on x86 production builds (optimized, no debug
     # info, and no asserts).
-    is_build_type_with_debuginfo("${CFLAGS_BUILD_TYPE}" debug)
-    if(NOT debug AND NOT CFLAGS_ENABLE_ASSERTIONS)
-      if("${CFLAGS_ARCH}" STREQUAL "i386" OR "${CFLAGS_ARCH}" STREQUAL "i686")
+    is_build_type_with_debuginfo("${CMAKE_BUILD_TYPE}" debug)
+    if(NOT debug AND NOT LLVM_ENABLE_ASSERTIONS)
+      if(SWIFT_HOST_VARIANT_ARCH MATCHES "i?86")
         if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
           list(APPEND result "-momit-leaf-frame-pointer")
         else()
@@ -243,9 +233,9 @@ function(_add_host_variant_c_compile_flags)
 
   # CMake automatically adds the flags for debug info if we use MSVC/clang-cl.
   if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-    is_build_type_with_debuginfo("${CFLAGS_BUILD_TYPE}" debuginfo)
+    is_build_type_with_debuginfo("${CMAKE_BUILD_TYPE}" debuginfo)
     if(debuginfo)
-      _compute_lto_flag("${CFLAGS_ENABLE_LTO}" _lto_flag_out)
+      _compute_lto_flag("${SWIFT_TOOLS_ENABLE_LTO}" _lto_flag_out)
       if(_lto_flag_out)
         list(APPEND result "-gline-tables-only")
       else()
@@ -256,7 +246,7 @@ function(_add_host_variant_c_compile_flags)
     endif()
   endif()
 
-  if("${CFLAGS_SDK}" STREQUAL "WINDOWS")
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
     # MSVC/clang-cl don't support -fno-pic or -fms-compatibility-version.
     if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
       list(APPEND result -fno-pic)
@@ -271,7 +261,7 @@ function(_add_host_variant_c_compile_flags)
     endif()
     # TODO(compnerd) permit building for different families
     list(APPEND result "-D_CRT_USE_WINAPI_FAMILY_DESKTOP_APP")
-    if("${CFLAGS_ARCH}" MATCHES arm)
+    if(SWIFT_HOST_VARIANT_ARCH MATCHES arm)
       list(APPEND result "-D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE")
     endif()
     list(APPEND result "-D_MT")
@@ -308,8 +298,8 @@ function(_add_host_variant_c_compile_flags)
     endif()
   endif()
 
-  if(${CFLAGS_SDK} STREQUAL ANDROID)
-    if(${CFLAGS_ARCH} STREQUAL x86_64)
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
+    if(SWIFT_HOST_VARIANT_ARCH STREQUAL x86_64)
       # NOTE(compnerd) Android NDK 21 or lower will generate library calls to
       # `__sync_val_compare_and_swap_16` rather than lowering to the CPU's
       # `cmpxchg16b` instruction as the `cx16` feature is disabled due to a bug
@@ -323,7 +313,7 @@ function(_add_host_variant_c_compile_flags)
     endif()
   endif()
 
-  if(CFLAGS_ENABLE_ASSERTIONS)
+  if(LLVM_ENABLE_ASSERTIONS)
     list(APPEND result "-UNDEBUG")
   else()
     list(APPEND result "-DNDEBUG")
@@ -333,28 +323,31 @@ function(_add_host_variant_c_compile_flags)
     list(APPEND result "-DSWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS")
   endif()
 
-  if(CFLAGS_ANALYZE_CODE_COVERAGE)
+  if(SWIFT_ANALYZE_CODE_COVERAGE)
     list(APPEND result "-fprofile-instr-generate"
                        "-fcoverage-mapping")
   endif()
 
-  if((CFLAGS_ARCH STREQUAL "armv7" OR CFLAGS_ARCH STREQUAL "aarch64") AND
-     (CFLAGS_SDK STREQUAL "LINUX" OR CFLAGS_SDK STREQUAL "ANDROID"))
+  if((SWIFT_HOST_VARIANT_ARCH STREQUAL armv7 OR
+      SWIFT_HOST_VARIANT_ARCH STREQUAL aarch64) AND
+     (SWIFT_HOST_VARIANT_SDK STREQUAL LINUX OR
+      SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID))
      list(APPEND result -funwind-tables)
   endif()
 
-  if("${CFLAGS_SDK}" STREQUAL "ANDROID")
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
     list(APPEND result -nostdinc++)
     swift_android_libcxx_include_paths(CFLAGS_CXX_INCLUDES)
-    swift_android_include_for_arch("${CFLAGS_ARCH}" "${CFLAGS_ARCH}_INCLUDE")
-    foreach(path IN LISTS CFLAGS_CXX_INCLUDES ${CFLAGS_ARCH}_INCLUDE)
+    swift_android_include_for_arch("${SWIFT_HOST_VARIANT_ARCH}"
+      "${SWIFT_HOST_VARIANT_ARCH}_INCLUDE")
+    foreach(path IN LISTS CFLAGS_CXX_INCLUDES ${SWIFT_HOST_VARIANT_ARCH}_INCLUDE)
       list(APPEND result "SHELL:${CMAKE_INCLUDE_SYSTEM_FLAG_C}${path}")
     endforeach()
     list(APPEND result "-D__ANDROID_API__=${SWIFT_ANDROID_API_LEVEL}")
   endif()
 
-  if("${CFLAGS_SDK}" STREQUAL "LINUX")
-    if(${CFLAGS_ARCH} STREQUAL x86_64)
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL "LINUX")
+    if(SWIFT_HOST_VARIANT_ARCH STREQUAL x86_64)
       # this is the minimum architecture that supports 16 byte CAS, which is necessary to avoid a dependency to libatomic
       list(APPEND result "-march=core2")
     endif()
@@ -364,7 +357,7 @@ function(_add_host_variant_c_compile_flags)
 endfunction()
 
 function(_add_host_variant_link_flags)
-  set(oneValueArgs SDK ARCH BUILD_TYPE ENABLE_ASSERTIONS ANALYZE_CODE_COVERAGE
+  set(oneValueArgs
   DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_MACCATALYST DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS
   RESULT_VAR_NAME ENABLE_LTO LTO_OBJECT_NAME LINK_LIBRARIES_VAR_NAME LIBRARY_SEARCH_DIRECTORIES_VAR_NAME
   MACCATALYST_BUILD_FLAVOR
@@ -375,20 +368,12 @@ function(_add_host_variant_link_flags)
     ""
     ${ARGN})
 
-  precondition(LFLAGS_SDK MESSAGE "Should specify an SDK")
-  precondition(LFLAGS_ARCH MESSAGE "Should specify an architecture")
-
   set(result ${${LFLAGS_RESULT_VAR_NAME}})
   set(link_libraries ${${LFLAGS_LINK_LIBRARIES_VAR_NAME}})
   set(library_search_directories ${${LFLAGS_LIBRARY_SEARCH_DIRECTORIES_VAR_NAME}})
 
   _add_host_variant_c_compile_link_flags(
-    SDK "${LFLAGS_SDK}"
-    ARCH "${LFLAGS_ARCH}"
-    BUILD_TYPE "${LFLAGS_BUILD_TYPE}"
-    ENABLE_ASSERTIONS "${LFLAGS_ENABLE_ASSERTIONS}"
-    ENABLE_LTO "${LFLAGS_ENABLE_LTO}"
-    ANALYZE_CODE_COVERAGE "${LFLAGS_ANALYZE_CODE_COVERAGE}"
+    ANALYZE_CODE_COVERAGE ${SWIFT_ANALYZE_CODE_COVERAGE}
     DEPLOYMENT_VERSION_OSX "${LFLAGS_DEPLOYMENT_VERSION_OSX}"
     DEPLOYMENT_VERSION_MACCATALYST "${LFLAGS_DEPLOYMENT_VERSION_MACCATALYST}"
     DEPLOYMENT_VERSION_IOS "${LFLAGS_DEPLOYMENT_VERSION_IOS}"
@@ -396,45 +381,47 @@ function(_add_host_variant_link_flags)
     DEPLOYMENT_VERSION_WATCHOS "${LFLAGS_DEPLOYMENT_VERSION_WATCHOS}"
     RESULT_VAR_NAME result
     MACCATALYST_BUILD_FLAVOR  "${LFLAGS_MACCATALYST_BUILD_FLAVOR}")
-  if("${LFLAGS_SDK}" STREQUAL "LINUX")
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL LINUX)
     list(APPEND link_libraries "pthread" "dl")
-  elseif("${LFLAGS_SDK}" STREQUAL "FREEBSD")
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL FREEBSD)
     list(APPEND link_libraries "pthread")
-  elseif("${LFLAGS_SDK}" STREQUAL "CYGWIN")
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL CYGWIN)
     # No extra libraries required.
-  elseif("${LFLAGS_SDK}" STREQUAL "WINDOWS")
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
     # We don't need to add -nostdlib using MSVC or clang-cl, as MSVC and clang-cl rely on auto-linking entirely.
     if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
       # NOTE: we do not use "/MD" or "/MDd" and select the runtime via linker
       # options. This causes conflicts.
       list(APPEND result "-nostdlib")
     endif()
-    swift_windows_lib_for_arch(${LFLAGS_ARCH} ${LFLAGS_ARCH}_LIB)
-    list(APPEND library_search_directories ${${LFLAGS_ARCH}_LIB})
+    swift_windows_lib_for_arch(${SWIFT_HOST_VARIANT_ARCH}
+      ${SWIFT_HOST_VARIANT_ARCH}_LIB)
+    list(APPEND library_search_directories ${${SWIFT_HOST_VARIANT_ARCH}_LIB})
 
     # NOTE(compnerd) workaround incorrectly extensioned import libraries from
     # the Windows SDK on case sensitive file systems.
     list(APPEND library_search_directories
-         ${CMAKE_BINARY_DIR}/winsdk_lib_${LFLAGS_ARCH}_symlinks)
-  elseif("${LFLAGS_SDK}" STREQUAL "HAIKU")
+      ${CMAKE_BINARY_DIR}/winsdk_lib_${SWIFT_HOST_VARIANT_ARCH}_symlinks)
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL HAIKU)
     list(APPEND link_libraries "bsd" "atomic")
     list(APPEND result "-Wl,-Bsymbolic")
-  elseif("${LFLAGS_SDK}" STREQUAL "ANDROID")
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
     list(APPEND link_libraries "dl" "log" "atomic")
     # We need to add the math library, which is linked implicitly by libc++
     list(APPEND result "-lm")
 
     # link against the custom C++ library
-    swift_android_cxx_libraries_for_arch(${LFLAGS_ARCH} cxx_link_libraries)
+    swift_android_cxx_libraries_for_arch(${SWIFT_HOST_VARIANT_ARCH} cxx_link_libraries)
     list(APPEND link_libraries ${cxx_link_libraries})
 
     # link against the ICU libraries
     list(APPEND link_libraries
-      ${SWIFT_ANDROID_${LFLAGS_ARCH}_ICU_I18N}
-      ${SWIFT_ANDROID_${LFLAGS_ARCH}_ICU_UC})
+      ${SWIFT_ANDROID_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N}
+      ${SWIFT_ANDROID_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC})
 
-    swift_android_lib_for_arch(${LFLAGS_ARCH} ${LFLAGS_ARCH}_LIB)
-    foreach(path IN LISTS ${LFLAGS_ARCH}_LIB)
+    swift_android_lib_for_arch(${SWIFT_HOST_VARIANT_ARCH}
+      ${SWIFT_HOST_VARIANT_ARCH}_LIB)
+    foreach(path IN LISTS ${SWIFT_HOST_VARIANT_ARCH}_LIB)
       list(APPEND library_search_directories ${path})
     endforeach()
   else()
@@ -443,7 +430,7 @@ function(_add_host_variant_link_flags)
     # be touched. The reason why this must be done is that on OS X, debug info is
     # left in object files. So if the object file is removed when we go to
     # generate a dsym, the debug info is gone.
-    if (LFLAGS_ENABLE_LTO)
+    if (SWIFT_TOOLS_ENABLE_LTO)
       precondition(LFLAGS_LTO_OBJECT_NAME
         MESSAGE "Should specify a unique name for the lto object")
       set(lto_object_dir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR})
@@ -452,26 +439,26 @@ function(_add_host_variant_link_flags)
       endif()
   endif()
 
-  if(NOT "${SWIFT_${LFLAGS_SDK}_${LFLAGS_ARCH}_ICU_UC}" STREQUAL "")
-    get_filename_component(SWIFT_${LFLAGS_SDK}_${LFLAGS_ARCH}_ICU_UC_LIBDIR
-      "${SWIFT_${LFLAGS_SDK}_${LFLAGS_ARCH}_ICU_UC}" DIRECTORY)
-    list(APPEND library_search_directories "${SWIFT_${LFLAGS_SDK}_${LFLAGS_ARCH}_ICU_UC_LIBDIR}")
+  if(NOT "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_SDK}_ICU_UC}" STREQUAL "")
+    get_filename_component(SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC_LIBDIR
+      "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_SDK}_ICU_UC}" DIRECTORY)
+    list(APPEND library_search_directories "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC_LIBDIR}")
   endif()
-  if(NOT "${SWIFT_${LFLAGS_SDK}_${LFLAGS_ARCH}_ICU_I18N}" STREQUAL "")
-    get_filename_component(SWIFT_${LFLAGS_SDK}_${LFLAGS_ARCH}_ICU_I18N_LIBDIR
-      "${SWIFT_${LFLAGS_SDK}_${LFLAGS_ARCH}_ICU_I18N}" DIRECTORY)
-    list(APPEND library_search_directories "${SWIFT_${LFLAGS_SDK}_${LFLAGS_ARCH}_ICU_I18N_LIBDIR}")
+  if(NOT "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N}" STREQUAL "")
+    get_filename_component(SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_SDK}_ICU_I18N_LIBDIR
+      "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N}" DIRECTORY)
+    list(APPEND library_search_directories "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N_LIBDIR}")
   endif()
 
   if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
     # FIXME: On Apple platforms, find_program needs to look for "ld64.lld"
     find_program(LDLLD_PATH "ld.lld")
     if((SWIFT_ENABLE_LLD_LINKER AND LDLLD_PATH AND NOT APPLE) OR
-       ("${LFLAGS_SDK}" STREQUAL "WINDOWS" AND
-        NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WINDOWS"))
+      (SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS AND
+       NOT CMAKE_SYSTEM_NAME STREQUAL WINDOWS))
       list(APPEND result "-fuse-ld=lld")
     elseif(SWIFT_ENABLE_GOLD_LINKER AND
-        "${SWIFT_SDK_${LFLAGS_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
+        "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
       if(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
         list(APPEND result "-fuse-ld=gold.exe")
       else()
@@ -495,7 +482,7 @@ function(_add_host_variant_link_flags)
   endif()
 
   get_maccatalyst_build_flavor(maccatalyst_build_flavor
-    "${LFLAGS_SDK}" "${LFLAGS_MACCATALYST_BUILD_FLAVOR}")
+    "${SWIFT_HOST_VARIANT_SDK}" "${LFLAGS_MACCATALYST_BUILD_FLAVOR}")
 
   set("${LFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
   set("${LFLAGS_LINK_LIBRARIES_VAR_NAME}" "${link_libraries}" PARENT_SCOPE)
@@ -593,7 +580,7 @@ function(_add_swift_host_library_single target)
   add_library("${target}" ${libkind} ${ASHLS_SOURCES})
   _set_target_prefix_and_suffix("${target}" "${libkind}" "${SWIFT_HOST_VARIANT_SDK}")
 
-  if("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "WINDOWS")
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
     swift_windows_include_for_arch(${SWIFT_HOST_VARIANT_ARCH} SWIFTLIB_INCLUDE)
     target_include_directories("${target}" SYSTEM PRIVATE ${SWIFTLIB_INCLUDE})
     set_target_properties(${target}
@@ -615,15 +602,15 @@ function(_add_swift_host_library_single target)
     set_target_properties("${target}"
       PROPERTIES
       INSTALL_NAME_DIR "@rpath")
-  elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "LINUX")
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL LINUX)
     set_target_properties("${target}"
       PROPERTIES
       INSTALL_RPATH "$ORIGIN:/usr/lib/swift/linux")
-  elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "CYGWIN")
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL CYGWIN)
     set_target_properties("${target}"
       PROPERTIES
       INSTALL_RPATH "$ORIGIN:/usr/lib/swift/cygwin")
-  elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "ANDROID")
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL "ANDROID")
     set_target_properties("${target}"
       PROPERTIES
       INSTALL_RPATH "$ORIGIN")
@@ -649,15 +636,7 @@ function(_add_swift_host_library_single target)
 
   set(library_search_directories)
 
-  _add_host_variant_c_compile_flags(
-    SDK "${SWIFT_HOST_VARIANT_SDK}"
-    ARCH "${SWIFT_HOST_VARIANT_ARCH}"
-    BUILD_TYPE ${CMAKE_BUILD_TYPE}
-    ENABLE_ASSERTIONS ${LLVM_ENABLE_ASSERTIONS}
-    ANALYZE_CODE_COVERAGE ${SWIFT_ANALYZE_CODE_COVERAGE}
-    ENABLE_LTO ${SWIFT_TOOLS_ENABLE_LTO}
-    RESULT_VAR_NAME c_compile_flags
-    )
+  _add_host_variant_c_compile_flags(RESULT_VAR_NAME c_compile_flags)
 
   if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
     if(libkind STREQUAL SHARED)
@@ -665,12 +644,6 @@ function(_add_swift_host_library_single target)
     endif()
   endif()
   _add_host_variant_link_flags(
-    SDK "${SWIFT_HOST_VARIANT_SDK}"
-    ARCH "${SWIFT_HOST_VARIANT_ARCH}"
-    BUILD_TYPE ${CMAKE_BUILD_TYPE}
-    ENABLE_ASSERTIONS ${LLVM_ENABLE_ASSERTIONS}
-    ANALYZE_CODE_COVERAGE ${SWIFT_ANALYZE_CODE_COVERAGE}
-    ENABLE_LTO ${SWIFT_TOOLS_ENABLE_LTO}
     LTO_OBJECT_NAME "${target}-${SWIFT_HOST_VARIANT_SDK}-${SWIFT_HOST_VARIANT_ARCH}"
     RESULT_VAR_NAME link_flags
     LIBRARY_SEARCH_DIRECTORIES_VAR_NAME library_search_directories
@@ -832,22 +805,9 @@ function(add_swift_host_tool executable)
   set(library_search_directories
     ${SWIFTLIB_DIR}/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR})
 
-  _add_host_variant_c_compile_flags(
-    SDK ${SWIFT_HOST_VARIANT_SDK}
-    ARCH ${SWIFT_HOST_VARIANT_ARCH}
-    BUILD_TYPE ${CMAKE_BUILD_TYPE}
-    ENABLE_ASSERTIONS ${LLVM_ENABLE_ASSERTIONS}
-    ENABLE_LTO ${SWIFT_TOOLS_ENABLE_LTO}
-    ANALYZE_CODE_COVERAGE ${SWIFT_ANALYZE_CODE_COVERAGE}
-    RESULT_VAR_NAME c_compile_flags)
+  _add_host_variant_c_compile_flags(RESULT_VAR_NAME c_compile_flags)
   _add_host_variant_link_flags(
-    SDK ${SWIFT_HOST_VARIANT_SDK}
-    ARCH ${SWIFT_HOST_VARIANT_ARCH}
-    BUILD_TYPE ${CMAKE_BUILD_TYPE}
-    ENABLE_ASSERTIONS ${LLVM_ENABLE_ASSERTIONS}
-    ENABLE_LTO ${SWIFT_TOOLS_ENABLE_LTO}
     LTO_OBJECT_NAME "${executable}-${SWIFT_HOST_VARIANT_SDK}-${SWIFT_HOST_VARIANT_ARCH}"
-    ANALYZE_CODE_COVERAGE ${SWIFT_ANALYZE_CODE_COVERAGE}
     RESULT_VAR_NAME link_flags
     LINK_LIBRARIES_VAR_NAME link_libraries
     LIBRARY_SEARCH_DIRECTORIES_VAR_NAME library_search_directories)
diff --git a/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake b/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
index 8a2096d6fa479..1235bb643fdd8 100644
--- a/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
+++ b/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
@@ -41,31 +41,13 @@ endfunction()
 # FIXME: this is a HACK.  All SourceKit CMake code using this function should be
 # rewritten to use 'add_swift_host_library' or 'add_swift_target_library'.
 function(add_sourcekit_default_compiler_flags target)
-  set(sdk "${SWIFT_HOST_VARIANT_SDK}")
-  set(arch "${SWIFT_HOST_VARIANT_ARCH}")
   set(c_compile_flags)
   set(link_flags)
 
   # Add variant-specific flags.
-  set(build_type "${CMAKE_BUILD_TYPE}")
-  set(enable_assertions "${LLVM_ENABLE_ASSERTIONS}")
-  set(analyze_code_coverage "${SWIFT_ANALYZE_CODE_COVERAGE}")
-  _add_host_variant_c_compile_flags(
-    SDK "${sdk}"
-    ARCH "${arch}"
-    BUILD_TYPE "${build_type}"
-    ENABLE_ASSERTIONS "${enable_assertions}"
-    ANALYZE_CODE_COVERAGE "${analyze_code_coverage}"
-    ENABLE_LTO "${SWIFT_TOOLS_ENABLE_LTO}"
-    RESULT_VAR_NAME c_compile_flags)
+  _add_host_variant_c_compile_flags(RESULT_VAR_NAME c_compile_flags)
   _add_host_variant_link_flags(
-    SDK "${sdk}"
-    ARCH "${arch}"
-    BUILD_TYPE "${build_type}"
-    ENABLE_ASSERTIONS "${enable_assertions}"
-    ENABLE_LTO "${SWIFT_TOOLS_ENABLE_LTO}"
-    LTO_OBJECT_NAME "${target}-${sdk}-${arch}"
-    ANALYZE_CODE_COVERAGE "${analyze_code_coverage}"
+    LTO_OBJECT_NAME "${target}-${SWIFT_HOST_VARIANT_SDK}-${SWIFT_HOST_VARIANT_ARCH}"
     RESULT_VAR_NAME link_flags
     LINK_LIBRARIES_VAR_NAME link_libraries
     LIBRARY_SEARCH_DIRECTORIES_VAR_NAME library_search_directories)

From 2e132050e1698317977f398389c00b0b23348575 Mon Sep 17 00:00:00 2001
From: Saleem Abdulrasool <compnerd@compnerd.org>
Date: Sat, 18 Apr 2020 11:48:17 -0700
Subject: [PATCH 2/7] build: CF, CVP, DAE over flag computation

Perform some constant folding, constant value propagation, dead argument
elimination over the flag computation methods.  This reduces the
unnecessary parameters and more clearly and succinctly describes what is
happening.
---
 cmake/modules/AddSwift.cmake | 59 +++++-------------------------------
 1 file changed, 8 insertions(+), 51 deletions(-)

diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index f2f2fab3b3e3e..c16771ddf7be4 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -75,17 +75,9 @@ endfunction()
 # _add_host_variant_c_compile_link_flags(
 #   ANALYZE_CODE_COVERAGE analyze_code_coverage
 #   RESULT_VAR_NAME result_var_name
-#   DEPLOYMENT_VERSION_OSX version # If provided, overrides the default value of the OSX deployment target set by the Swift project for this compilation only.
-#   DEPLOYMENT_VERSION_MACCATALYST version
-#   DEPLOYMENT_VERSION_IOS version
-#   DEPLOYMENT_VERSION_TVOS version
-#   DEPLOYMENT_VERSION_WATCHOS version
 # )
 function(_add_host_variant_c_compile_link_flags)
-  set(oneValueArgs RESULT_VAR_NAME ANALYZE_CODE_COVERAGE
-    DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_MACCATALYST DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS
-    MACCATALYST_BUILD_FLAVOR
-  )
+  set(oneValueArgs RESULT_VAR_NAME ANALYZE_CODE_COVERAGE)
   cmake_parse_arguments(CFLAGS
     ""
     "${oneValueArgs}"
@@ -93,30 +85,13 @@ function(_add_host_variant_c_compile_link_flags)
     ${ARGN})
 
   get_maccatalyst_build_flavor(maccatalyst_build_flavor
-    "${SWFIT_HOST_VARIANT_SDK}" "${CFLAGS_MACCATALYST_BUILD_FLAVOR}")
+    "${SWFIT_HOST_VARIANT_SDK}" "")
 
   set(result ${${CFLAGS_RESULT_VAR_NAME}})
 
   is_darwin_based_sdk("${SWIFT_HOST_VARIANT_SDK}" IS_DARWIN)
   if(IS_DARWIN)
-    # Check if there's a specific OS deployment version needed for this invocation
-    if(SWIFT_HOST_VARIANT_SDK STREQUAL OSX)
-      if(DEFINED maccatalyst_build_flavor)
-        set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_MACCATALYST})
-      else()
-        set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_OSX})
-      endif()
-    elseif(SWIFT_HOST_VARIANT_SDK MATCHES "^IOS")
-      set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_IOS})
-    elseif(SWIFT_HOST_VARIANT_SDK MATCHES "^TVOS")
-      set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_TVOS})
-    elseif(SWIFT_HOST_VARIANT_SDK MATCHES "^WATCHOS")
-      set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_WATCHOS})
-    endif()
-
-    if("${DEPLOYMENT_VERSION}" STREQUAL "")
-      set(DEPLOYMENT_VERSION "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
-    endif()
+    set(DEPLOYMENT_VERSION "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
   endif()
 
   # MSVC, clang-cl, gcc don't understand -target.
@@ -185,10 +160,7 @@ endfunction()
 
 
 function(_add_host_variant_c_compile_flags)
-  set(oneValueArgs
-    DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_MACCATALYST DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS
-    RESULT_VAR_NAME
-    MACCATALYST_BUILD_FLAVOR)
+  set(oneValueArgs RESULT_VAR_NAME)
   cmake_parse_arguments(CFLAGS
     ""
     "${oneValueArgs}"
@@ -199,13 +171,7 @@ function(_add_host_variant_c_compile_flags)
 
   _add_host_variant_c_compile_link_flags(
     ANALYZE_CODE_COVERAGE FALSE
-    DEPLOYMENT_VERSION_OSX "${CFLAGS_DEPLOYMENT_VERSION_OSX}"
-    DEPLOYMENT_VERSION_MACCATALYST "${CFLAGS_DEPLOYMENT_VERSION_MACCATALYST}"
-    DEPLOYMENT_VERSION_IOS "${CFLAGS_DEPLOYMENT_VERSION_IOS}"
-    DEPLOYMENT_VERSION_TVOS "${CFLAGS_DEPLOYMENT_VERSION_TVOS}"
-    DEPLOYMENT_VERSION_WATCHOS "${CFLAGS_DEPLOYMENT_VERSION_WATCHOS}"
-    RESULT_VAR_NAME result
-    MACCATALYST_BUILD_FLAVOR "${CFLAGS_MACCATALYST_BUILD_FLAVOR}")
+    RESULT_VAR_NAME result)
 
   is_build_type_optimized("${CMAKE_BUILD_TYPE}" optimized)
   if(optimized)
@@ -358,10 +324,7 @@ endfunction()
 
 function(_add_host_variant_link_flags)
   set(oneValueArgs
-  DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_MACCATALYST DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS
-  RESULT_VAR_NAME ENABLE_LTO LTO_OBJECT_NAME LINK_LIBRARIES_VAR_NAME LIBRARY_SEARCH_DIRECTORIES_VAR_NAME
-  MACCATALYST_BUILD_FLAVOR
-  )
+  RESULT_VAR_NAME ENABLE_LTO LTO_OBJECT_NAME LINK_LIBRARIES_VAR_NAME LIBRARY_SEARCH_DIRECTORIES_VAR_NAME)
   cmake_parse_arguments(LFLAGS
     ""
     "${oneValueArgs}"
@@ -374,13 +337,7 @@ function(_add_host_variant_link_flags)
 
   _add_host_variant_c_compile_link_flags(
     ANALYZE_CODE_COVERAGE ${SWIFT_ANALYZE_CODE_COVERAGE}
-    DEPLOYMENT_VERSION_OSX "${LFLAGS_DEPLOYMENT_VERSION_OSX}"
-    DEPLOYMENT_VERSION_MACCATALYST "${LFLAGS_DEPLOYMENT_VERSION_MACCATALYST}"
-    DEPLOYMENT_VERSION_IOS "${LFLAGS_DEPLOYMENT_VERSION_IOS}"
-    DEPLOYMENT_VERSION_TVOS "${LFLAGS_DEPLOYMENT_VERSION_TVOS}"
-    DEPLOYMENT_VERSION_WATCHOS "${LFLAGS_DEPLOYMENT_VERSION_WATCHOS}"
-    RESULT_VAR_NAME result
-    MACCATALYST_BUILD_FLAVOR  "${LFLAGS_MACCATALYST_BUILD_FLAVOR}")
+    RESULT_VAR_NAME result)
   if(SWIFT_HOST_VARIANT_SDK STREQUAL LINUX)
     list(APPEND link_libraries "pthread" "dl")
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL FREEBSD)
@@ -482,7 +439,7 @@ function(_add_host_variant_link_flags)
   endif()
 
   get_maccatalyst_build_flavor(maccatalyst_build_flavor
-    "${SWIFT_HOST_VARIANT_SDK}" "${LFLAGS_MACCATALYST_BUILD_FLAVOR}")
+    "${SWIFT_HOST_VARIANT_SDK}" "")
 
   set("${LFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
   set("${LFLAGS_LINK_LIBRARIES_VAR_NAME}" "${link_libraries}" PARENT_SCOPE)

From 98732808531239e57bd43114554ce1551421c3dd Mon Sep 17 00:00:00 2001
From: Saleem Abdulrasool <compnerd@compnerd.org>
Date: Sat, 18 Apr 2020 12:18:55 -0700
Subject: [PATCH 3/7] build: convert output variables to target

Convert the out parameters for `_add_host_variant_link_flags` to use the
target as an in-parameter.  Doing so allows us to set the properties on
the target directly rather than providing them as out parameters which
then get set subsequently.
---
 cmake/modules/AddSwift.cmake                  | 133 +++++++-----------
 .../cmake/modules/AddSwiftSourceKit.cmake     |  12 +-
 2 files changed, 54 insertions(+), 91 deletions(-)

diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index c16771ddf7be4..8138dca1b0295 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -322,65 +322,69 @@ function(_add_host_variant_c_compile_flags)
   set("${CFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
 endfunction()
 
-function(_add_host_variant_link_flags)
-  set(oneValueArgs
-  RESULT_VAR_NAME ENABLE_LTO LTO_OBJECT_NAME LINK_LIBRARIES_VAR_NAME LIBRARY_SEARCH_DIRECTORIES_VAR_NAME)
-  cmake_parse_arguments(LFLAGS
-    ""
-    "${oneValueArgs}"
-    ""
-    ${ARGN})
-
-  set(result ${${LFLAGS_RESULT_VAR_NAME}})
-  set(link_libraries ${${LFLAGS_LINK_LIBRARIES_VAR_NAME}})
-  set(library_search_directories ${${LFLAGS_LIBRARY_SEARCH_DIRECTORIES_VAR_NAME}})
-
+function(_add_host_variant_link_flags target)
   _add_host_variant_c_compile_link_flags(
     ANALYZE_CODE_COVERAGE ${SWIFT_ANALYZE_CODE_COVERAGE}
     RESULT_VAR_NAME result)
+  target_link_options(${target} PRIVATE
+    ${result})
+
   if(SWIFT_HOST_VARIANT_SDK STREQUAL LINUX)
-    list(APPEND link_libraries "pthread" "dl")
+    target_link_libraries(${target} PRIVATE
+      pthread
+      dl)
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL FREEBSD)
-    list(APPEND link_libraries "pthread")
+    target_link_libraries(${target} PRIVATE
+      pthread)
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL CYGWIN)
     # No extra libraries required.
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
-    # We don't need to add -nostdlib using MSVC or clang-cl, as MSVC and clang-cl rely on auto-linking entirely.
+    # We don't need to add -nostdlib using MSVC or clang-cl, as MSVC and
+    # clang-cl rely on auto-linking entirely.
     if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
       # NOTE: we do not use "/MD" or "/MDd" and select the runtime via linker
       # options. This causes conflicts.
-      list(APPEND result "-nostdlib")
+      target_link_options(${target} PRIVATE
+        -nostdlib)
     endif()
     swift_windows_lib_for_arch(${SWIFT_HOST_VARIANT_ARCH}
       ${SWIFT_HOST_VARIANT_ARCH}_LIB)
-    list(APPEND library_search_directories ${${SWIFT_HOST_VARIANT_ARCH}_LIB})
+    target_link_directories(${target} PRIVATE
+      ${${SWIFT_HOST_VARIANT_ARCH}_LIB})
 
     # NOTE(compnerd) workaround incorrectly extensioned import libraries from
     # the Windows SDK on case sensitive file systems.
-    list(APPEND library_search_directories
+    target_link_directories(${target} PRIVATE
       ${CMAKE_BINARY_DIR}/winsdk_lib_${SWIFT_HOST_VARIANT_ARCH}_symlinks)
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL HAIKU)
-    list(APPEND link_libraries "bsd" "atomic")
-    list(APPEND result "-Wl,-Bsymbolic")
+    target_link_libraries(${target} PRIVATE
+      atomic
+      bsd)
+    target_link_options(${target} PRIVATE
+      "SHELL:-Xlinker -Bsymbolic")
   elseif(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
-    list(APPEND link_libraries "dl" "log" "atomic")
-    # We need to add the math library, which is linked implicitly by libc++
-    list(APPEND result "-lm")
+    target_link_libraries(${target} PRIVATE
+      atomic
+      dl
+      log
+      # We need to add the math library, which is linked implicitly by libc++
+      m)
 
     # link against the custom C++ library
-    swift_android_cxx_libraries_for_arch(${SWIFT_HOST_VARIANT_ARCH} cxx_link_libraries)
-    list(APPEND link_libraries ${cxx_link_libraries})
+    swift_android_cxx_libraries_for_arch(${SWIFT_HOST_VARIANT_ARCH}
+      cxx_link_libraries)
+    target_link_libraries(${target} PRIVATE
+      ${cxx_link_libraries})
 
     # link against the ICU libraries
-    list(APPEND link_libraries
+    target_link_libraries(${target} PRIVATE
       ${SWIFT_ANDROID_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N}
       ${SWIFT_ANDROID_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC})
 
     swift_android_lib_for_arch(${SWIFT_HOST_VARIANT_ARCH}
       ${SWIFT_HOST_VARIANT_ARCH}_LIB)
-    foreach(path IN LISTS ${SWIFT_HOST_VARIANT_ARCH}_LIB)
-      list(APPEND library_search_directories ${path})
-    endforeach()
+    target_link_directories(${target} PRIVATE
+      ${${SWIFT_HOST_VARIANT_ARCH}_LIB})
   else()
     # If lto is enabled, we need to add the object path flag so that the LTO code
     # generator leaves the intermediate object file in a place where it will not
@@ -388,38 +392,37 @@ function(_add_host_variant_link_flags)
     # left in object files. So if the object file is removed when we go to
     # generate a dsym, the debug info is gone.
     if (SWIFT_TOOLS_ENABLE_LTO)
-      precondition(LFLAGS_LTO_OBJECT_NAME
-        MESSAGE "Should specify a unique name for the lto object")
-      set(lto_object_dir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR})
-      set(lto_object ${lto_object_dir}/${LFLAGS_LTO_OBJECT_NAME}-lto.o)
-        list(APPEND result "-Wl,-object_path_lto,${lto_object}")
-      endif()
+      target_link_options(${target} PRIVATE
+        "SHELL:-Xlinker -object_path_lto"
+        "SHELL:-Xlinker ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${target}-${SWIFT_HOST_VARIANT_SDK}-${SWIFT_HOST_VARIANT_ARCH}-lto${CMAKE_C_OUTPUT_EXTENSION}")
+    endif()
   endif()
 
   if(NOT "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_SDK}_ICU_UC}" STREQUAL "")
     get_filename_component(SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC_LIBDIR
       "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_SDK}_ICU_UC}" DIRECTORY)
-    list(APPEND library_search_directories "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC_LIBDIR}")
+    target_link_directories(${target} PRIVATE
+      "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC_LIBDIR}")
   endif()
   if(NOT "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N}" STREQUAL "")
     get_filename_component(SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_SDK}_ICU_I18N_LIBDIR
       "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N}" DIRECTORY)
-    list(APPEND library_search_directories "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N_LIBDIR}")
+    target_link_directories(${target} PRIVATE
+      "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N_LIBDIR}")
   endif()
 
   if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
     # FIXME: On Apple platforms, find_program needs to look for "ld64.lld"
     find_program(LDLLD_PATH "ld.lld")
     if((SWIFT_ENABLE_LLD_LINKER AND LDLLD_PATH AND NOT APPLE) OR
-      (SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS AND
-       NOT CMAKE_SYSTEM_NAME STREQUAL WINDOWS))
-      list(APPEND result "-fuse-ld=lld")
+       (SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS AND NOT CMAKE_SYSTEM_NAME STREQUAL WINDOWS))
+      target_link_options(${target} PRIVATE -fuse-ld=lld)
     elseif(SWIFT_ENABLE_GOLD_LINKER AND
-        "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
+           "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
       if(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
-        list(APPEND result "-fuse-ld=gold.exe")
+        target_link_options(${target} PRIVATE -fuse-ld=gold.exe)
       else()
-        list(APPEND result "-fuse-ld=gold")
+        target_link_options(${target} PRIVATE -fuse-ld=gold)
       endif()
     endif()
   endif()
@@ -431,19 +434,16 @@ function(_add_host_variant_link_flags)
   # TODO: Evaluate/enable -f{function,data}-sections --gc-sections for bfd,
   # gold, and lld.
   if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
-    if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    if(CMAKE_SYSTEM_NAME MATCHES Darwin)
       # See rdar://48283130: This gives 6MB+ size reductions for swift and
       # SourceKitService, and much larger size reductions for sil-opt etc.
-      list(APPEND result "-Wl,-dead_strip")
+      target_link_options(${target} PRIVATE
+        "SHELL:-Xlinker -dead_strip")
     endif()
   endif()
 
   get_maccatalyst_build_flavor(maccatalyst_build_flavor
     "${SWIFT_HOST_VARIANT_SDK}" "")
-
-  set("${LFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
-  set("${LFLAGS_LINK_LIBRARIES_VAR_NAME}" "${link_libraries}" PARENT_SCOPE)
-  set("${LFLAGS_LIBRARY_SEARCH_DIRECTORIES_VAR_NAME}" "${library_search_directories}" PARENT_SCOPE)
 endfunction()
 
 # Add a single variant of a new Swift library.
@@ -591,8 +591,6 @@ function(_add_swift_host_library_single target)
   set(c_compile_flags ${ASHLS_C_COMPILE_FLAGS})
   set(link_flags)
 
-  set(library_search_directories)
-
   _add_host_variant_c_compile_flags(RESULT_VAR_NAME c_compile_flags)
 
   if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
@@ -600,11 +598,7 @@ function(_add_swift_host_library_single target)
       list(APPEND c_compile_flags -D_WINDLL)
     endif()
   endif()
-  _add_host_variant_link_flags(
-    LTO_OBJECT_NAME "${target}-${SWIFT_HOST_VARIANT_SDK}-${SWIFT_HOST_VARIANT_ARCH}"
-    RESULT_VAR_NAME link_flags
-    LIBRARY_SEARCH_DIRECTORIES_VAR_NAME library_search_directories
-      )
+  _add_host_variant_link_flags(${target})
 
   # Set compilation and link flags.
   if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
@@ -629,8 +623,6 @@ function(_add_swift_host_library_single target)
 
   target_compile_options(${target} PRIVATE
     ${c_compile_flags})
-  target_link_options(${target} PRIVATE
-    ${link_flags})
   if(${SWIFT_HOST_VARIANT_SDK} IN_LIST SWIFT_APPLE_PLATFORMS)
     target_link_options(${target} PRIVATE
       "LINKER:-compatibility_version,1")
@@ -657,10 +649,6 @@ function(_add_swift_host_library_single target)
       endif()
     endif()
   endif()
-  target_link_libraries(${target} PRIVATE
-    ${link_libraries})
-  target_link_directories(${target} PRIVATE
-    ${library_search_directories})
 
   # Do not add code here.
 endfunction()
@@ -755,29 +743,14 @@ function(add_swift_host_tool executable)
   precondition(ASHT_SWIFT_COMPONENT
                MESSAGE "Swift Component is required to add a host tool")
 
-  # Determine compiler flags.
-  set(c_compile_flags)
-  set(link_flags)
-  set(link_libraries)
-  set(library_search_directories
-    ${SWIFTLIB_DIR}/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR})
-
   _add_host_variant_c_compile_flags(RESULT_VAR_NAME c_compile_flags)
-  _add_host_variant_link_flags(
-    LTO_OBJECT_NAME "${executable}-${SWIFT_HOST_VARIANT_SDK}-${SWIFT_HOST_VARIANT_ARCH}"
-    RESULT_VAR_NAME link_flags
-    LINK_LIBRARIES_VAR_NAME link_libraries
-    LIBRARY_SEARCH_DIRECTORIES_VAR_NAME library_search_directories)
 
   add_executable(${executable} ${ASHT_UNPARSED_ARGUMENTS})
   target_compile_options(${executable} PRIVATE
     ${c_compile_flags})
+  _add_host_variant_link_flags(${executable})
   target_link_directories(${executable} PRIVATE
-    ${library_search_directories})
-  target_link_options(${executable} PRIVATE
-    ${link_flags})
-  target_link_libraries(${executable} PRIVATE
-    ${link_libraries})
+    ${SWIFTLIB_DIR}/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR})
 
   set_target_properties(${executable} PROPERTIES
     FOLDER "Swift executables")
diff --git a/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake b/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
index 1235bb643fdd8..b2b59b981ea6c 100644
--- a/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
+++ b/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
@@ -46,11 +46,7 @@ function(add_sourcekit_default_compiler_flags target)
 
   # Add variant-specific flags.
   _add_host_variant_c_compile_flags(RESULT_VAR_NAME c_compile_flags)
-  _add_host_variant_link_flags(
-    LTO_OBJECT_NAME "${target}-${SWIFT_HOST_VARIANT_SDK}-${SWIFT_HOST_VARIANT_ARCH}"
-    RESULT_VAR_NAME link_flags
-    LINK_LIBRARIES_VAR_NAME link_libraries
-    LIBRARY_SEARCH_DIRECTORIES_VAR_NAME library_search_directories)
+  _add_host_variant_link_flags(${target})
 
   # Set compilation and link flags.
   if(${SWIFT_HOST_VARIANT_SDK} STREQUAL WINDOWS)
@@ -61,12 +57,6 @@ function(add_sourcekit_default_compiler_flags target)
   endif()
   target_compile_options(${target} PRIVATE
     -fblocks)
-  target_link_options(${target} PRIVATE
-    ${link_flags})
-  target_link_directories(${target} PRIVATE
-    ${library_search_directories})
-  target_link_libraries(${target} PRIVATE
-    ${link_libraries})
 endfunction()
 
 # Add a new SourceKit library.

From 123c2b06dc5e6500669dd1dd76914420e1e74ea7 Mon Sep 17 00:00:00 2001
From: Saleem Abdulrasool <compnerd@compnerd.org>
Date: Sat, 18 Apr 2020 12:18:55 -0700
Subject: [PATCH 4/7] build: convert output variables to target

Convert the out parameters for `_add_host_variant_c_compile_flags` to
use the target as an in-parameter.  Doing so allows us to set the
properties on the target directly rather than providing them as out
parameters which then get set subsequently.
---
 cmake/modules/AddSwift.cmake                  | 138 +++++++++---------
 .../cmake/modules/AddSwiftSourceKit.cmake     |   5 +-
 2 files changed, 69 insertions(+), 74 deletions(-)

diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index 8138dca1b0295..84ca246259e0e 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -159,23 +159,16 @@ function(_add_host_variant_c_compile_link_flags)
 endfunction()
 
 
-function(_add_host_variant_c_compile_flags)
-  set(oneValueArgs RESULT_VAR_NAME)
-  cmake_parse_arguments(CFLAGS
-    ""
-    "${oneValueArgs}"
-    ""
-    ${ARGN})
-
-  set(result ${${CFLAGS_RESULT_VAR_NAME}})
-
+function(_add_host_variant_c_compile_flags target)
   _add_host_variant_c_compile_link_flags(
     ANALYZE_CODE_COVERAGE FALSE
     RESULT_VAR_NAME result)
+  target_compile_options(${target} PRIVATE
+    ${result})
 
   is_build_type_optimized("${CMAKE_BUILD_TYPE}" optimized)
   if(optimized)
-    list(APPEND result "-O2")
+    target_compile_options(${target} PRIVATE -O2)
 
     # Omit leaf frame pointers on x86 production builds (optimized, no debug
     # info, and no asserts).
@@ -183,17 +176,17 @@ function(_add_host_variant_c_compile_flags)
     if(NOT debug AND NOT LLVM_ENABLE_ASSERTIONS)
       if(SWIFT_HOST_VARIANT_ARCH MATCHES "i?86")
         if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-          list(APPEND result "-momit-leaf-frame-pointer")
+          target_compile_options(${target} PRIVATE -momit-leaf-frame-pointer)
         else()
-          list(APPEND result "/Oy")
+          target_compile_options(${target} PRIVATE /Oy)
         endif()
       endif()
     endif()
   else()
     if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-      list(APPEND result "-O0")
+      target_compile_options(${target} PRIVATE -O0)
     else()
-      list(APPEND result "/Od")
+      target_compile_options(${target} PRIVATE /Od)
     endif()
   endif()
 
@@ -203,64 +196,73 @@ function(_add_host_variant_c_compile_flags)
     if(debuginfo)
       _compute_lto_flag("${SWIFT_TOOLS_ENABLE_LTO}" _lto_flag_out)
       if(_lto_flag_out)
-        list(APPEND result "-gline-tables-only")
+        target_compile_options(${target} PRIVATE -gline-tables-only)
       else()
-        list(APPEND result "-g")
+        target_compile_options(${target} PRIVATE -g)
       endif()
     else()
-      list(APPEND result "-g0")
+      target_compile_options(${target} PRIVATE -g0)
     endif()
   endif()
 
   if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
     # MSVC/clang-cl don't support -fno-pic or -fms-compatibility-version.
     if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-      list(APPEND result -fno-pic)
-      list(APPEND result "-fms-compatibility-version=1900")
+      target_compile_options(${target} PRIVATE
+        -fms-compatibility-version=1900
+        -fno-pic)
     endif()
 
-    list(APPEND result "-DLLVM_ON_WIN32")
-    list(APPEND result "-D_CRT_SECURE_NO_WARNINGS")
-    list(APPEND result "-D_CRT_NONSTDC_NO_WARNINGS")
+    target_compile_definitions(${target} PRIVATE
+      LLVM_ON_WIN32
+      _CRT_SECURE_NO_WARNINGS
+      _CRT_NONSTDC_NO_WARNINGS)
     if(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
-      list(APPEND result "-D_CRT_USE_BUILTIN_OFFSETOF")
+      target_compile_definitions(${target} PRIVATE
+        _CRT_USE_BUILTIN_OFFSETOF)
     endif()
     # TODO(compnerd) permit building for different families
-    list(APPEND result "-D_CRT_USE_WINAPI_FAMILY_DESKTOP_APP")
+    target_compile_definitions(${target} PRIVATE
+      _CRT_USE_WINAPI_FAMILY_DESKTOP_APP)
     if(SWIFT_HOST_VARIANT_ARCH MATCHES arm)
-      list(APPEND result "-D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE")
+      target_compile_definitions(${target} PRIVATE
+        _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE)
     endif()
-    list(APPEND result "-D_MT")
-    # TODO(compnerd) handle /MT
-    list(APPEND result "-D_DLL")
-    # NOTE: We assume that we are using VS 2015 U2+
-    list(APPEND result "-D_ENABLE_ATOMIC_ALIGNMENT_FIX")
-    # NOTE: We use over-aligned values for the RefCount side-table
-    # (see revision d913eefcc93f8c80d6d1a6de4ea898a2838d8b6f)
-    # This is required to build with VS2017 15.8+
-    list(APPEND result "-D_ENABLE_EXTENDED_ALIGNED_STORAGE=1")
+    target_compile_definitions(${target} PRIVATE
+      # TODO(compnerd) handle /MT
+      _MD
+      _DLL
+      # NOTE: We assume that we are using VS 2015 U2+
+      _ENABLE_ATOMIC_ALIGNMENT_FIX
+      # NOTE: We use over-aligned values for the RefCount side-table
+      # (see revision d913eefcc93f8c80d6d1a6de4ea898a2838d8b6f)
+      # This is required to build with VS2017 15.8+
+      _ENABLE_EXTENDED_ALIGNED_STORAGE=1)
 
     # msvcprt's std::function requires RTTI, but we do not want RTTI data.
     # Emulate /GR-.
     # TODO(compnerd) when moving up to VS 2017 15.3 and newer, we can disable
     # RTTI again
     if(SWIFT_COMPILER_IS_MSVC_LIKE)
-      list(APPEND result /GR-)
+      target_compile_options(${target} PRIVATE /GR-)
     else()
-      list(APPEND result -frtti)
-      list(APPEND result -Xclang;-fno-rtti-data)
+      target_compile_options(${target} PRIVATE
+        -frtti
+        "SHELL:-Xclang -fno-rtti-data")
     endif()
 
     # NOTE: VS 2017 15.3 introduced this to disable the static components of
     # RTTI as well.  This requires a newer SDK though and we do not have
     # guarantees on the SDK version currently.
-    list(APPEND result "-D_HAS_STATIC_RTTI=0")
+    target_compile_definitions(${target} PRIVATE
+      _HAS_STATIC_RTTI=0)
 
     # NOTE(compnerd) workaround LLVM invoking `add_definitions(-D_DEBUG)` which
     # causes failures for the runtime library when cross-compiling due to
     # undefined symbols from the standard library.
     if(NOT CMAKE_BUILD_TYPE STREQUAL Debug)
-      list(APPEND result "-U_DEBUG")
+      target_compile_options(${target} PRIVATE
+        -U_DEBUG)
     endif()
   endif()
 
@@ -274,52 +276,54 @@ function(_add_host_variant_c_compile_flags)
       # the build.
       if(CMAKE_C_COMPILER_ID MATCHES Clang AND CMAKE_C_COMPILER_VERSION
           VERSION_LESS 9.0.0)
-        list(APPEND result -mcx16)
+        target_compile_options(${target} PRIVATE -mcx16)
       endif()
     endif()
   endif()
 
   if(LLVM_ENABLE_ASSERTIONS)
-    list(APPEND result "-UNDEBUG")
+    target_compile_options(${target} PRIVATE -UNDEBUG)
   else()
-    list(APPEND result "-DNDEBUG")
+    target_compile_definitions(${target} PRIVATE -DNDEBUG)
   endif()
-  
+
   if(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS)
-    list(APPEND result "-DSWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS")
+    target_compile_definitions(${target} PRIVATE
+      SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS)
   endif()
 
   if(SWIFT_ANALYZE_CODE_COVERAGE)
-    list(APPEND result "-fprofile-instr-generate"
-                       "-fcoverage-mapping")
+    target_compile_options(${target} PRIVATE
+      -fprofile-instr-generate
+      -fcoverage-mapping)
   endif()
 
   if((SWIFT_HOST_VARIANT_ARCH STREQUAL armv7 OR
       SWIFT_HOST_VARIANT_ARCH STREQUAL aarch64) AND
      (SWIFT_HOST_VARIANT_SDK STREQUAL LINUX OR
       SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID))
-     list(APPEND result -funwind-tables)
+    target_compile_options(${target} PRIVATE -funwind-tables)
   endif()
 
   if(SWIFT_HOST_VARIANT_SDK STREQUAL ANDROID)
-    list(APPEND result -nostdinc++)
+    target_compile_options(${target} PRIVATE -nostdinc++)
     swift_android_libcxx_include_paths(CFLAGS_CXX_INCLUDES)
     swift_android_include_for_arch("${SWIFT_HOST_VARIANT_ARCH}"
       "${SWIFT_HOST_VARIANT_ARCH}_INCLUDE")
-    foreach(path IN LISTS CFLAGS_CXX_INCLUDES ${SWIFT_HOST_VARIANT_ARCH}_INCLUDE)
-      list(APPEND result "SHELL:${CMAKE_INCLUDE_SYSTEM_FLAG_C}${path}")
-    endforeach()
-    list(APPEND result "-D__ANDROID_API__=${SWIFT_ANDROID_API_LEVEL}")
+    target_include_directories(${target} SYSTEM PRIVATE
+      ${CFLAGS_CXX_INCLUDES}
+      ${${SWIFT_HOST_VARIANT_ARCH}_INCLUDE})
+    target_compile_definitions(${target} PRIVATE
+      __ANDROID_API__=${SWIFT_ANDROID_API_LEVEL})
   endif()
 
   if(SWIFT_HOST_VARIANT_SDK STREQUAL "LINUX")
     if(SWIFT_HOST_VARIANT_ARCH STREQUAL x86_64)
-      # this is the minimum architecture that supports 16 byte CAS, which is necessary to avoid a dependency to libatomic
-      list(APPEND result "-march=core2")
+      # this is the minimum architecture that supports 16 byte CAS, which is
+      # necessary to avoid a dependency to libatomic
+      target_compile_options(${target} PRIVATE -march=core2)
     endif()
   endif()
-
-  set("${CFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
 endfunction()
 
 function(_add_host_variant_link_flags target)
@@ -586,18 +590,16 @@ function(_add_swift_host_library_single target)
   # Call llvm_config() only for libraries that are part of the compiler.
   swift_common_llvm_config("${target}" ${ASHLS_LLVM_LINK_COMPONENTS})
 
-  # Collect compile and link flags for the static and non-static targets.
-  # Don't set PROPERTY COMPILE_FLAGS or LINK_FLAGS directly.
-  set(c_compile_flags ${ASHLS_C_COMPILE_FLAGS})
-  set(link_flags)
-
-  _add_host_variant_c_compile_flags(RESULT_VAR_NAME c_compile_flags)
-
+  target_compile_options(${target} PRIVATE
+    ${ASHLS_C_COMPILE_FLAGS})
   if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
     if(libkind STREQUAL SHARED)
-      list(APPEND c_compile_flags -D_WINDLL)
+      target_compile_definitions(${target} PRIVATE
+        _WINDLL)
     endif()
   endif()
+
+  _add_host_variant_c_compile_flags(${target})
   _add_host_variant_link_flags(${target})
 
   # Set compilation and link flags.
@@ -621,8 +623,6 @@ function(_add_swift_host_library_single target)
     endif()
   endif()
 
-  target_compile_options(${target} PRIVATE
-    ${c_compile_flags})
   if(${SWIFT_HOST_VARIANT_SDK} IN_LIST SWIFT_APPLE_PLATFORMS)
     target_link_options(${target} PRIVATE
       "LINKER:-compatibility_version,1")
@@ -743,11 +743,9 @@ function(add_swift_host_tool executable)
   precondition(ASHT_SWIFT_COMPONENT
                MESSAGE "Swift Component is required to add a host tool")
 
-  _add_host_variant_c_compile_flags(RESULT_VAR_NAME c_compile_flags)
 
   add_executable(${executable} ${ASHT_UNPARSED_ARGUMENTS})
-  target_compile_options(${executable} PRIVATE
-    ${c_compile_flags})
+  _add_host_variant_c_compile_flags(${executable})
   _add_host_variant_link_flags(${executable})
   target_link_directories(${executable} PRIVATE
     ${SWIFTLIB_DIR}/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR})
diff --git a/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake b/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
index b2b59b981ea6c..e841f248150df 100644
--- a/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
+++ b/tools/SourceKit/cmake/modules/AddSwiftSourceKit.cmake
@@ -41,11 +41,8 @@ endfunction()
 # FIXME: this is a HACK.  All SourceKit CMake code using this function should be
 # rewritten to use 'add_swift_host_library' or 'add_swift_target_library'.
 function(add_sourcekit_default_compiler_flags target)
-  set(c_compile_flags)
-  set(link_flags)
-
   # Add variant-specific flags.
-  _add_host_variant_c_compile_flags(RESULT_VAR_NAME c_compile_flags)
+  _add_host_variant_c_compile_flags(${target})
   _add_host_variant_link_flags(${target})
 
   # Set compilation and link flags.

From 8e736584fa86f11b0103877d79f83363c5045517 Mon Sep 17 00:00:00 2001
From: Saleem Abdulrasool <compnerd@compnerd.org>
Date: Sat, 18 Apr 2020 14:07:31 -0700
Subject: [PATCH 5/7] build: remove ICU handling in the android host handling

The host tools do not use ICU, only the standard library does.  Remove
the special handling in the host tool path for ICU.  This simplifies the
flag computation and allows the ICU handling to be sunk entirely into
the target specific paths.
---
 cmake/modules/AddSwift.cmake | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index 84ca246259e0e..23f69bc77102b 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -380,11 +380,6 @@ function(_add_host_variant_link_flags target)
     target_link_libraries(${target} PRIVATE
       ${cxx_link_libraries})
 
-    # link against the ICU libraries
-    target_link_libraries(${target} PRIVATE
-      ${SWIFT_ANDROID_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N}
-      ${SWIFT_ANDROID_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC})
-
     swift_android_lib_for_arch(${SWIFT_HOST_VARIANT_ARCH}
       ${SWIFT_HOST_VARIANT_ARCH}_LIB)
     target_link_directories(${target} PRIVATE
@@ -402,19 +397,6 @@ function(_add_host_variant_link_flags target)
     endif()
   endif()
 
-  if(NOT "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_SDK}_ICU_UC}" STREQUAL "")
-    get_filename_component(SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC_LIBDIR
-      "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_SDK}_ICU_UC}" DIRECTORY)
-    target_link_directories(${target} PRIVATE
-      "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC_LIBDIR}")
-  endif()
-  if(NOT "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N}" STREQUAL "")
-    get_filename_component(SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_SDK}_ICU_I18N_LIBDIR
-      "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N}" DIRECTORY)
-    target_link_directories(${target} PRIVATE
-      "${SWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N_LIBDIR}")
-  endif()
-
   if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
     # FIXME: On Apple platforms, find_program needs to look for "ld64.lld"
     find_program(LDLLD_PATH "ld.lld")

From 0bbc160a442572c6ccc950b396840b9ce72dfaa6 Mon Sep 17 00:00:00 2001
From: Saleem Abdulrasool <compnerd@compnerd.org>
Date: Sat, 18 Apr 2020 14:27:59 -0700
Subject: [PATCH 6/7] build: strength reduce `add_dependencies` usage

The two invocations here both had a single parameter passed to it.
Replace it with `add_dependencies` which already actually supports
multiple dependencies specified.  Sink the custom wrapper into the
usage location in `AddSwiftStdlib.cmake`.
---
 cmake/modules/AddSwift.cmake              | 28 ++---------------------
 stdlib/cmake/modules/AddSwiftStdlib.cmake | 16 +++++++++++++
 2 files changed, 18 insertions(+), 26 deletions(-)

diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index 23f69bc77102b..e8dbd09539c71 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -12,22 +12,6 @@ set(SWIFTLIB_DIR
 set(SWIFTSTATICLIB_DIR
     "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib/swift_static")
 
-function(add_dependencies_multiple_targets)
-  cmake_parse_arguments(
-      ADMT # prefix
-      "" # options
-      "" # single-value args
-      "TARGETS;DEPENDS" # multi-value args
-      ${ARGN})
-  precondition(ADMT_UNPARSED_ARGUMENTS NEGATE MESSAGE "unrecognized arguments: ${ADMT_UNPARSED_ARGUMENTS}")
-
-  if(NOT "${ADMT_DEPENDS}" STREQUAL "")
-    foreach(target ${ADMT_TARGETS})
-      add_dependencies("${target}" ${ADMT_DEPENDS})
-    endforeach()
-  endif()
-endfunction()
-
 function(_compute_lto_flag option out_var)
   string(TOLOWER "${option}" lowercase_option)
   if (lowercase_option STREQUAL "full")
@@ -522,6 +506,7 @@ function(_add_swift_host_library_single target)
 
   add_library("${target}" ${libkind} ${ASHLS_SOURCES})
   _set_target_prefix_and_suffix("${target}" "${libkind}" "${SWIFT_HOST_VARIANT_SDK}")
+  add_dependencies(${target} ${LLVM_COMMON_DEPENDS})
 
   if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
     swift_windows_include_for_arch(${SWIFT_HOST_VARIANT_ARCH} SWIFTLIB_INCLUDE)
@@ -562,13 +547,6 @@ function(_add_swift_host_library_single target)
   set_target_properties("${target}" PROPERTIES BUILD_WITH_INSTALL_RPATH YES)
   set_target_properties("${target}" PROPERTIES FOLDER "Swift libraries")
 
-  # Handle linking and dependencies.
-  add_dependencies_multiple_targets(
-      TARGETS "${target}"
-      DEPENDS
-        ${gyb_dependency_targets}
-        ${LLVM_COMMON_DEPENDS})
-
   # Call llvm_config() only for libraries that are part of the compiler.
   swift_common_llvm_config("${target}" ${ASHLS_LLVM_LINK_COMPONENTS})
 
@@ -731,6 +709,7 @@ function(add_swift_host_tool executable)
   _add_host_variant_link_flags(${executable})
   target_link_directories(${executable} PRIVATE
     ${SWIFTLIB_DIR}/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR})
+  add_dependencies(${executable} ${LLVM_COMMON_DEPENDS})
 
   set_target_properties(${executable} PROPERTIES
     FOLDER "Swift executables")
@@ -744,9 +723,6 @@ function(add_swift_host_tool executable)
       INSTALL_RPATH "@executable_path/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
   endif()
 
-  add_dependencies_multiple_targets(
-    TARGETS ${executable}
-    DEPENDS ${LLVM_COMMON_DEPENDS})
   llvm_update_compile_flags(${executable})
   swift_common_llvm_config(${executable} ${ASHT_LLVM_LINK_COMPONENTS})
   set_output_directory(${executable}
diff --git a/stdlib/cmake/modules/AddSwiftStdlib.cmake b/stdlib/cmake/modules/AddSwiftStdlib.cmake
index f34bcbbb42668..a5776238443dd 100644
--- a/stdlib/cmake/modules/AddSwiftStdlib.cmake
+++ b/stdlib/cmake/modules/AddSwiftStdlib.cmake
@@ -2,6 +2,22 @@
 include(AddSwift)
 include(SwiftSource)
 
+function(add_dependencies_multiple_targets)
+  cmake_parse_arguments(
+      ADMT # prefix
+      "" # options
+      "" # single-value args
+      "TARGETS;DEPENDS" # multi-value args
+      ${ARGN})
+  precondition(ADMT_UNPARSED_ARGUMENTS NEGATE MESSAGE "unrecognized arguments: ${ADMT_UNPARSED_ARGUMENTS}")
+
+  if(NOT "${ADMT_DEPENDS}" STREQUAL "")
+    foreach(target ${ADMT_TARGETS})
+      add_dependencies("${target}" ${ADMT_DEPENDS})
+    endforeach()
+  endif()
+endfunction()
+
 # Usage:
 # _add_target_variant_c_compile_link_flags(
 #   SDK sdk

From e6f2e6257f14e186a60c5479e3707b89a4ea74fa Mon Sep 17 00:00:00 2001
From: Saleem Abdulrasool <compnerd@compnerd.org>
Date: Thu, 20 Feb 2020 18:40:05 -0800
Subject: [PATCH 7/7] build: de-GYB_SOURCES the host tools

Use a newly introduced `swift_gyb_target_sources` to gyb and use the
generated sources when building.  Let CMake figure out when to run the
command, let it invoke the command properly, and indicate that the
sources being added to the target are generated.
---
 cmake/modules/AddSwift.cmake | 30 +++++++++++++++++++++---------
 lib/Basic/CMakeLists.txt     |  6 +++---
 lib/Parse/CMakeLists.txt     |  5 ++---
 lib/Syntax/CMakeLists.txt    |  5 ++---
 4 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake
index e8dbd09539c71..e8747c21b6c8f 100644
--- a/cmake/modules/AddSwift.cmake
+++ b/cmake/modules/AddSwift.cmake
@@ -4,6 +4,27 @@ include(SwiftXcodeSupport)
 include(SwiftWindowsSupport)
 include(SwiftAndroidSupport)
 
+function(_swift_gyb_target_sources target scope)
+  foreach(source ${ARGN})
+    get_filename_component(generated ${source} NAME_WLE)
+    get_filename_component(absolute ${source} REALPATH)
+
+    add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${generated}
+      COMMAND
+        $<TARGET_FILE:Python2::Interpreter> ${SWIFT_SOURCE_DIR}/utils/gyb -D CMAKE_SIZEOF_VOID_P=${CMAKE_SIZEOF_VOID_P} ${SWIFT_GYB_FLAGS} -o ${CMAKE_CURRENT_BINARY_DIR}/${generated}.tmp ${absolute}
+      COMMAND
+        ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_BINARY_DIR}/${generated}.tmp ${CMAKE_CURRENT_BINARY_DIR}/${generated}
+      COMMAND
+        ${CMAKE_COMMAND} -E remove ${CMAKE_CURRENT_BINARY_DIR}/${generated}.tmp
+      DEPENDS
+        ${absolute})
+    set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${generated} PROPERTIES
+      GENERATED TRUE)
+    target_sources(${target} ${scope}
+      ${CMAKE_CURRENT_BINARY_DIR}/${generated})
+  endforeach()
+endfunction()
+
 # SWIFTLIB_DIR is the directory in the build tree where Swift resource files
 # should be placed.  Note that $CMAKE_CFG_INTDIR expands to "." for
 # single-configuration builds.
@@ -446,7 +467,6 @@ function(_add_swift_host_library_single target)
         STATIC)
   set(single_parameter_options)
   set(multiple_parameter_options
-        GYB_SOURCES
         LLVM_LINK_COMPONENTS)
 
   cmake_parse_arguments(ASHLS
@@ -496,14 +516,6 @@ function(_add_swift_host_library_single target)
     set(libkind STATIC)
   endif()
 
-  if(ASHLS_GYB_SOURCES)
-    handle_gyb_sources(
-        gyb_dependency_targets
-        ASHLS_GYB_SOURCES
-        "${SWIFT_HOST_VARIANT_ARCH}")
-      set(ASHLS_SOURCES ${ASHLS_SOURCES} ${ASHLS_GYB_SOURCES})
-  endif()
-
   add_library("${target}" ${libkind} ${ASHLS_SOURCES})
   _set_target_prefix_and_suffix("${target}" "${libkind}" "${SWIFT_HOST_VARIANT_SDK}")
   add_dependencies(${target} ${LLVM_COMMON_DEPENDS})
diff --git a/lib/Basic/CMakeLists.txt b/lib/Basic/CMakeLists.txt
index 1c2df87cb77f1..c1ed3d503bebc 100644
--- a/lib/Basic/CMakeLists.txt
+++ b/lib/Basic/CMakeLists.txt
@@ -78,10 +78,10 @@ add_swift_host_library(swiftBasic STATIC
   # Platform-agnostic fallback TaskQueue implementation
   Default/TaskQueue.inc
 
-  GYB_SOURCES
-    UnicodeExtendedGraphemeClusters.cpp.gyb
-
   LLVM_LINK_COMPONENTS support)
+_swift_gyb_target_sources(swiftBasic PRIVATE
+    UnicodeExtendedGraphemeClusters.cpp.gyb)
+
 target_include_directories(swiftBasic PRIVATE
   ${UUID_INCLUDE})
 
diff --git a/lib/Parse/CMakeLists.txt b/lib/Parse/CMakeLists.txt
index d85e3d2969bfe..7158bdce8b24e 100644
--- a/lib/Parse/CMakeLists.txt
+++ b/lib/Parse/CMakeLists.txt
@@ -22,9 +22,8 @@ add_swift_host_library(swiftParse STATIC
   PersistentParserState.cpp
   Scope.cpp
   SyntaxParsingCache.cpp
-  SyntaxParsingContext.cpp
-
-  GYB_SOURCES
+  SyntaxParsingContext.cpp)
+_swift_gyb_target_sources(swiftParse PRIVATE
     ParsedSyntaxBuilders.cpp.gyb
     ParsedSyntaxNodes.cpp.gyb
     ParsedSyntaxRecorder.cpp.gyb)
diff --git a/lib/Syntax/CMakeLists.txt b/lib/Syntax/CMakeLists.txt
index 93ab40b71f004..29e18291f4e3f 100644
--- a/lib/Syntax/CMakeLists.txt
+++ b/lib/Syntax/CMakeLists.txt
@@ -8,9 +8,8 @@ add_swift_host_library(swiftSyntax STATIC
   RawSyntax.cpp
   Syntax.cpp
   SyntaxData.cpp
-  UnknownSyntax.cpp
-
-  GYB_SOURCES
+  UnknownSyntax.cpp)
+_swift_gyb_target_sources(swiftSyntax PRIVATE
     SyntaxNodes.cpp.gyb
     SyntaxBuilders.cpp.gyb
     SyntaxKind.cpp.gyb