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
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
|
add_subdirectory(LLVMSupport)
set(SWIFT_RUNTIME_CXX_FLAGS)
set(SWIFT_RUNTIME_LINK_FLAGS)
set(SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS)
set(SWIFT_RUNTIME_SWIFT_LINK_FLAGS)
if(SWIFT_RUNTIME_USE_SANITIZERS)
# TODO: Refactor this
if("Thread" IN_LIST SWIFT_RUNTIME_USE_SANITIZERS)
list(APPEND SWIFT_RUNTIME_CXX_FLAGS "-fsanitize=thread")
list(APPEND SWIFT_RUNTIME_LINK_FLAGS "-fsanitize=thread")
list(APPEND SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS "-sanitize=thread")
list(APPEND SWIFT_RUNTIME_SWIFT_LINK_FLAGS "-fsanitize=thread")
endif()
endif()
if(SWIFT_STDLIB_SIL_DEBUGGING)
list(APPEND SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS "-Xfrontend" "-sil-based-debuginfo")
endif()
option(SWIFT_RUNTIME_DYLD_SHARED_CACHE_COMPATIBLE
"On Darwin platforms, link the standard library in a way that
allows inclusion in the dyld shared cache"
FALSE)
if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND
LLVM_LINKER_IS_APPLE AND
NOT SWIFT_RUNTIME_DYLD_SHARED_CACHE_COMPATIBLE)
set(shared_cache_link_flags "LINKER:-not_for_dyld_shared_cache")
list(APPEND SWIFT_RUNTIME_LINK_FLAGS ${shared_cache_link_flags})
list(APPEND SWIFT_RUNTIME_SWIFT_LINK_FLAGS ${shared_cache_link_flags})
endif()
# Build the runtime with -Wall to catch, e.g., uninitialized variables
# warnings.
if(SWIFT_COMPILER_IS_MSVC_LIKE)
list(APPEND SWIFT_RUNTIME_CXX_FLAGS "/W3")
else()
list(APPEND SWIFT_RUNTIME_CXX_FLAGS "-Wall")
endif()
set(SWIFT_RUNTIME_CORE_CXX_FLAGS "${SWIFT_RUNTIME_CXX_FLAGS}")
set(SWIFT_RUNTIME_CORE_LINK_FLAGS "${SWIFT_RUNTIME_LINK_FLAGS}")
if(CMAKE_SYSTEM_NAME STREQUAL "CYGWIN")
list(APPEND SWIFT_RUNTIME_CORE_CXX_FLAGS "-mcmodel=large")
elseif(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
list(APPEND SWIFT_RUNTIME_CORE_CXX_FLAGS "-xc++")
endif()
# We should avoid non-literals in format strings, or appropriately mark
# functions.
check_cxx_compiler_flag("-Wformat-nonliteral -Werror=format-nonliteral" CXX_SUPPORTS_FORMAT_NONLITERAL_WARNING)
if (CXX_SUPPORTS_FORMAT_NONLITERAL_WARNING)
list(APPEND SWIFT_RUNTIME_CORE_CXX_FLAGS "-Wformat-nonliteral"
"-Werror=format-nonliteral")
endif()
# C++ code in the runtime and standard library should generally avoid
# introducing static constructors or destructors.
check_cxx_compiler_flag("-Wglobal-constructors -Werror=global-constructors" CXX_SUPPORTS_GLOBAL_CONSTRUCTORS_WARNING)
if(CXX_SUPPORTS_GLOBAL_CONSTRUCTORS_WARNING)
list(APPEND SWIFT_RUNTIME_CORE_CXX_FLAGS "-Wglobal-constructors"
"-Werror=global-constructors")
endif()
# C++ code in the runtime and standard library should generally avoid
# introducing static constructors or destructors.
check_cxx_compiler_flag("-Wexit-time-destructors -Werror=exit-time-destructors" CXX_SUPPORTS_EXIT_TIME_DESTRUCTORS_WARNING)
if(CXX_SUPPORTS_EXIT_TIME_DESTRUCTORS_WARNING)
list(APPEND SWIFT_RUNTIME_CORE_CXX_FLAGS "-Wexit-time-destructors"
"-Werror=exit-time-destructors")
endif()
add_subdirectory(SwiftShims/swift/shims)
add_subdirectory(CommandLineSupport)
if(SWIFT_ENABLE_EXPERIMENTAL_CXX_INTEROP)
add_subdirectory(Cxx)
else()
# SwiftCompilerSources rely on C++ interop, specifically on being able to
# import the C++ standard library into Swift. On Linux, this is only possible
# when using the modulemap that Swift provides for libstdc++. Make sure we
# include the libstdc++ modulemap into the build even when not building
# C++ interop modules.
add_subdirectory(Cxx/libstdcxx)
endif()
add_subdirectory(Threading)
# This static library is shared across swiftCore and swiftRemoteInspection
if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_REMOTE_MIRROR OR SWIFT_BUILD_EXTERNAL_GENERIC_METADATA_BUILDER)
# TODO: due to the use of `add_swift_target_library` rather than `add_library`
# we cannot use `target_sources` and thus must resort to list manipulations to
# adjust the source list.
set(swiftDemanglingSources
"${SWIFT_SOURCE_DIR}/lib/Demangling/Context.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/Demangler.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/ManglingUtils.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/NodePrinter.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/Punycode.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/Remangler.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/NodeDumper.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/Errors.cpp")
set(swiftDemanglingCRSources
"${SWIFT_SOURCE_DIR}/lib/Demangling/CrashReporter.cpp")
set(swift_demangling_cflags)
if(SWIFT_RUNTIME_CRASH_REPORTER_CLIENT)
list(APPEND swift_demangling_cflags
"-DSWIFT_HAVE_CRASHREPORTERCLIENT=1")
endif()
# The old mangling support is only needed on platforms with ObjC.
if(SWIFT_STDLIB_ENABLE_OBJC_INTEROP)
list(APPEND swiftDemanglingSources
"${SWIFT_SOURCE_DIR}/lib/Demangling/OldDemangler.cpp"
"${SWIFT_SOURCE_DIR}/lib/Demangling/OldRemangler.cpp"
)
list(APPEND swift_demangling_cflags -DSWIFT_SUPPORT_OLD_MANGLING=1)
else()
list(APPEND swift_demangling_cflags -DSWIFT_SUPPORT_OLD_MANGLING=0)
endif()
if(SWIFT_STDLIB_HAS_TYPE_PRINTING)
list(APPEND swift_demangling_cflags -DSWIFT_STDLIB_HAS_TYPE_PRINTING)
endif()
# Gold LTO is unsupported. To prevent tests from failing when building
# with LTO, force swiftDemangling library to compile without LTO for Linux.
add_swift_target_library(swiftDemangling OBJECT_LIBRARY
${swiftDemanglingSources}
C_COMPILE_FLAGS
-DswiftCore_EXPORTS
${swift_demangling_cflags}
C_COMPILE_FLAGS_LINUX -fno-lto
INSTALL_IN_COMPONENT never_install)
add_swift_target_library(swiftDemanglingCR OBJECT_LIBRARY
${swiftDemanglingCRSources}
C_COMPILE_FLAGS
-DswiftCore_EXPORTS
${swift_demangling_cflags}
INSTALL_IN_COMPONENT never_install)
endif()
option(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB
"Enable build of the embedded Swift standard library and runtime"
TRUE)
# Temporarily, by default only build embedded stdlib when building the compiler, to
# unblock CI jobs that run against old(er) toolchains.
option(SWIFT_ALLOW_BUILD_EMBEDDED_STDLIB_WITH_HOST_COMPILER
"Build embedded Swift standard library and runtime even
if we are not building our own compiler"
FALSE)
if((NOT SWIFT_HOST_VARIANT STREQUAL "macosx") AND (NOT SWIFT_HOST_VARIANT STREQUAL "linux"))
set(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB FALSE)
elseif(NOT SWIFT_INCLUDE_TOOLS)
set(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB ${SWIFT_ALLOW_BUILD_EMBEDDED_STDLIB_WITH_HOST_COMPILER})
elseif(BOOTSTRAPPING_MODE STREQUAL "OFF")
set(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB FALSE)
endif()
if(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB)
set(EMBEDDED_STDLIB_TARGET_TRIPLES)
if("ARM" IN_LIST LLVM_TARGETS_TO_BUILD)
list(APPEND EMBEDDED_STDLIB_TARGET_TRIPLES
# arch module_name target triple
"armv6 armv6-apple-none-macho armv6-apple-none-macho"
"armv6m armv6m-apple-none-macho armv6m-apple-none-macho"
"armv7 armv7-apple-none-macho armv7-apple-none-macho"
"armv7em armv7em-apple-none-macho armv7em-apple-none-macho"
)
endif()
if("AArch64" IN_LIST LLVM_TARGETS_TO_BUILD)
list(APPEND EMBEDDED_STDLIB_TARGET_TRIPLES
"arm64 arm64-apple-none-macho arm64-apple-none-macho"
)
endif()
# the following are all ELF targets
if("ARM" IN_LIST LLVM_TARGETS_TO_BUILD)
list(APPEND EMBEDDED_STDLIB_TARGET_TRIPLES
"armv6 armv6-none-none-eabi armv6-none-none-eabi"
"armv6m armv6m-none-none-eabi armv6m-none-none-eabi"
"armv7 armv7-none-none-eabi armv7-none-none-eabi"
"armv7em armv7em-none-none-eabi armv7em-none-none-eabi"
)
endif()
if("AArch64" IN_LIST LLVM_TARGETS_TO_BUILD)
list(APPEND EMBEDDED_STDLIB_TARGET_TRIPLES
"aarch64 aarch64-none-none-elf aarch64-none-none-elf"
)
endif()
if("RISCV" IN_LIST LLVM_TARGETS_TO_BUILD)
list(APPEND EMBEDDED_STDLIB_TARGET_TRIPLES
"riscv32 riscv32-none-none-eabi riscv32-none-none-eabi"
"riscv64 riscv64-none-none-eabi riscv64-none-none-eabi"
)
endif()
if("X86" IN_LIST LLVM_TARGETS_TO_BUILD)
list(APPEND EMBEDDED_STDLIB_TARGET_TRIPLES
"i686 i686-unknown-none-elf i686-unknown-none-elf"
"x86_64 x86_64-unknown-none-elf x86_64-unknown-none-elf"
# Without specifying the `windows` component LLVM refuses to
# generate valid COFF object files.
"i686 i686-unknown-windows-msvc i686-unknown-windows-msvc"
"x86_64 x86_64-unknown-windows-msvc x86_64-unknown-windows-msvc"
)
endif()
if("WebAssembly" IN_LIST LLVM_TARGETS_TO_BUILD)
list(APPEND EMBEDDED_STDLIB_TARGET_TRIPLES
"wasm32 wasm32-unknown-none-wasm wasm32-unknown-none-wasm"
"wasm64 wasm64-unknown-none-wasm wasm64-unknown-none-wasm"
)
endif()
if (SWIFT_HOST_VARIANT STREQUAL "linux")
set(EMBEDDED_STDLIB_TARGET_TRIPLES ${EMBEDDED_STDLIB_TARGET_TRIPLES}
"${SWIFT_HOST_VARIANT_ARCH} ${SWIFT_HOST_VARIANT_ARCH}-unknown-linux-gnu ${SWIFT_HOST_VARIANT_ARCH}-unknown-linux-gnu"
# In practice this expands to either:
# "x86_64 x86_64-unknown-linux-gnu x86_64-unknown-linux-gnu"
# "aarch64 aarch64-unknown-linux-gnu aarch64-unknown-linux-gnu"
)
elseif (SWIFT_HOST_VARIANT STREQUAL "macosx")
set(EMBEDDED_STDLIB_TARGET_TRIPLES ${EMBEDDED_STDLIB_TARGET_TRIPLES}
"x86_64 x86_64-apple-macos x86_64-apple-macos10.13"
"arm64 arm64-apple-macos arm64-apple-macos10.13"
"arm64e arm64e-apple-macos arm64e-apple-macos10.13"
)
endif()
endif()
if(SWIFT_BUILD_STDLIB)
# These must be kept in dependency order so that any referenced targets
# exist at the time we look for them in add_swift_*.
add_subdirectory(runtime)
add_subdirectory(stubs)
add_subdirectory(core)
add_subdirectory(SwiftOnoneSupport)
if(SWIFT_BUILD_CLANG_OVERLAYS OR SWIFT_BUILD_TEST_SUPPORT_MODULES)
add_subdirectory(ClangOverlays)
endif()
endif()
if(SWIFT_BUILD_STDLIB AND NOT SWIFT_STDLIB_BUILD_ONLY_CORE_MODULES)
# In some internal Apple configurations we have the need
# to build Core and Onone separately from the rest
# of the stdlib
if(SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING)
add_subdirectory(Differentiation)
endif()
if(SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY)
add_subdirectory(Concurrency)
endif()
if(SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED)
add_subdirectory(Distributed)
endif()
if(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
add_subdirectory(RegexParser)
add_subdirectory(StringProcessing)
add_subdirectory(RegexBuilder)
endif()
if(SWIFT_ENABLE_EXPERIMENTAL_OBSERVATION)
add_subdirectory(Observation)
endif()
if(SWIFT_ENABLE_BACKTRACING)
add_subdirectory(Backtracing)
endif()
if(SWIFT_ENABLE_SYNCHRONIZATION)
add_subdirectory(Synchronization)
endif()
endif()
if(SWIFT_BUILD_REMOTE_MIRROR)
add_subdirectory(RemoteInspection)
add_subdirectory(SwiftRemoteMirror)
endif()
if(SWIFT_BUILD_SDK_OVERLAY OR (SWIFT_BUILD_TEST_SUPPORT_MODULES AND SWIFT_BUILD_DYNAMIC_SDK_OVERLAY_default))
add_subdirectory(Platform)
endif()
if(SWIFT_BUILD_SDK_OVERLAY)
# On Apple platforms, we aren't building any overlays. Instead, we're picking them up from the SDK.
if(WINDOWS IN_LIST SWIFT_SDKS)
add_subdirectory(Windows)
endif()
endif()
if(SWIFT_BUILD_LIBEXEC)
add_subdirectory(libexec)
endif()
|
