AddPureSwift.cmake

include(macCatalystUtils)

# Workaround a cmake bug, see the corresponding function in swift-syntax
function(force_add_dependencies TARGET)
 foreach(DEPENDENCY ${ARGN})
 string(REGEX REPLACE [<>:\"/\\|?*] _ sanitized ${DEPENDENCY})
 set(depfile"${CMAKE_CURRENT_BINARY_DIR}/forced-${sanitized}-dep.swift")
 add_custom_command(OUTPUT${depfile}
COMMAND${CMAKE_COMMAND} -E touch ${depfile}
DEPENDS${DEPENDENCY}
 )
 target_sources(${TARGET}PRIVATE${depfile})
 endforeach()
endfunction()

function(force_target_link_libraries TARGET)
 target_link_libraries(${TARGET}${ARGN})

 cmake_parse_arguments(ARGS "PUBLIC;PRIVATE;INTERFACE"""""${ARGN})
 force_add_dependencies(${TARGET}${ARGS_UNPARSED_ARGUMENTS})
endfunction()

# Add compile options shared between libraries and executables.
function(_add_host_swift_compile_options name)
# Avoid introducing an implicit dependency on the string-processing library.
 if(SWIFT_SUPPORTS_DISABLE_IMPLICIT_STRING_PROCESSING_MODULE_IMPORT)
 target_compile_options(${name}PRIVATE
"$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -disable-implicit-string-processing-module-import>")
 endif()

# Emitting module seprately doesn't give us any benefit.
 target_compile_options(${name}PRIVATE
"$<$<COMPILE_LANGUAGE:Swift>:-no-emit-module-separately-wmo>")

 if(SWIFT_ANALYZE_CODE_COVERAGE)
 set(_cov_flags $<$<COMPILE_LANGUAGE:Swift>:-profile-generate -profile-coverage-mapping>)
 target_compile_options(${name}PRIVATE${_cov_flags})
 target_link_options(${name}PRIVATE${_cov_flags})
 endif()

 if("${BRIDGING_MODE}"STREQUAL"PURE")
 target_compile_options(${name}PRIVATE
"$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xcc -DPURE_BRIDGING_MODE>")
 endif()

# The compat56 library is not available in current toolchains. The stage-0
# compiler will build fine since the builder compiler is not aware of the 56
# compat library, but the stage-1 and subsequent stage compilers will fail as
# the stage-0 compiler is aware and will attempt to include the appropriate
# compatibility library. We should turn this back on once we are building the
# compiler correctly.
# Note: This is safe at the moment because the 5.6 compat library only
# contains concurrency runtime fixes, and the compiler frontend does not
# use concurrency at the moment.
 target_compile_options(${name}PRIVATE
 $<$<COMPILE_LANGUAGE:Swift>:-runtime-compatibility-version>
 $<$<COMPILE_LANGUAGE:Swift>:none>)

 target_compile_options(${name}PRIVATE $<$<COMPILE_LANGUAGE:Swift>:-target;${SWIFT_HOST_TRIPLE}>)
 if(BOOTSTRAPPING_MODE STREQUAL"CROSSCOMPILE")
 add_dependencies(${name} swift-stdlib-${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}-${SWIFT_HOST_VARIANT_ARCH})
 target_compile_options(${name}PRIVATE
 $<$<COMPILE_LANGUAGE:Swift>:-sdk;${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH};>
 $<$<COMPILE_LANGUAGE:Swift>:-resource-dir;${SWIFTLIB_DIR};>)
 if(SWIFT_HOST_VARIANT_SDK STREQUAL"ANDROID"ANDNOT"${SWIFT_ANDROID_NDK_PATH}"STREQUAL"")
 swift_android_tools_path(${SWIFT_HOST_VARIANT_ARCH} tools_path)
 target_compile_options(${name}PRIVATE $<$<COMPILE_LANGUAGE:Swift>:-tools-directory;${tools_path};>)
 endif()
 endif()

 target_compile_options(${name}PRIVATE
 $<$<COMPILE_LANGUAGE:Swift>:-color-diagnostics>
 )

 if(LLVM_ENABLE_ASSERTIONS)
 target_compile_options(${name}PRIVATE"$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xcc -UNDEBUG>")
 else()
 target_compile_options(${name}PRIVATE"$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xcc -DNDEBUG>")
 endif()
endfunction()

# Set compile options for C/C++ interop
function(_set_swift_cxx_interop_options name)
 target_compile_options(${name}PRIVATE
"SHELL: -Xcc -std=c++17 -Xcc -DCOMPILED_WITH_SWIFT"

# FIXME: Needed to work around an availability issue with CxxStdlib
"SHELL: -Xfrontend -disable-target-os-checking"

# Necessary to avoid treating IBOutlet and IBAction as keywords
"SHELL:-Xcc -UIBOutlet -Xcc -UIBAction -Xcc -UIBInspectable"
 )

 if(CMAKE_SYSTEM_NAMESTREQUAL"Windows")
 target_compile_options(${name}PRIVATE
# Make 'offsetof()' a const value.
"SHELL:-Xcc -D_CRT_USE_BUILTIN_OFFSETOF"
# Workaround for https://github.com/swiftlang/llvm-project/issues/7172
"SHELL:-Xcc -Xclang -Xcc -fmodule-format=raw"
 )
 endif()

# Prior to 5.9, we have to use the experimental flag for C++ interop.
 if (CMAKE_Swift_COMPILER_VERSION VERSION_LESS 5.9)
 target_compile_options(${name}PRIVATE
"SHELL:-Xfrontend -enable-experimental-cxx-interop"
 )
 else()
 target_compile_options(${name}PRIVATE
"-cxx-interoperability-mode=default"
 )
 endif()
endfunction()

function(_set_pure_swift_link_flags name relpath_to_lib_dir)
 if(SWIFT_HOST_VARIANT_SDK MATCHES"LINUX|ANDROID|OPENBSD|FREEBSD")
# Don't add builder's stdlib RPATH automatically.
 target_compile_options(${name}PRIVATE
 $<$<COMPILE_LANGUAGE:Swift>:-no-toolchain-stdlib-rpath>
 )

 set_property(TARGET${name}
APPEND PROPERTY INSTALL_RPATH
# At runtime, use swiftCore in the current just-built toolchain.
# NOTE: This relies on the ABI being the same as the builder.
"$ORIGIN/${relpath_to_lib_dir}swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}"
 )
# NOTE: At this point we don't have any pure swift executables/shared
# libraries required for building runtime/stdlib. So we don't need to add
# RPATH to the builder's runtime.
 endif()
endfunction()

function(_set_pure_swift_profile_flags target_name)
# This replicates the code existing in LLVM llvm/cmake/modules/HandleLLVMOptions.cmake
# The second part of the clause replicates the LINKER_IS_LLD_LINK of the
# original.
 if(LLVM_BUILD_INSTRUMENTED ANDNOT (SWIFT_COMPILER_IS_MSVC_LIKE AND SWIFT_USE_LINKER STREQUAL"lld"))
 string(TOUPPER "${LLVM_BUILD_INSTRUMENTED}" uppercase_LLVM_BUILD_INSTRUMENTED)
 if(LLVM_ENABLE_IR_PGO OR uppercase_LLVM_BUILD_INSTRUMENTED STREQUAL"IR")
 target_link_options(${target_name}PRIVATE
"SHELL:-Xclang-linker -fprofile-generate=\"${LLVM_PROFILE_DATA_DIR}\"")
 elseif(uppercase_LLVM_BUILD_INSTRUMENTED STREQUAL"CSIR")
 target_link_options(${target_name}PRIVATE
"SHELL:-Xclang-linker -fcs-profile-generate=\"${LLVM_CSPROFILE_DATA_DIR}\"")
 else()
 target_link_options(${target_name}PRIVATE
"SHELL:-Xclang-linker -fprofile-instr-generate=\"${LLVM_PROFILE_FILE_PATTERN}\"")
 endif()
 endif()
endfunction()

function(_set_pure_swift_package_options target_name package_name)
 if(NOT package_name ORNOT Swift_COMPILER_PACKAGE_CMO_SUPPORT)
 return()
 endif()

# Enable package CMO if possible.
# NOTE: '-enable-library-evolution' is required for package CMO even when we
# don't need '.swiftinterface'. E.g. executables.
 if(Swift_COMPILER_PACKAGE_CMO_SUPPORT STREQUAL"IMPLEMENTED")
 target_compile_options("${target_name}"PRIVATE
"-enable-library-evolution"
"SHELL:-package-name ${package_name}"
"SHELL:-Xfrontend -package-cmo"
"SHELL:-Xfrontend -allow-non-resilient-access"
 )
 elseif(Swift_COMPILER_PACKAGE_CMO_SUPPORT STREQUAL"EXPERIMENTAL")
 target_compile_options("${target_name}"PRIVATE
"-enable-library-evolution"
"SHELL:-package-name ${package_name}"
"SHELL:-Xfrontend -experimental-package-cmo"
"SHELL:-Xfrontend -experimental-allow-non-resilient-access"
"SHELL:-Xfrontend -experimental-package-bypass-resilience"
 )
 endif()
endfunction()

# Add a new "pure" Swift host library.
#
# "Pure" Swift host libraries can only contain Swift code, and will be built
# with the host compiler. They are always expected to be part of the built
# compiler, without bootstrapping.
#
# All of these libraries depend on the swift-syntax stack, since they are
# meant to be part of the compiler.
#
# Usage:
# add_pure_swift_host_library(name
# [SHARED]
# [STATIC]
# [LLVM_LINK_COMPONENTS comp1 ...]
# source1 [source2 source3 ...])
#
# name
# Name of the library (e.g., swiftParse).
#
# SHARED
# Build a shared library.
#
# STATIC
# Build a static library.
#
# CXX_INTEROP
# Use C++ interop.
#
# EMIT_MODULE
# Emit '.swiftmodule' to
#
# PACKAGE_NAME
# Name of the Swift package this library belongs to.
#
# DEPENDENCIES
# Target names to pass target_link_library
#
# SWIFT_DEPENDENCIES
# Target names to pass force_target_link_library.
# TODO: Remove this and use DEPENDENCIES when CMake is fixed
#
# source1 ...
# Sources to add into this library.
function(add_pure_swift_host_library name)
 if (NOT SWIFT_BUILD_SWIFT_SYNTAX)
 message(STATUS"Not building ${name} because swift-syntax is not available")
 return()
 endif()

# Option handling
 set(options
 SHARED
STATIC
 CXX_INTEROP
 EMIT_MODULE)
 set(single_parameter_options
 PACKAGE_NAME)
 set(multiple_parameter_options
 DEPENDENCIES
 SWIFT_DEPENDENCIES)

 cmake_parse_arguments(APSHL
"${options}"
"${single_parameter_options}"
"${multiple_parameter_options}"
${ARGN})
 set(APSHL_SOURCES ${APSHL_UNPARSED_ARGUMENTS})

 translate_flags(APSHL "${options}")

# Determine what kind of library we're building.
 if(APSHL_SHARED)
 set(libkind SHARED)
 elseif(APSHL_STATIC)
 set(libkind STATIC)
 endif()

# Create the library.
 add_library(${name}${libkind}${APSHL_SOURCES})
 _add_host_swift_compile_options(${name})
 _set_pure_swift_package_options(${name}"${APSHL_PACKAGE_NAME}")
 if(APSHL_CXX_INTEROP)
 _set_swift_cxx_interop_options(${name})
 endif()

 set_property(TARGET${name}
 PROPERTY BUILD_WITH_INSTALL_RPATHYES)

 if(APSHL_SHARED ANDCMAKE_SYSTEM_NAMESTREQUAL"Darwin")
# Allow install_name_tool to update paths (for rdar://109473564)
 set_property(TARGET${name} APPEND_STRING PROPERTY
LINK_FLAGS" -Xlinker -headerpad_max_install_names")
 endif()

# Respect LLVM_COMMON_DEPENDS if it is set.
#
# LLVM_COMMON_DEPENDS if a global variable set in ./lib that provides targets
# such as swift-syntax or tblgen that all LLVM/Swift based tools depend on. If
# we don't have it defined, then do not add the dependency since some parts of
# swift host tools do not interact with LLVM/Swift tools and do not define
# LLVM_COMMON_DEPENDS.
 if (LLVM_COMMON_DEPENDS)
 add_dependencies(${name}${LLVM_COMMON_DEPENDS})
 endif()

# Depends on all '*.h' files in 'include/module.modulemap'.
 force_add_dependencies(${name} importedHeaderDependencies)

# Link against dependencies.
 target_link_libraries(${name}PUBLIC
${APSHL_DEPENDENCIES}
 )
# TODO: Change to target_link_libraries when cmake is fixed
 force_target_link_libraries(${name}PUBLIC
${APSHL_SWIFT_DEPENDENCIES}
 )

 if(APSHL_EMIT_MODULE)
 set(module_triple "${SWIFT_HOST_MODULE_TRIPLE}")
 set(module_dir "${SWIFT_HOST_LIBRARIES_DEST_DIR}")
 set(module_base "${module_dir}/${name}.swiftmodule")
 set(module_file "${module_base}/${module_triple}.swiftmodule")
 set(module_interface_file "${module_base}/${module_triple}.swiftinterface")
 set(module_private_interface_file "${module_base}/${module_triple}.private.swiftinterface")
 set(module_sourceinfo_file "${module_base}/${module_triple}.swiftsourceinfo")

# Create the module directory.
 add_custom_command(
TARGET${name}
PRE_BUILD
COMMAND"${CMAKE_COMMAND}" -E make_directory ${module_base}
COMMENT"Generating module directory for ${name}")

# Configure the emission of the Swift module files.
 target_compile_options("${name}"PRIVATE
 $<$<COMPILE_LANGUAGE:Swift>:
 -module-name;$<TARGET_PROPERTY:${name},Swift_MODULE_NAME>;
 -enable-library-evolution;
 -emit-module-path;${module_file};
 -emit-module-source-info-path;${module_sourceinfo_file};
 -emit-module-interface-path;${module_interface_file};
 -emit-private-module-interface-path;${module_private_interface_file}
 >)
 else()
# Emit a swiftmodule in the current directory.
 set(module_dir "${CMAKE_CURRENT_BINARY_DIR}/modules")
 set(module_file "${module_dir}/${name}.swiftmodule")
 endif()

 set_target_properties(${name} PROPERTIES
# Set the default module name to the target name.
 Swift_MODULE_NAME ${name}
# Install the Swift module into the appropriate location.
 Swift_MODULE_DIRECTORY ${module_dir}
# NOTE: workaround for CMake not setting up include flags.
INTERFACE_INCLUDE_DIRECTORIES${module_dir})

# Workaround to touch the library and its objects so that we don't
# continually rebuild (again, see corresponding change in swift-syntax).
 add_custom_command(
TARGET${name}
 POST_BUILD
COMMAND"${CMAKE_COMMAND}" -E touch_nocreate $<TARGET_FILE:${name}> $<TARGET_OBJECTS:${name}> "${module_file}"
COMMAND_EXPAND_LISTS
COMMENT"Update mtime of library outputs workaround")

# Downstream linking should include the swiftmodule in debug builds to allow lldb to
# work correctly. Only do this on Darwin since neither gold (currently used by default
# on Linux), nor the default Windows linker 'link' support '-add_ast_path'.
 is_build_type_with_debuginfo("${CMAKE_BUILD_TYPE}" debuginfo)
 if(debuginfo AND SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
 target_link_options(${name}PUBLIC"SHELL:-Xlinker -add_ast_path -Xlinker ${module_file}")
 endif()

 if(LLVM_USE_LINKER)
 target_link_options(${name}PRIVATE
"-use-ld=${LLVM_USE_LINKER}"
 )
 endif()

 _set_pure_swift_profile_flags(${name})

# Enable build IDs
 if(SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_USE_BUILD_ID)
 target_link_options(${name}PRIVATE
"SHELL:-Xlinker --build-id=sha1")
 endif()

# Export this target.
 set_property(GLOBALAPPEND PROPERTY SWIFT_EXPORTS ${name})
endfunction()

# Add a new "pure" Swift host tool.
#
# "Pure" Swift host tools can only contain Swift code, and will be built
# with the host compiler.
#
# Usage:
# add_pure_swift_host_tool(name
# [DEPENDENCIES dep1 ...]
# [SWIFT_DEPENDENCIES swiftdep1 ...]
# source1 [source2 source3 ...])
#
# name
# Name of the tool (e.g., swift-frontend).
#
# PACKAGE_NAME
# Name of the Swift package this executable belongs to.
#
# DEPENDENCIES
# Target names to pass target_link_library
#
# SWIFT_DEPENDENCIES
# Target names to pass force_target_link_library.
# TODO: Remove this and use DEPENDENCIES when CMake is fixed
#
# source1 ...
# Sources to add into this tool.
function(add_pure_swift_host_tool name)
 if (NOT SWIFT_BUILD_SWIFT_SYNTAX)
 message(STATUS"Not building ${name} because swift-syntax is not available")
 return()
 endif()

# Option handling
 set(options)
 set(single_parameter_options
 SWIFT_COMPONENT
 PACKAGE_NAME)
 set(multiple_parameter_options
 DEPENDENCIES
 SWIFT_DEPENDENCIES)

 cmake_parse_arguments(APSHT
"${options}"
"${single_parameter_options}"
"${multiple_parameter_options}"
${ARGN})
 set(APSHT_SOURCES ${APSHT_UNPARSED_ARGUMENTS})

# Create the library.
 add_executable(${name}${APSHT_SOURCES})
 _add_host_swift_compile_options(${name})
 _set_pure_swift_link_flags(${name}"../lib/")
 _set_pure_swift_package_options(${name}"${APSHT_PACKAGE_NAME}")

 if(SWIFT_HOST_VARIANT_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
 set_property(TARGET${name}
APPEND PROPERTY INSTALL_RPATH
"@executable_path/../lib/swift/host")
 elseif(SWIFT_HOST_VARIANT_SDK MATCHES"LINUX|ANDROID|OPENBSD|FREEBSD")
 set_property(TARGET${name}
APPEND PROPERTY INSTALL_RPATH
"$ORIGIN/../lib/swift/host")
 endif()

 set_property(TARGET${name}
 PROPERTY BUILD_WITH_INSTALL_RPATHYES)

# Respect LLVM_COMMON_DEPENDS if it is set.
#
# LLVM_COMMON_DEPENDS if a global variable set in ./lib that provides targets
# such as swift-syntax or tblgen that all LLVM/Swift based tools depend on. If
# we don't have it defined, then do not add the dependency since some parts of
# swift host tools do not interact with LLVM/Swift tools and do not define
# LLVM_COMMON_DEPENDS.
 if (LLVM_COMMON_DEPENDS)
 add_dependencies(${name}${LLVM_COMMON_DEPENDS})
 endif()

# Depends on all '*.h' files in 'include/module.modulemap'.
 force_add_dependencies(${name} importedHeaderDependencies)

# Link against dependencies.
 target_link_libraries(${name}PUBLIC
${APSHT_DEPENDENCIES}
 )
# TODO: Change to target_link_libraries when cmake is fixed
 force_target_link_libraries(${name}PUBLIC
${APSHT_SWIFT_DEPENDENCIES}
 )

# Make sure we can use the host libraries.
 target_include_directories(${name}PUBLIC
"${SWIFT_HOST_LIBRARIES_DEST_DIR}")
 target_link_directories(${name}PUBLIC
"${SWIFT_HOST_LIBRARIES_DEST_DIR}")

 if(LLVM_USE_LINKER)
 target_link_options(${name}PRIVATE
"-use-ld=${LLVM_USE_LINKER}"
 )
 endif()

# Enable build IDs
 if(SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_USE_BUILD_ID)
 target_link_options(${name}PRIVATE
"SHELL:-Xlinker --build-id=sha1")
 endif()

# Workaround to touch the library and its objects so that we don't
# continually rebuild (again, see corresponding change in swift-syntax).
 add_custom_command(
TARGET${name}
 POST_BUILD
COMMAND"${CMAKE_COMMAND}" -E touch_nocreate $<TARGET_FILE:${name}> $<TARGET_OBJECTS:${name}>
COMMAND_EXPAND_LISTS
COMMENT"Update mtime of executable outputs workaround")

# Even worse hack - ${name}.swiftmodule is added as an output, even though
# this is an executable target. Just touch it all the time to avoid having
# to rebuild it every time.
 add_custom_command(
TARGET${name}
 POST_BUILD
COMMAND"${CMAKE_COMMAND}" -E touch "${CMAKE_CURRENT_BINARY_DIR}/${name}.swiftmodule"
COMMAND_EXPAND_LISTS
COMMENT"Update mtime of executable outputs workaround")

 if(NOT APSHT_SWIFT_COMPONENT STREQUAL no_component)
 add_dependencies(${APSHT_SWIFT_COMPONENT}${name})
 swift_install_in_component(TARGETS ${name}
COMPONENT${APSHT_SWIFT_COMPONENT}
 RUNTIME DESTINATION bin)
 swift_is_installing_component(${APSHT_SWIFT_COMPONENT} is_installing)
 endif()

 if(NOT is_installing)
 set_property(GLOBALAPPEND PROPERTY SWIFT_BUILDTREE_EXPORTS ${name})
 else()
 set_property(GLOBALAPPEND PROPERTY SWIFT_EXPORTS ${name})
 endif()

 _set_pure_swift_profile_flags(${name})
endfunction()