[CMake] Provide options for toggling on and off various runtime libraries.

[beanz]

Summary

Rather than having to add new "experimental" options each time someone wants to work on bringing a sanitizer to a new platform, this patch makes options for all of them.

The default values for the options are set by the platform checks that would have enabled them, but they can be overridden on or off.

[samsonov]

Can we have smth. like LLVM_TARGETS_TO_BUILD ? I.e. have the one CMake variable which takes semicolon-separated list of sanitizers / configurations to build (which defaults to ALL, which expands to everything supported on a given platform)?

[beanz]

Migrating enabling sanitizers to a semi-colon separated list. "all" defaults to the list of supported sanitizers determined by config-ix.cmake.

[kubamracek]

cmake/config-ix.cmake

591

I think we need to add interception here as well. Otherwise using COMPILER_RT_RUNTIMES_TO_BUILD=asan doesn't build for me.

lib/lsan/CMakeLists.txt

28

Can we wrap this in a macro (and use it in ubsan/CMakeLists.txt as well)?

lib/tsan/CMakeLists.txt

196

Shouldn't this be just dd instead of tsan/dd?

test/ubsan/CMakeLists.txt

45

remove the extra paren

48

same here

[beanz]

Updates based on feedback from Kuba.

[samsonov]

Looks reasonable, several comments/nits below.

cmake/Modules/CompilerRTUtils.cmake

81

I'm curious, can we make it look more like "check_c_compiler_flag" or "check_symbol_exists"

check_list_contains(list value output)

?

84

use True/False instead?

90

See note below - probably remove this?

cmake/config-ix.cmake

562

cfi is available not only on Windows, I think lib/cfi is added unconditionally.

588

Please describe what you're doing here.

lib/CMakeLists.txt

12

Is it a debug output?

test/CMakeLists.txt

40

How do you handle CFI special case here?

test/ubsan/CMakeLists.txt

23

I actually think this macro is an overkill, and would prefer literal mentioning of COMPILER_RT_RUNTIMES_TO_BUILD here. Sorry for the nit.

[beanz]

Updated patches coming shortly. One comment below.

lib/CMakeLists.txt

12

I intended this to be much like the logging we do in LLVM for adding targets.

I thought this heading should be there because if there are no runtimes following it you know there are no runtimes being included.

[beanz]

Updates based on feedback from samsonov.

[samsonov]

LGTM. Thanks!

test/cfi/CMakeLists.txt

2 ↗

(On Diff #42331)

Copy the comment from test/CMakeLists.txt
\# CFI tests require diagnostic mode, which is implemented in UBSan.

cmake/Modules/CompilerRTUtils.cmake

 macro(append_list_if condition value)
   if(${condition})
     foreach(list ${ARGN})
       list(APPEND ${list} ${value})
     endforeach()
   endif()
 endmacro()
 
+# Appends values to list if it isn't already there
+macro(append_list_unique list)
+  foreach(val ${ARGN})
+    list(FIND ${list} ${val} idx)
+    if(idx EQUAL -1)
+      list(APPEND ${list} ${val})
+    endif()
+  endforeach()
+endmacro()
+
 # Appends value to all strings in ARGN, if the condition is true.
 macro(append_string_if condition value)
   if(${condition})
     foreach(str ${ARGN})
       set(${str} "${${str}} ${value}")
     endforeach()
   endif()
 endmacro()
macro(list_union output input1 input2)
   set(${output})
   foreach(it ${${input1}})
     list(FIND ${input2} ${it} index)
     if( NOT (index EQUAL -1))
       list(APPEND ${output} ${it})
     endif()
   endforeach()
 endmacro()
+
+macro(is_in_list outvar list input)
+  list(FIND ${list} ${input} idx)
+  if(idx GREATER -1)
+    set(${outvar} On)
+  else()
+    set(${outvar} Off)
+  endif()
+endmacro()
+
+macro(is_runtime_building outvar runtime)
+  is_in_list(${outvar} COMPILER_RT_RUNTIMES_TO_BUILD ${runtime})
+endmacro()
+
+

cmake/config-ix.cmake

if(ANDROID)
   set(OS_NAME "Android")
 else()
   set(OS_NAME "${CMAKE_SYSTEM_NAME}")
 endif()
 
 if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
     (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD" OR
     (OS_NAME MATCHES "Windows" AND MSVC)))
