Repository navigation
Expand file tree
/
Copy pathCMakeLists.txt
More file actions
243 lines (207 loc) · 9.76 KB
/
Copy pathCMakeLists.txt
File metadata and controls
243 lines (207 loc) · 9.76 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
# TODO(compnerd) once we have a newer CMake we should be able to use the new
# `Swift` LANGUAGE support in CMake to simplify the build. For now, just add
# the project so that it is possible to start working on extracting the Swift
# standard library from the Swift compiler build.
project(swift-stdlib LANGUAGES C CXX)
# CMake passes `-external:I` to clang-cl which results in the search order being
# altered, and this impacts the definitions of the intrinsics. When building
# with a MSVC toolset 19.29.30036.3 or newer, this will prevent the runtime from
8000
# being built on Windows. Since we know that we only support `clang-cl` as the
# compiler for the runtime due to the use of the Swift calling convention, we
# simply override the CMake behaviour unconditionally.
if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
set(CMAKE_INCLUDE_SYSTEM_FLAG_C "-imsvc ")
set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-imsvc ")
else()
set(CMAKE_INCLUDE_SYSTEM_FLAG_C "-Isystem")
set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-Isystem")
endif()
# Add path for custom CMake modules.
list(APPEND CMAKE_MODULE_PATH
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
if(SWIFT_BUILD_SDK_OVERLAY OR SWIFT_INCLUDE_TESTS)
set(SWIFT_BUILD_TEST_SUPPORT_MODULES_default TRUE)
else()
set(SWIFT_BUILD_TEST_SUPPORT_MODULES_default FALSE)
endif()
# TODO(compnerd) use a target to avoid re-creating this file all the time
function(generate_windows_vfs_overlay)
file(TO_CMAKE_PATH ${VCToolsInstallDir} VCToolsInstallDir)
file(TO_CMAKE_PATH ${UniversalCRTSdkDir} UniversalCRTSdkDir)
configure_file("${PROJECT_SOURCE_DIR}/cmake/WindowsVFS.yaml.in"
"${CMAKE_CURRENT_BINARY_DIR}/windows-vfs-overlay.yaml"
@ONLY)
endfunction()
if(WINDOWS IN_LIST SWIFT_SDKS)
generate_windows_vfs_overlay()
file(TO_CMAKE_PATH "${CMAKE_CURRENT_BINARY_DIR}/windows-vfs-overlay.yaml"
SWIFT_WINDOWS_VFS_OVERLAY)
endif()
#
# User-configurable options for the standard library.
#
# New options should be added to stdlib/cmake/modules/StdlibOptions.cmake,
# so that they are considered in configurations using StandaloneOverlay.cmake
# NOTE: Some of these variables are also initialized in StandaloneOverlay.cmake
# so that interfaces are emitted when overlays are separately built.
# TODO: migrate this section to StdlibOptions.cmake to reduce duplication
option(SWIFT_BUILD_TEST_SUPPORT_MODULES
"Whether to build StdlibUnittest and other test support modules. Defaults to On when SWIFT_BUILD_SDK_OVERLAY is On, or when SWIFT_INCLUDE_TESTS is On."
"${SWIFT_BUILD_TEST_SUPPORT_MODULES_default}")
# New options should be added to stdlib/cmake/modules/StdlibOptions.cmake,
# so that they are considered in configurations using StandaloneOverlay.cmake
include(StdlibOptions)
#
# End of user-configurable options.
#
set(SWIFT_STDLIB_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
# Remove llvm-project/llvm/include directory from -I search part when building
# the stdlib. We have our own fork of LLVM includes (Support, ADT) in
# stdlib/include/llvm and we don't want to silently use headers from LLVM.
get_property(stdlib_include_directories DIRECTORY PROPERTY INCLUDE_DIRECTORIES)
list(REMOVE_ITEM stdlib_include_directories "${LLVM_MAIN_INCLUDE_DIR}")
set_property(DIRECTORY PROPERTY INCLUDE_DIRECTORIES ${stdlib_include_directories})
include(AddSwiftStdlib)
# Create convenience targets for the Swift standard library.
# NOTE(compnerd) this will pass the *build* configuration to the *host*
# libraries. Explicitly indicate to CMake that it should **NOT** track the
# implicit language runtimes. This can go away once we migrate to an external
# project with its own configure with the CMAKE_SYSTEM_NAME set rather than
# using the custom cross-compilation solution
set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "")
set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "")
set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "")
set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "")
set(CMAKE_C_VISIBILITY_PRESET hidden)
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
set(CMAKE_VISIBILITY_INLINES_HIDDEN YES)
if(SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER)
if(NOT "${CMAKE_C_COMPILER_ID}" MATCHES "Clang")
message(FATAL_ERROR "Building the swift runtime is not supported with ${CMAKE_C_COMPILER_ID}. Use the just-built clang instead.")
else()
message(WARNING "Building the swift runtime using the host compiler, and not the just-built clang.")
endif()
else()
# If we use Clang-cl or MSVC, CMake provides default compiler and linker flags that are incompatible
# with the frontend of Clang or Clang++.
if(SWIFT_COMPILER_IS_MSVC_LIKE)
set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang-cl")
set(CMAKE_C_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang-cl")
else()
set(CMAKE_CXX_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang++")
set(CMAKE_C_COMPILER "${SWIFT_NATIVE_CLANG_TOOLS_PATH}/clang")
endif()
if(CMAKE_C_COMPILER_LAUNCHER MATCHES ".*distcc")
set(CMAKE_C_COMPILER_LAUNCHER "")
endif()
if(CMAKE_CXX_COMPILER_LAUNCHER MATCHES ".*distcc")
set(CMAKE_CXX_COMPILER_LAUNCHER "")
endif()
# The sanitizers require using the same version of the compiler for
# everything and there are various places where we link runtime code with
# code built by the host compiler. Disable sanitizers for the runtime for
# now.
add_compile_options(-fno-sanitize=all)
endif()
# Do not enforce checks for LLVM's ABI-breaking build settings.
# The Swift runtime uses some header-only code from LLVM's ADT classes,
# but we do not want to link libSupport into the runtime. These checks rely
# on the presence of symbols in libSupport to identify how the code was
# built and cause link failures for mismatches. Without linking that library,
# we
8000
get link failures regardless, so instead, this just disables the checks.
add_compile_definitions($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING=1>)
set(SWIFT_STDLIB_LIBRARY_BUILD_TYPES)
if(SWIFT_BUILD_DYNAMIC_STDLIB)
list(APPEND SWIFT_STDLIB_LIBRARY_BUILD_TYPES SHARED)
endif()
if(SWIFT_BUILD_STATIC_STDLIB)
list_intersect("${SWIFT_DARWIN_PLATFORMS}" "${SWIFT_SDKS}" building_darwin_sdks)
if(building_darwin_sdks)
message(SEND_ERROR "cannot build static standard library for Darwin SDKs")
else()
list(APPEND SWIFT_STDLIB_LIBRARY_BUILD_TYPES STATIC)
endif()
endif()
function(swift_create_stdlib_targets name variant define_all_alias)
if(NOT variant STREQUAL "")
set(variant "-${variant}")
endif()
if(define_all_alias)
add_custom_target(${name}${variant}-all)
set_target_properties(${name}${variant}-all
PROPERTIES
FOLDER "Swift libraries/Aggregate")
endif()
foreach(sdk ${SWIFT_SDKS})
add_custom_target(${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}${variant})
set_target_properties(${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}${variant}
PROPERTIES
FOLDER "Swift libraries/Aggregate")
foreach(arch ${SWIFT_SDK_${sdk}_ARCHITECTURES})
set(target_variant -${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch})
add_custom_target(${name}${target_variant}${variant})
set_target_properties(${name}${target_variant}${variant}
PROPERTIES
FOLDER "Swift libraries/Aggregate")
if(define_all_alias)
add_dependencies(${name}${variant}-all
${name}${target_variant}${variant})
endif()
add_dependencies(${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}${variant}
${name}${target_variant}${variant})
endforeach()
endforeach()
if(NOT define_all_alias)
set(ALL_keyword ALL)
endif()
# When cross-compiling host tools for multiple architectures, targeting a
# different SDK, the primary variant is not one of the variants being built,
# so it can't be added as a target here. build-script will invoke the
# more-specific target, so just skip creating this target and warn in case
# someone is using the CMake more directly.
if(SWIFT_PRIMARY_VARIANT_SDK IN_LIST SWIFT_SDKS)
add_custom_target(${name}${variant}
${ALL_keyword}
DEPENDS
${name}${SWIFT_PRIMARY_VARIANT_SUFFIX}${variant})
set_target_properties(${name}${variant}
PROPERTIES
FOLDER "Swift libraries/Aggregate")
else()
message(WARNING "Primary variant ${SWIFT_PRIMARY_VARIANT_SDK} is not being built, not creating ${name}${variant} alias target for it.")
endif()
endfunction()
if("${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR}" STREQUAL "singlethreaded"
AND NOT SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY)
message(SEND_ERROR "Cannot enable the single-threaded global executor without enabling SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY")
endif()
if(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
if(SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY)
message(SEND_ERROR "Cannot use the single-threaded concurrency with task-to-thread concurrency model")
endif()
if(NOT "${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR}" STREQUAL "none")
message(SEND_ERROR "Task-to-thread concurrency model requires no global executor")
endif()
else()
if("${SWIFT_CONCURRENCY_GLOBAL_EXECUTOR}" STREQUAL "none")
message(SEND_ERROR "Only task-to-thread concurrency model is usable with no global executor")
endif()
endif()
swift_create_stdlib_targets("swift-stdlib" "" TRUE)
if(SWIFT_STDLIB_ENABLE_SIB_TARGETS)
swift_create_stdlib_targets("swift-stdlib" "sib" TRUE)
swift_create_stdlib_targets("swift-stdlib" "sibopt" TRUE)
swift_create_stdlib_targets("swift-stdlib" "sibgen" TRUE)
endif()
swift_create_stdlib_targets("swift-test-stdlib" "" FALSE)
# Create the libexec targets
swift_create_stdlib_targets("swift-libexec" "" TRUE)
swift_create_stdlib_targets("swift-test-libexec" "" FALSE)
# FIXME: Include the toolchain directory before the public directory. Otherwise
# the clang resource directory symlink stops installing correctly.
add_subdirectory(toolchain)
add_subdirectory(public)
if(SWIFT_STDLIB_BUILD_PRIVATE)
add_subdirectory(private)
endif()
add_subdirectory(tools)