Revert "[NFCI][IR] ConstantRangeTest: add basic scaffolding for next-gen precision...
[lldb.git] / compiler-rt / CMakeLists.txt
1 # CMake build for CompilerRT.
2 #
3 # An important constraint of the build is that it only produces libraries
4 # based on the ability of the host toolchain to target various platforms.
5
6 cmake_minimum_required(VERSION 3.13.4)
7
8 if(POLICY CMP0075)
9   cmake_policy(SET CMP0075 NEW)
10 endif()
11
12 # Check if compiler-rt is built as a standalone project.
13 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR OR COMPILER_RT_STANDALONE_BUILD)
14   project(CompilerRT C CXX ASM)
15   set(COMPILER_RT_STANDALONE_BUILD TRUE)
16   set_property(GLOBAL PROPERTY USE_FOLDERS ON)
17 endif()
18
19 # Add path for custom compiler-rt modules.
20 list(INSERT CMAKE_MODULE_PATH 0
21   "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
22   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
23   )
24
25 if(CMAKE_CONFIGURATION_TYPES)
26   set(CMAKE_CFG_RESOLVED_INTDIR "${CMAKE_CFG_INTDIR}/")
27 else()
28   set(CMAKE_CFG_RESOLVED_INTDIR "")
29 endif()
30
31 include(base-config-ix)
32 include(CompilerRTUtils)
33
34 option(COMPILER_RT_BUILD_BUILTINS "Build builtins" ON)
35 mark_as_advanced(COMPILER_RT_BUILD_BUILTINS)
36 option(COMPILER_RT_BUILD_CRT "Build crtbegin.o/crtend.o" ON)
37 mark_as_advanced(COMPILER_RT_BUILD_CRT)
38 option(COMPILER_RT_CRT_USE_EH_FRAME_REGISTRY "Use eh_frame in crtbegin.o/crtend.o" ON)
39 mark_as_advanced(COMPILER_RT_CRT_USE_EH_FRAME_REGISTRY)
40 option(COMPILER_RT_BUILD_SANITIZERS "Build sanitizers" ON)
41 mark_as_advanced(COMPILER_RT_BUILD_SANITIZERS)
42 option(COMPILER_RT_BUILD_XRAY "Build xray" ON)
43 mark_as_advanced(COMPILER_RT_BUILD_XRAY)
44 option(COMPILER_RT_BUILD_LIBFUZZER "Build libFuzzer" ON)
45 mark_as_advanced(COMPILER_RT_BUILD_LIBFUZZER)
46 option(COMPILER_RT_BUILD_PROFILE "Build profile runtime" ON)
47 mark_as_advanced(COMPILER_RT_BUILD_PROFILE)
48 option(COMPILER_RT_BUILD_XRAY_NO_PREINIT "Build xray with no preinit patching" OFF)
49 mark_as_advanced(COMPILER_RT_BUILD_XRAY_NO_PREINIT)
50
51 set(COMPILER_RT_ASAN_SHADOW_SCALE ""
52     CACHE STRING "Override the shadow scale to be used in ASan runtime")
53
54 if (NOT COMPILER_RT_ASAN_SHADOW_SCALE STREQUAL "")
55   # Check that the shadow scale value is valid.
56   if (NOT (COMPILER_RT_ASAN_SHADOW_SCALE GREATER -1 AND
57            COMPILER_RT_ASAN_SHADOW_SCALE LESS 8))
58     message(FATAL_ERROR "
59       Invalid ASan Shadow Scale '${COMPILER_RT_ASAN_SHADOW_SCALE}'.")
60   endif()
61
62   set(COMPILER_RT_ASAN_SHADOW_SCALE_LLVM_FLAG
63       -mllvm -asan-mapping-scale=${COMPILER_RT_ASAN_SHADOW_SCALE})
64   set(COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION
65       ASAN_SHADOW_SCALE=${COMPILER_RT_ASAN_SHADOW_SCALE})
66   set(COMPILER_RT_ASAN_SHADOW_SCALE_FLAG
67       -D${COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION})
68 endif()
69
70 set(COMPILER_RT_HWASAN_WITH_INTERCEPTORS ON CACHE BOOL
71     "Enable libc interceptors in HWASan (testing mode)")
72
73 set(COMPILER_RT_BAREMETAL_BUILD OFF CACHE BOOL
74   "Build for a bare-metal target.")
75
76 if (COMPILER_RT_STANDALONE_BUILD)
77   load_llvm_config()
78   if (TARGET intrinsics_gen)
79     # Loading the llvm config causes this target to be imported so place it
80     # under the appropriate folder in an IDE.
81     set_target_properties(intrinsics_gen PROPERTIES FOLDER "Compiler-RT Misc")
82   endif()
83
84   find_package(Python3 COMPONENTS Interpreter)
85   if(NOT Python3_Interpreter_FOUND)
86     message(WARNING "Python3 not found, using python2 as a fallback")
87     find_package(Python2 COMPONENTS Interpreter REQUIRED)
88     if(Python2_VERSION VERSION_LESS 2.7)
89       message(SEND_ERROR "Python 2.7 or newer is required")
90     endif()
91
92     # Treat python2 as python3
93     add_executable(Python3::Interpreter IMPORTED)
94     set_target_properties(Python3::Interpreter PROPERTIES
95       IMPORTED_LOCATION ${Python2_EXECUTABLE})
96     set(Python3_EXECUTABLE ${Python2_EXECUTABLE})
97   endif()
98
99   # Ensure that fat libraries are built correctly on Darwin
100   if(APPLE)
101     include(UseLibtool)
102   endif()
103
104   # Define default arguments to lit.
105   set(LIT_ARGS_DEFAULT "-sv")
106   if (MSVC OR XCODE)
107     set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")
108   endif()
109   set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")
110   set(LLVM_LIT_OUTPUT_DIR "${COMPILER_RT_EXEC_OUTPUT_DIR}")
111 endif()
112
113 construct_compiler_rt_default_triple()
114 if ("${COMPILER_RT_DEFAULT_TARGET_TRIPLE}" MATCHES ".*hf$")
115   if (${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "^arm")
116     set(COMPILER_RT_DEFAULT_TARGET_ARCH "armhf")
117   endif()
118 endif()
119 if ("${COMPILER_RT_DEFAULT_TARGET_TRIPLE}" MATCHES ".*android.*")
120   set(ANDROID 1)
121 endif()
122 pythonize_bool(ANDROID)
123
124 set(ANDROID_NDK_VERSION 18
125     CACHE STRING "Set this to the Android NDK version that you are using")
126
127 set(COMPILER_RT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
128 set(COMPILER_RT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
129
130 pythonize_bool(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR)
131
132 # We support running instrumented tests when we're not cross compiling
133 # and target a UNIX-like system or Windows.
134 # We can run tests on Android even when we are cross-compiling.
135 if(("${CMAKE_HOST_SYSTEM}" STREQUAL "${CMAKE_SYSTEM}" AND (UNIX OR WIN32)) OR ANDROID
136    OR COMPILER_RT_EMULATOR)
137   option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" ON)
138 else()
139   option(COMPILER_RT_CAN_EXECUTE_TESTS "Can we execute instrumented tests" OFF)
140 endif()
141
142 option(COMPILER_RT_DEBUG "Build runtimes with full debug info" OFF)
143 option(COMPILER_RT_EXTERNALIZE_DEBUGINFO
144   "Generate dSYM files and strip executables and libraries (Darwin Only)" OFF)
145 # COMPILER_RT_DEBUG_PYBOOL is used by lit.common.configured.in.
146 pythonize_bool(COMPILER_RT_DEBUG)
147
148 option(COMPILER_RT_INTERCEPT_LIBDISPATCH
149   "Support interception of libdispatch (GCD). Requires '-fblocks'" OFF)
150 option(COMPILER_RT_LIBDISPATCH_INSTALL_PATH
151   "Specify if libdispatch is installed in a custom location" "")
152 if (COMPILER_RT_INTERCEPT_LIBDISPATCH AND NOT APPLE)
153   set(COMPILER_RT_LIBDISPATCH_CFLAGS -fblocks)
154   set(COMPILER_RT_TEST_LIBDISPATCH_CFLAGS)
155   if (COMPILER_RT_LIBDISPATCH_INSTALL_PATH)
156     list(APPEND COMPILER_RT_TEST_LIBDISPATCH_CFLAGS
157         -I${COMPILER_RT_LIBDISPATCH_INSTALL_PATH}/include
158         -L${COMPILER_RT_LIBDISPATCH_INSTALL_PATH}/lib
159         -Wl,-rpath=${COMPILER_RT_LIBDISPATCH_INSTALL_PATH}/lib)
160   endif()
161   list(APPEND COMPILER_RT_TEST_LIBDISPATCH_CFLAGS -lBlocksRuntime -ldispatch)
162 endif()
163 if (APPLE) # Always enable on Apple platforms.
164   set(COMPILER_RT_INTERCEPT_LIBDISPATCH ON)
165 endif()
166 pythonize_bool(COMPILER_RT_INTERCEPT_LIBDISPATCH)
167
168 if(APPLE AND SANITIZER_MIN_OSX_VERSION AND SANITIZER_MIN_OSX_VERSION VERSION_LESS "10.9")
169   # Mac OS X prior to 10.9 had problems with exporting symbols from
170   # libc++/libc++abi.
171   set(cxxabi_supported OFF)
172 else()
173   set(cxxabi_supported ON)
174 endif()
175
176 option(SANITIZER_ALLOW_CXXABI "Allow use of C++ ABI details in ubsan" ON)
177
178 set(SANITIZE_CAN_USE_CXXABI OFF)
179 if (cxxabi_supported AND SANITIZER_ALLOW_CXXABI)
180   set(SANITIZER_CAN_USE_CXXABI ON)
181 endif()
182 pythonize_bool(SANITIZER_CAN_USE_CXXABI)
183
184 macro(handle_default_cxx_lib var)
185   if (${var} STREQUAL "default")
186     if (APPLE OR CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
187       set(${var}_LIBNAME "libc++")
188       set(${var}_SYSTEM 1)
189     elseif (FUCHSIA)
190       set(${var}_LIBNAME "libc++")
191       set(${var}_INTREE 1)
192     else()
193       set(${var}_LIBNAME "libstdc++")
194       set(${var}_SYSTEM 1)
195     endif()
196   else()
197     set(${var}_LIBNAME "${${var}}")
198     set(${var}_SYSTEM 1)
199   endif()
200 endmacro()
201
202 # This is either directly the C++ ABI library or the full C++ library
203 # which pulls in the ABI transitively.
204 set(SANITIZER_CXX_ABI "default" CACHE STRING
205     "Specify C++ ABI library to use.")
206 set(CXXABIS none default libstdc++ libc++ libcxxabi)
207 set_property(CACHE SANITIZER_CXX_ABI PROPERTY STRINGS ;${CXXABIS})
208 handle_default_cxx_lib(SANITIZER_CXX_ABI)
209
210 # This needs to be a full C++ library for linking gtest and unit tests.
211 set(SANITIZER_TEST_CXX "default" CACHE STRING
212     "Specify C++ library to use for tests.")
213 set(CXXLIBS none default libstdc++ libc++)
214 set_property(CACHE SANITIZER_TEST_CXX PROPERTY STRINGS ;${CXXLIBS})
215 handle_default_cxx_lib(SANITIZER_TEST_CXX)
216
217 set(DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER OFF)
218 if (FUCHSIA)
219   set(DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER ON)
220 elseif (DEFINED LIBUNWIND_ENABLE_SHARED AND NOT LIBUNWIND_ENABLE_SHARED)
221   set(DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER ON)
222 endif()
223
224 option(SANITIZER_USE_STATIC_LLVM_UNWINDER
225   "Use static LLVM unwinder." ${DEFAULT_SANITIZER_USE_STATIC_LLVM_UNWINDER})
226
227 set(DEFAULT_SANITIZER_USE_STATIC_CXX_ABI OFF)
228 if (DEFINED LIBCXXABI_ENABLE_SHARED AND NOT LIBCXXABI_ENABLE_SHARED)
229   set(DEFAULT_SANITIZER_USE_STATIC_CXX_ABI ON)
230 endif()
231
232 option(SANITIZER_USE_STATIC_CXX_ABI
233   "Use static libc++abi." ${DEFAULT_SANITIZER_USE_STATIC_CXX_ABI})
234
235 set(DEFAULT_COMPILER_RT_USE_BUILTINS_LIBRARY OFF)
236 if (FUCHSIA)
237   set(DEFAULT_COMPILER_RT_USE_BUILTINS_LIBRARY ON)
238 endif()
239
240 option(COMPILER_RT_USE_BUILTINS_LIBRARY
241   "Use compiler-rt builtins instead of libgcc" ${DEFAULT_COMPILER_RT_USE_BUILTINS_LIBRARY})
242
243 include(config-ix)
244
245 #================================
246 # Setup Compiler Flags
247 #================================
248
249 if(MSVC)
250   # Override any existing /W flags with /W4. This is what LLVM does.  Failing to
251   # remove other /W[0-4] flags will result in a warning about overriding a
252   # previous flag.
253   if (COMPILER_RT_HAS_W4_FLAG)
254     string(REGEX REPLACE " /W[0-4]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
255     string(REGEX REPLACE " /W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
256     append_string_if(COMPILER_RT_HAS_W4_FLAG /W4 CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
257   endif()
258 else()
259   append_string_if(COMPILER_RT_HAS_WALL_FLAG -Wall CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
260 endif()
261 if(COMPILER_RT_ENABLE_WERROR)
262   append_string_if(COMPILER_RT_HAS_WERROR_FLAG -Werror CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
263   append_string_if(COMPILER_RT_HAS_WX_FLAG /WX CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
264 endif()
265
266 append_string_if(COMPILER_RT_HAS_STD_CXX14_FLAG -std=c++14 CMAKE_CXX_FLAGS)
267
268 # Emulate C99 and C++11's __func__ for MSVC prior to 2013 CTP.
269 if(NOT COMPILER_RT_HAS_FUNC_SYMBOL)
270   add_definitions(-D__func__=__FUNCTION__)
271 endif()
272
273 # Provide some common commmandline flags for Sanitizer runtimes.
274 if(NOT WIN32)
275   append_list_if(COMPILER_RT_HAS_FPIC_FLAG -fPIC SANITIZER_COMMON_CFLAGS)
276 endif()
277 append_list_if(COMPILER_RT_HAS_FNO_BUILTIN_FLAG -fno-builtin SANITIZER_COMMON_CFLAGS)
278 append_list_if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions SANITIZER_COMMON_CFLAGS)
279 if(NOT COMPILER_RT_DEBUG AND NOT APPLE)
280   append_list_if(COMPILER_RT_HAS_FOMIT_FRAME_POINTER_FLAG -fomit-frame-pointer SANITIZER_COMMON_CFLAGS)
281 endif()
282 append_list_if(COMPILER_RT_HAS_FUNWIND_TABLES_FLAG -funwind-tables SANITIZER_COMMON_CFLAGS)
283 append_list_if(COMPILER_RT_HAS_FNO_STACK_PROTECTOR_FLAG -fno-stack-protector SANITIZER_COMMON_CFLAGS)
284 append_list_if(COMPILER_RT_HAS_FNO_SANITIZE_SAFE_STACK_FLAG -fno-sanitize=safe-stack SANITIZER_COMMON_CFLAGS)
285 append_list_if(COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG -fvisibility=hidden SANITIZER_COMMON_CFLAGS)
286 if(NOT COMPILER_RT_HAS_FVISIBILITY_HIDDEN_FLAG)
287   append_list_if(COMPILER_RT_HAS_FVISIBILITY_INLINES_HIDDEN_FLAG -fvisibility-inlines-hidden SANITIZER_COMMON_CFLAGS)
288 endif()
289 append_list_if(COMPILER_RT_HAS_FNO_LTO_FLAG -fno-lto SANITIZER_COMMON_CFLAGS)
290
291 # By default do not instrument or use profdata for compiler-rt.
292 if(NOT COMPILER_RT_ENABLE_PGO)
293   if(LLVM_PROFDATA_FILE AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_USE_FLAG)
294     list(APPEND SANITIZER_COMMON_CFLAGS "-fno-profile-instr-use")
295   endif()
296   if(LLVM_BUILD_INSTRUMENTED MATCHES IR AND COMPILER_RT_HAS_FNO_PROFILE_GENERATE_FLAG)
297     list(APPEND SANITIZER_COMMON_CFLAGS "-fno-profile-generate")
298   elseif(LLVM_BUILD_INSTRUMENTED AND COMPILER_RT_HAS_FNO_PROFILE_INSTR_GENERATE_FLAG)
299     list(APPEND SANITIZER_COMMON_CFLAGS "-fno-profile-instr-generate")
300   endif()
301 endif()
302
303 # The following is a workaround for powerpc64le. This is the only architecture
304 # that requires -fno-function-sections to work properly. If lacking, the ASan
305 # Linux test function-sections-are-bad.cpp fails with the following error:
306 # 'undefined symbol: __sanitizer_unaligned_load32'.
307 if(DEFINED TARGET_powerpc64le_CFLAGS)
308   if(CMAKE_CXX_COMPILER_ID MATCHES "XL")
309     append("-qnofuncsect" TARGET_powerpc64le_CFLAGS)
310   else()
311     append_list_if(COMPILER_RT_HAS_FNO_FUNCTION_SECTIONS_FLAG -fno-function-sections TARGET_powerpc64le_CFLAGS)
312   endif()
313 endif()
314
315 # The following is a workaround for s390x.  This avoids creation of "partial
316 # inline" function fragments when building the asan libraries with certain
317 # GCC versions.  The presence of those fragments, in particular for the
318 # interceptors, changes backtraces seen in asan error cases, which causes
319 # testsuite failures.
320 if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "s390x")
321   append_list_if(COMPILER_RT_HAS_FNO_PARTIAL_INLINING_FLAG -fno-partial-inlining SANITIZER_COMMON_CFLAGS)
322 endif()
323
324 if(MSVC)
325   # Replace the /M[DT][d] flags with /MT, and strip any definitions of _DEBUG,
326   # which cause definition mismatches at link time.
327   # FIXME: In fact, sanitizers should support both /MT and /MD, see PR20214.
328   if(COMPILER_RT_HAS_MT_FLAG)
329     foreach(flag_var
330       CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
331       CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
332       CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
333       CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
334       string(REGEX REPLACE "/M[DT]d" "/MT" ${flag_var} "${${flag_var}}")
335       string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
336       string(REGEX REPLACE "/D_DEBUG" "" ${flag_var} "${${flag_var}}")
337     endforeach()
338   endif()
339   append_list_if(COMPILER_RT_HAS_Oy_FLAG /Oy- SANITIZER_COMMON_CFLAGS)
340   append_list_if(COMPILER_RT_HAS_GS_FLAG /GS- SANITIZER_COMMON_CFLAGS)
341
342   # Disable thread safe initialization for static locals. ASan shouldn't need
343   # it. Thread safe initialization assumes that the CRT has already been
344   # initialized, but ASan initializes before the CRT.
345   list(APPEND SANITIZER_COMMON_CFLAGS /Zc:threadSafeInit-)
346 endif()
347
348 append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 SANITIZER_COMMON_CFLAGS)
349
350 # If we're using MSVC,
351 # always respect the optimization flags set by CMAKE_BUILD_TYPE instead.
352 if (NOT MSVC)
353
354   # Build with optimization, unless we're in debug mode.
355   if(COMPILER_RT_DEBUG)
356     list(APPEND SANITIZER_COMMON_CFLAGS -O0)
357   else()
358     list(APPEND SANITIZER_COMMON_CFLAGS -O3)
359   endif()
360 endif()
361
362 # Determine if we should restrict stack frame sizes.
363 # Stack frames on PowerPC, Mips, SystemZ and in debug build can be much larger than
364 # anticipated.
365 # FIXME: Fix all sanitizers and add -Wframe-larger-than to
366 # SANITIZER_COMMON_FLAGS
367 if(COMPILER_RT_HAS_WFRAME_LARGER_THAN_FLAG AND NOT COMPILER_RT_DEBUG
368    AND NOT ${COMPILER_RT_DEFAULT_TARGET_ARCH} MATCHES "powerpc|mips|s390x")
369   set(SANITIZER_LIMIT_FRAME_SIZE TRUE)
370 else()
371   set(SANITIZER_LIMIT_FRAME_SIZE FALSE)
372 endif()
373
374 if(FUCHSIA OR UNIX)
375   set(SANITIZER_USE_SYMBOLS TRUE)
376 else()
377   set(SANITIZER_USE_SYMBOLS FALSE)
378 endif()
379
380 # Build sanitizer runtimes with debug info.
381 if(MSVC)
382   # Use /Z7 instead of /Zi for the asan runtime. This avoids the LNK4099
383   # warning from the MS linker complaining that it can't find the 'vc140.pdb'
384   # file used by our object library compilations.
385   list(APPEND SANITIZER_COMMON_CFLAGS /Z7)
386   foreach(var_to_update
387     CMAKE_CXX_FLAGS
388     CMAKE_CXX_FLAGS_DEBUG
389     CMAKE_CXX_FLAGS_RELWITHDEBINFO)
390     string(REGEX REPLACE "(^| )/Z[i7I]($| )" " /Z7 "
391            "${var_to_update}" "${${var_to_update}}")
392   endforeach()
393 elseif(COMPILER_RT_HAS_GLINE_TABLES_ONLY_FLAG AND NOT COMPILER_RT_DEBUG)
394   list(APPEND SANITIZER_COMMON_CFLAGS -gline-tables-only)
395 elseif(COMPILER_RT_HAS_G_FLAG)
396   list(APPEND SANITIZER_COMMON_CFLAGS -g)
397 endif()
398
399 if(LLVM_ENABLE_MODULES)
400   # Sanitizers cannot be built with -fmodules. The interceptors intentionally
401   # don't include system headers, which is incompatible with modules.
402   list(APPEND SANITIZER_COMMON_CFLAGS -fno-modules)
403 endif()
404
405 # Turn off several warnings.
406 append_list_if(COMPILER_RT_HAS_WGNU_FLAG -Wno-gnu SANITIZER_COMMON_CFLAGS)
407 append_list_if(COMPILER_RT_HAS_WVARIADIC_MACROS_FLAG -Wno-variadic-macros SANITIZER_COMMON_CFLAGS)
408 append_list_if(COMPILER_RT_HAS_WC99_EXTENSIONS_FLAG -Wno-c99-extensions SANITIZER_COMMON_CFLAGS)
409 append_list_if(COMPILER_RT_HAS_WNON_VIRTUAL_DTOR_FLAG -Wno-non-virtual-dtor SANITIZER_COMMON_CFLAGS)
410 append_list_if(COMPILER_RT_HAS_WD4146_FLAG /wd4146 SANITIZER_COMMON_CFLAGS)
411 append_list_if(COMPILER_RT_HAS_WD4291_FLAG /wd4291 SANITIZER_COMMON_CFLAGS)
412 append_list_if(COMPILER_RT_HAS_WD4391_FLAG /wd4391 SANITIZER_COMMON_CFLAGS)
413 append_list_if(COMPILER_RT_HAS_WD4722_FLAG /wd4722 SANITIZER_COMMON_CFLAGS)
414 append_list_if(COMPILER_RT_HAS_WD4800_FLAG /wd4800 SANITIZER_COMMON_CFLAGS)
415
416 append_list_if(MINGW -fms-extensions SANITIZER_COMMON_CFLAGS)
417
418 # Set common link flags.
419 append_list_if(COMPILER_RT_HAS_NODEFAULTLIBS_FLAG -nodefaultlibs SANITIZER_COMMON_LINK_FLAGS)
420 append_list_if(COMPILER_RT_HAS_Z_TEXT -Wl,-z,text SANITIZER_COMMON_LINK_FLAGS)
421
422 if (COMPILER_RT_USE_BUILTINS_LIBRARY)
423   string(REPLACE "-Wl,-z,defs" "" CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
424 else()
425   if (ANDROID)
426     append_list_if(COMPILER_RT_HAS_GCC_LIB gcc SANITIZER_COMMON_LINK_LIBS)
427   else()
428     append_list_if(COMPILER_RT_HAS_GCC_S_LIB gcc_s SANITIZER_COMMON_LINK_LIBS)
429   endif()
430 endif()
431
432 append_list_if(COMPILER_RT_HAS_LIBC c SANITIZER_COMMON_LINK_LIBS)
433
434 if("${CMAKE_SYSTEM_NAME}" STREQUAL "Fuchsia")
435   list(APPEND SANITIZER_COMMON_LINK_FLAGS -Wl,-z,defs,-z,now,-z,relro)
436   list(APPEND SANITIZER_COMMON_LINK_LIBS zircon)
437 endif()
438
439 macro(append_libcxx_libs var)
440   if (${var}_INTREE)
441     if (SANITIZER_USE_STATIC_LLVM_UNWINDER AND (TARGET unwind_static OR HAVE_LIBUNWIND))
442       list(APPEND ${var}_LIBRARIES unwind_static)
443     elseif (TARGET unwind_shared OR HAVE_LIBUNWIND)
444       list(APPEND ${var}_LIBRARIES unwind_shared)
445     endif()
446
447     if (SANITIZER_USE_STATIC_CXX_ABI AND (TARGET cxxabi_static OR HAVE_LIBCXXABI))
448       list(APPEND ${var}_LIBRARIES cxxabi_static)
449     elseif (TARGET cxxabi_shared OR HAVE_LIBCXXABI)
450       list(APPEND ${var}_LIBRARIES cxxabi_shared)
451     endif()
452   else()
453     append_list_if(COMPILER_RT_HAS_LIBCXX c++ ${var}_LIBRARIES)
454   endif()
455 endmacro()
456
457 if (SANITIZER_CXX_ABI_LIBNAME STREQUAL "libc++")
458   append_libcxx_libs(SANITIZER_CXX_ABI)
459 elseif (SANITIZER_CXX_ABI_LIBNAME STREQUAL "libcxxabi")
460   list(APPEND SANITIZER_CXX_ABI_LIBRARIES "c++abi")
461 elseif (SANITIZER_CXX_ABI_LIBNAME STREQUAL "libstdc++")
462   append_list_if(COMPILER_RT_HAS_LIBSTDCXX stdc++ SANITIZER_CXX_ABI_LIBRARIES)
463 endif()
464
465 if (SANITIZER_TEST_CXX_LIBNAME STREQUAL "libc++")
466   append_libcxx_libs(SANITIZER_TEST_CXX)
467 elseif (SANITIZER_TEST_CXX_LIBNAME STREQUAL "libstdc++")
468   append_list_if(COMPILER_RT_HAS_LIBSTDCXX stdc++ SANITIZER_TEST_CXX_LIBRARIES)
469 endif()
470
471 # Warnings to turn off for all libraries, not just sanitizers.
472 append_string_if(COMPILER_RT_HAS_WUNUSED_PARAMETER_FLAG -Wno-unused-parameter CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
473
474 if (CMAKE_LINKER MATCHES "link.exe$")
475   # Silence MSVC linker warnings caused by empty object files. The
476   # sanitizer libraries intentionally use ifdefs that result in empty
477   # files, rather than skipping these files in the build system.
478   # Ideally, we would pass this flag only for the libraries that need
479   # it, but CMake doesn't seem to have a way to set linker flags for
480   # individual static libraries, so we enable the suppression flag for
481   # the whole compiler-rt project.
482   set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /IGNORE:4221")
483 endif()
484
485 if(${CMAKE_SYSTEM_NAME} MATCHES "AIX")
486   set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> -X32_64 qc <TARGET> <LINK_FLAGS> <OBJECTS>")
487   set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> -X32_64 qc <TARGET> <LINK_FLAGS> <OBJECTS>")
488   set(CMAKE_C_ARCHIVE_APPEND "<CMAKE_AR> -X32_64 q <TARGET> <LINK_FLAGS> <OBJECTS>")
489   set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> -X32_64 q <TARGET> <LINK_FLAGS> <OBJECTS>")
490   set(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> -X32_64 <TARGET>")
491   set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -X32_64 <TARGET>")
492 endif()
493
494 add_subdirectory(include)
495
496 option(COMPILER_RT_USE_LIBCXX
497   "Enable compiler-rt to use libc++ from the source tree" ON)
498 if(COMPILER_RT_USE_LIBCXX)
499   if(LLVM_ENABLE_PROJECTS_USED)
500     # Don't use libcxx if LLVM_ENABLE_PROJECTS does not enable it.
501     set(COMPILER_RT_LIBCXX_PATH ${LLVM_EXTERNAL_LIBCXX_SOURCE_DIR})
502     set(COMPILER_RT_LIBCXXABI_PATH ${LLVM_EXTERNAL_LIBCXXABI_SOURCE_DIR})
503   else()
504     foreach(path IN ITEMS ${LLVM_MAIN_SRC_DIR}/projects/libcxx
505                           ${LLVM_MAIN_SRC_DIR}/runtimes/libcxx
506                           ${LLVM_MAIN_SRC_DIR}/../libcxx
507                           ${LLVM_EXTERNAL_LIBCXX_SOURCE_DIR})
508       if(IS_DIRECTORY ${path})
509         set(COMPILER_RT_LIBCXX_PATH ${path})
510         break()
511       endif()
512     endforeach()
513     foreach(path IN ITEMS ${LLVM_MAIN_SRC_DIR}/projects/libcxxabi
514                           ${LLVM_MAIN_SRC_DIR}/runtimes/libcxxabi
515                           ${LLVM_MAIN_SRC_DIR}/../libcxxabi
516                           ${LLVM_EXTERNAL_LIBCXXABI_SOURCE_DIR})
517       if(IS_DIRECTORY ${path})
518         set(COMPILER_RT_LIBCXXABI_PATH ${path})
519         break()
520       endif()
521     endforeach()
522   endif()
523 endif()
524
525 set(COMPILER_RT_LLD_PATH ${LLVM_MAIN_SRC_DIR}/tools/lld)
526 if(EXISTS ${COMPILER_RT_LLD_PATH}/ AND LLVM_TOOL_LLD_BUILD)
527   set(COMPILER_RT_HAS_LLD TRUE)
528 else()
529   set(COMPILER_RT_LLD_PATH ${LLVM_MAIN_SRC_DIR}/../lld)
530   if(EXISTS ${COMPILER_RT_LLD_PATH}/ AND LLVM_TOOL_LLD_BUILD)
531     set(COMPILER_RT_HAS_LLD TRUE)
532   endif()
533 endif()
534 pythonize_bool(COMPILER_RT_HAS_LLD)
535
536 add_subdirectory(lib)
537
538 if(COMPILER_RT_INCLUDE_TESTS)
539   add_subdirectory(unittests)
540   add_subdirectory(test)
541   # Don't build llvm-lit for runtimes-build, it will clean up map_config.
542   if (COMPILER_RT_STANDALONE_BUILD AND NOT RUNTIMES_BUILD)
543     # If we have a valid source tree, generate llvm-lit into the bin directory.
544     # The user can still choose to have the check targets *use* a different lit
545     # by specifying -DLLVM_EXTERNAL_LIT, but we generate it regardless.
546     if (EXISTS ${LLVM_MAIN_SRC_DIR}/utils/llvm-lit)
547       # Needed for lit support in standalone builds.
548       include(AddLLVM)
549       add_subdirectory(${LLVM_MAIN_SRC_DIR}/utils/llvm-lit ${CMAKE_CURRENT_BINARY_DIR}/llvm-lit)
550     elseif(NOT EXISTS ${LLVM_EXTERNAL_LIT})
551       message(WARNING "Could not find LLVM source directory and LLVM_EXTERNAL_LIT does not"
552                        "point to a valid file.  You will not be able to run tests.")
553     endif()
554   endif()
555 endif()
556
557 add_subdirectory(tools)