-  set(COMPILER_RT_HAS_SANITIZER_COMMON TRUE)
-else()
-  set(COMPILER_RT_HAS_SANITIZER_COMMON FALSE)
+  list(APPEND DEFAULT_RUNTIMES sanitizer_common)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND
-    (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4))
-  set(COMPILER_RT_HAS_INTERCEPTION TRUE)
-else()
-  set(COMPILER_RT_HAS_INTERCEPTION FALSE)
+if (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4)
+  list(APPEND DEFAULT_RUNTIMES interception)
+  list(APPEND REQUIRES_COMMON interception)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH AND
+if (ASAN_SUPPORTED_ARCH AND
     (NOT OS_NAME MATCHES "Windows" OR CMAKE_SIZEOF_VOID_P EQUAL 4))
-  set(COMPILER_RT_HAS_ASAN TRUE)
-else()
-  set(COMPILER_RT_HAS_ASAN FALSE)
+  list(APPEND DEFAULT_RUNTIMES asan)
+  list(APPEND REQUIRES_COMMON asan)
 endif()
 
 if (OS_NAME MATCHES "Linux|FreeBSD|Windows")
-  set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE)
-else()
-  set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME FALSE)
+  set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME On)
 endif()
 
 # TODO: Add builtins support.
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND DFSAN_SUPPORTED_ARCH AND
+if (DFSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
-  set(COMPILER_RT_HAS_DFSAN TRUE)
-else()
-  set(COMPILER_RT_HAS_DFSAN FALSE)
+  list(APPEND DEFAULT_RUNTIMES dfsan)
+  list(APPEND REQUIRES_COMMON dfsan)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND
-    OS_NAME MATCHES "Linux|FreeBSD")
-  set(COMPILER_RT_HAS_LSAN TRUE)
-else()
-  set(COMPILER_RT_HAS_LSAN FALSE)
+if (LSAN_SUPPORTED_ARCH AND OS_NAME MATCHES "Linux|FreeBSD")
+  list(APPEND DEFAULT_RUNTIMES lsan)
+  list(APPEND REQUIRES_COMMON lsan)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND
+if (MSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
-  set(COMPILER_RT_HAS_MSAN TRUE)
-else()
-  set(COMPILER_RT_HAS_MSAN FALSE)
+  list(APPEND DEFAULT_RUNTIMES msan)
+  list(APPEND REQUIRES_COMMON msan)
 endif()
 
 if (PROFILE_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD")
-  set(COMPILER_RT_HAS_PROFILE TRUE)
-else()
-  set(COMPILER_RT_HAS_PROFILE FALSE)
+  list(APPEND DEFAULT_RUNTIMES profile)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND TSAN_SUPPORTED_ARCH AND
+if (TSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD")
-  set(COMPILER_RT_HAS_TSAN TRUE)
-else()
-  set(COMPILER_RT_HAS_TSAN FALSE)
+  list(APPEND DEFAULT_RUNTIMES tsan)
+  list(APPEND REQUIRES_COMMON tsan)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
+if (UBSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows")
-  set(COMPILER_RT_HAS_UBSAN TRUE)
-else()
-  set(COMPILER_RT_HAS_UBSAN FALSE)
+  list(APPEND DEFAULT_RUNTIMES ubsan)
+  list(APPEND REQUIRES_COMMON ubsan)
+endif()
+
+if(OS_NAME MATCHES "Windows")
+  list(APPEND DEFAULT_RUNTIMES cfi)
 endif()
 
 # -msse3 flag is not valid for Mips therefore clang gives a warning
 # message with -msse3. But check_c_compiler_flags() checks only for
 # compiler error messages. Therefore COMPILER_RT_HAS_MSSE3_FLAG turns out to be
 # true on Mips, so we make it false here.
 if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mips")
   set(COMPILER_RT_HAS_MSSE3_FLAG FALSE)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND SAFESTACK_SUPPORTED_ARCH AND
+if (SAFESTACK_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD")
-  set(COMPILER_RT_HAS_SAFESTACK TRUE)
-else()
-  set(COMPILER_RT_HAS_SAFESTACK FALSE)
+  list(APPEND DEFAULT_RUNTIMES safestack)
+  list(APPEND REQUIRES_COMMON safestack)
+endif()
+
+set(COMPILER_RT_RUNTIMES_TO_BUILD "all"
+    CACHE STRING "Semicolon-separated list of runtimes to build, or \"all\".")
+
+if(COMPILER_RT_RUNTIMES_TO_BUILD STREQUAL "all")
+  set(COMPILER_RT_RUNTIMES_TO_BUILD ${DEFAULT_RUNTIMES})
 endif()
+
+list_union(SHOULD_BUILD_COMMON REQUIRES_COMMON COMPILER_RT_RUNTIMES_TO_BUILD)
+
+if(SHOULD_BUILD_COMMON)
+  append_list_unique(COMPILER_RT_RUNTIMES_TO_BUILD sanitizer_common)
+  append_list_unique(COMPILER_RT_RUNTIMES_TO_BUILD lsan)
+  append_list_unique(COMPILER_RT_RUNTIMES_TO_BUILD ubsan)
+  append_list_unique(COMPILER_RT_RUNTIMES_TO_BUILD interception)
+endif()
+

lib/CMakeLists.txt

 # First, add the subdirectories which contain feature-based runtime libraries
 # and several convenience helper libraries.
 
 include(AddCompilerRT)
 include(SanitizerUtils)
 
 if(COMPILER_RT_BUILD_BUILTINS)
   add_subdirectory(builtins)
 endif()
 
 if(COMPILER_RT_BUILD_SANITIZERS)
-  if(COMPILER_RT_HAS_INTERCEPTION)
-    add_subdirectory(interception)
-  endif()
-
-  if(COMPILER_RT_HAS_SANITIZER_COMMON)
-    add_subdirectory(sanitizer_common)
-    add_subdirectory(lsan)
-    add_subdirectory(ubsan)
-  endif()
-
-  add_subdirectory(cfi)
-
-  if(COMPILER_RT_HAS_ASAN)
-    add_subdirectory(asan)
-  endif()
-
-  if(COMPILER_RT_HAS_DFSAN)
-    add_subdirectory(dfsan)
-  endif()
-
-  if(COMPILER_RT_HAS_MSAN)
-    add_subdirectory(msan)
-  endif()
-
-  if(COMPILER_RT_HAS_PROFILE)
-    add_subdirectory(profile)
-  endif()
-
-  if(COMPILER_RT_HAS_TSAN)
-    add_subdirectory(tsan)
-    add_subdirectory(tsan/dd)
-  endif()
-
-  if(COMPILER_RT_HAS_SAFESTACK)
-    add_subdirectory(safestack)
-  endif()
+  message(STATUS "Adding runtimes...")
+  foreach(runtime ${COMPILER_RT_RUNTIMES_TO_BUILD})
+    message(STATUS "Adding runtime: ${runtime}")
+    add_subdirectory(${runtime})
+  endforeach()
 endif()

lib/lsan/CMakeLists.txt

 add_custom_target(lsan)
 
 add_compiler_rt_object_libraries(RTLSanCommon
     OS ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${LSAN_COMMON_SUPPORTED_ARCH}
     SOURCES ${LSAN_COMMON_SOURCES}
     CFLAGS ${LSAN_CFLAGS})
 
-if(COMPILER_RT_HAS_LSAN)
+is_runtime_building(BUILDING_LSAN lsan)
+if(BUILDING_LSAN)
   foreach(arch ${LSAN_SUPPORTED_ARCH})
     add_compiler_rt_runtime(clang_rt.lsan
       STATIC
       ARCHS ${arch}
       SOURCES ${LSAN_SOURCES}
               $<TARGET_OBJECTS:RTInterception.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
               $<TARGET_OBJECTS:RTLSanCommon.${arch}>
       CFLAGS ${LSAN_CFLAGS}
       PARENT_TARGET lsan)
   endforeach()
 endif()
 
 add_dependencies(compiler-rt lsan)

lib/tsan/CMakeLists.txt

if(COMPILER_RT_HAS_LIBCXX_SOURCES AND
   add_custom_libcxx(libcxx_tsan ${LIBCXX_PREFIX}
     DEPS ${TSAN_RUNTIME_LIBRARIES}
     CFLAGS -fsanitize=thread)
 endif()
 
 if(COMPILER_RT_INCLUDE_TESTS)
   add_subdirectory(tests)
 endif()
+
+add_subdirectory(dd)

lib/ubsan/CMakeLists.txt

 # Build for the undefined behavior sanitizer runtime support library.
 
+is_runtime_building(COMPILER_RT_HAS_UBSAN ubsan)
+
 set(UBSAN_SOURCES
   ubsan_diag.cc
   ubsan_init.cc
   ubsan_flags.cc
   ubsan_handlers.cc
   ubsan_value.cc
   )
 

test/CMakeLists.txt

if(NOT ANDROID)
   if(UNIX)
     list(APPEND SANITIZER_COMMON_LIT_TEST_DEPS SanitizerLintCheck)
   endif()
 endif()
 
 # Run sanitizer tests only if we're sure that clang would produce
 # working binaries.
 if(COMPILER_RT_CAN_EXECUTE_TESTS)
-  if(COMPILER_RT_HAS_ASAN)
-    add_subdirectory(asan)
-  endif()
-  if(COMPILER_RT_HAS_DFSAN)
-    add_subdirectory(dfsan)
-  endif()
-  if(COMPILER_RT_HAS_LSAN)
-    add_subdirectory(lsan)
-  endif()
-  if(COMPILER_RT_HAS_MSAN)
-    add_subdirectory(msan)
-  endif()
-  if(COMPILER_RT_HAS_PROFILE)
-    add_subdirectory(profile)
-  endif()
-  if(COMPILER_RT_HAS_SANITIZER_COMMON)
-    add_subdirectory(sanitizer_common)
-  endif()
-  if(COMPILER_RT_HAS_TSAN)
-    add_subdirectory(tsan)
-  endif()
-  if(COMPILER_RT_HAS_UBSAN)
-    add_subdirectory(ubsan)
-  endif()
-  # CFI tests require diagnostic mode, which is implemented in UBSan.
-  if(COMPILER_RT_HAS_UBSAN)
-    add_subdirectory(cfi)
-  endif()
-  if(COMPILER_RT_HAS_SAFESTACK)
-    add_subdirectory(safestack)
-  endif()
+  foreach(runtime ${COMPILER_RT_RUNTIMES_TO_BUILD})
+    add_subdirectory(${runtime})
+  endforeach()
 endif()
 
 if(COMPILER_RT_STANDALONE_BUILD)
   # Now that we've traversed all the directories and know all the lit testsuites,
   # introduce a rule to run to run all of them.
   get_property(LLVM_LIT_TESTSUITES GLOBAL PROPERTY LLVM_LIT_TESTSUITES)
   get_property(LLVM_LIT_DEPENDS GLOBAL PROPERTY LLVM_LIT_DEPENDS)
   add_lit_target(check-all
     "Running all regression tests"
     ${LLVM_LIT_TESTSUITES}
     DEPENDS ${LLVM_LIT_DEPENDS})
 endif()
+ 

test/interception/CMakeLists.txt

+# Placeholder to avoid special casing.

test/ubsan/CMakeLists.txt

macro(add_ubsan_testsuite test_mode sanitizer arch)
   endif()
 endmacro()
 
 set(UBSAN_TEST_ARCH ${UBSAN_SUPPORTED_ARCH})
 if(APPLE)
   darwin_filter_host_archs(UBSAN_SUPPORTED_ARCH UBSAN_TEST_ARCH)
 endif()
 
+is_runtime_building(HAS_ASAN asan)
+is_runtime_building(HAS_MSAN msan)
+is_runtime_building(HAS_TSAN tsan)
+
 foreach(arch ${UBSAN_TEST_ARCH})
   set(UBSAN_TEST_TARGET_ARCH ${arch})
   if(${arch} MATCHES "arm|aarch64")
     # This is only true if we're cross-compiling.
     set(UBSAN_TEST_TARGET_CFLAGS ${COMPILER_RT_TEST_COMPILER_CFLAGS})
   else()
     get_target_flags_for_arch(${arch} UBSAN_TEST_TARGET_CFLAGS)
     string(REPLACE ";" " " UBSAN_TEST_TARGET_CFLAGS "${UBSAN_TEST_TARGET_CFLAGS}")
   endif()
   add_ubsan_testsuite("Standalone" ubsan ${arch})
 
-  if(COMPILER_RT_HAS_ASAN AND ";${ASAN_SUPPORTED_ARCH};" MATCHES ";${arch};")
+  is_in_list(ASAN_HAS_ARCH ASAN_SUPPORTED_ARCH ${arch})
+  is_in_list(MSAN_HAS_ARCH MSAN_SUPPORTED_ARCH ${arch})
+  is_in_list(TSAN_HAS_ARCH TSAN_SUPPORTED_ARCH ${arch})
+
+  if(HAS_ASAN AND ASAN_HAS_ARCH)
     add_ubsan_testsuite("AddressSanitizer" asan ${arch})
   endif()
-  if(COMPILER_RT_HAS_MSAN AND ";${MSAN_SUPPORTED_ARCH};" MATCHES ";${arch};")
+  if(HAS_MSAN AND MSAN_HAS_ARCH)
     add_ubsan_testsuite("MemorySanitizer" msan ${arch})
   endif()
-  if(COMPILER_RT_HAS_TSAN AND ";${TSAN_SUPPORTED_ARCH};" MATCHES ";${arch};")
+  if(HAS_TSAN AND TSAN_HAS_ARCH)
     add_ubsan_testsuite("ThreadSanitizer" tsan ${arch})
   endif()
 endforeach()
 
 add_lit_testsuite(check-ubsan "Running UndefinedBehaviorSanitizer tests"
   ${UBSAN_TESTSUITES}
   DEPENDS ${UBSAN_TEST_DEPS})
 set_target_properties(check-ubsan PROPERTIES FOLDER "UBSan tests")