mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
65505d197b
When building the swift compler with "Debug" configuration, modules written in Swift must be linked to swiftOnoneSupport. Explicitly link it as some linker doesn't auto-link it. rdar://162631685
520 lines
19 KiB
CMake
520 lines
19 KiB
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" AND NOT "${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_NAME STREQUAL "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 AND NOT (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 OR NOT 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_RPATH YES)
|
|
|
|
if(APSHL_SHARED AND CMAKE_SYSTEM_NAME STREQUAL "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(CMAKE_BUILD_TYPE STREQUAL "Debug")
|
|
target_link_libraries(${name} PUBLIC swiftSwiftOnoneSupport)
|
|
endif()
|
|
|
|
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(GLOBAL APPEND 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_RPATH YES)
|
|
|
|
# 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}
|
|
)
|
|
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
|
|
target_link_libraries(${name} PUBLIC swiftSwiftOnoneSupport)
|
|
endif()
|
|
|
|
# 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(GLOBAL APPEND PROPERTY SWIFT_BUILDTREE_EXPORTS ${name})
|
|
else()
|
|
set_property(GLOBAL APPEND PROPERTY SWIFT_EXPORTS ${name})
|
|
endif()
|
|
|
|
_set_pure_swift_profile_flags(${name})
|
|
endfunction()
|