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

[beanz]

Summary

Trying this again after I had to back it out due to bot failures.

I believe the bot failrues were the result of the interception library getting picked up in places it shouldn't have been. This is fixed by adding the REQUIRES_INTERCEPTION list. Original code review (http://reviews.llvm.org/D14846).

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]

cmake/config-ix.cmake

630

I think you should do the same for "stats" library. It's not a part of sanitizer_common, it uses sanitizer_common. So, this
should be smth. like

if (OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows")
  list(APPEND DEFAULT_RUNTIMES stats)
  list(APPEND REQUIRES_COMMON stats)
endif()

and remove adding stats below from "SHOULD_BUILD_COMMON".

646

I don't fully understand how it works: you seem to add "ubsan" to COMPILER_RT_RUNTIMES_TO_BUILD always if you need sanitizer_common, which will lead to COMPILER_RT_HAS_UBSAN being true in that case. That's not true: e.g. if UBSAN_SUPPORTED_ARCH is empty you don't need to create UBSan runtime, or execute UBSan tests.

[beanz]

cmake/config-ix.cmake

630

I can make that change.

Additional explanation in my next comment.

646

I had based this on the if(COMPILER_RT_HAS_SANITIZER_COMMON) block that exists in lib/CMakeLists.txt today.

The complication is that some of these libraries (like ubsan and lsan) produce object libs even if you're not actually building the sanitizer, and those object libraries get used all over the place without checking to make sure the corresponding sanitizer is supported.

I probably need to re-think how to handle those. If you have suggestions I'd appreciate them, but I'll head back to the drawing board.

[beanz]

Changed handling of lsan and ubsan to generate object libraries without building the actual runtimes.

[samsonov]

cmake/config-ix.cmake

655

Hm, do you need to remove/update this now?

lib/CMakeLists.txt

17

Looks like you have to pepper these check_list_contains code around the CMakeLists.txt now. WDYT of generating them in a single place
in config-ix.cmake, and using them as is?

foreach(runtime ${COMPILER_RT_RUNTIMES_TO_BUILD})
  string(TOUPPER ${runtime} runtime_toupper)
  set(COMPILER_RT_HAS_${runtime_toupper} True)
endforeach()

?

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(check_list_contains outvar list input)
+  list(FIND ${list} ${input} idx)
+  if(idx GREATER -1)
+    set(${outvar} True)
+  else()
+    set(${outvar} False)
+  endif()
+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)
+  list(APPEND REQUIRES_INTERCEPTION 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)
+  list(APPEND REQUIRES_INTERCEPTION 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)
+  list(APPEND REQUIRES_INTERCEPTION 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)
+  list(APPEND REQUIRES_INTERCEPTION msan)
 endif()
 
 if (PROFILE_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Darwin|Linux|FreeBSD|Windows")
-  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)
+  list(APPEND REQUIRES_INTERCEPTION 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()
+list(APPEND DEFAULT_RUNTIMES cfi)
 
-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)
+  list(APPEND REQUIRES_INTERCEPTION 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()
+
+# Several of the runtimes produce object libraries that are consumed by other
+# runtimes (i.e. asan relies on ubsan). If you're building a library that relies
+# on common bits we need to build this full set of libraries.
+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 stats)
+endif()
+
+# Several of the runtimes require the interception library. If you're building
+# cfi, dfsan, lsan, msan, safestack, or tsan, we need interception too
+list_union(SHOULD_BUILD_INTERCEPTION REQUIRES_INTERCEPTION COMPILER_RT_RUNTIMES_TO_BUILD)
+if(SHOULD_BUILD_INTERCEPTION)
+  append_list_unique(COMPILER_RT_RUNTIMES_TO_BUILD interception)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND CFI_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_CFI TRUE)
 else()
   set(COMPILER_RT_HAS_CFI FALSE)
 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(stats)
+  message(STATUS "Adding runtimes...")
+  foreach(runtime ${COMPILER_RT_RUNTIMES_TO_BUILD})
+    message(STATUS "Adding runtime: ${runtime}")
+    add_subdirectory(${runtime})
+  endforeach()
+  check_list_contains(COMPILER_RT_HAS_COMMON COMPILER_RT_RUNTIMES_TO_BUILD sanitizer_common)
+  
+  check_list_contains(COMPILER_RT_HAS_LSAN COMPILER_RT_RUNTIMES_TO_BUILD lsan)
+  if(COMPILER_RT_HAS_COMMON AND NOT COMPILER_RT_HAS_LSAN)
+    message(STATUS "Adding lsan common components.")
     add_subdirectory(lsan)
-    add_subdirectory(ubsan)
-  endif()
-
-  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()
 
-  if(COMPILER_RT_HAS_CFI)
-    add_subdirectory(cfi)
+  check_list_contains(COMPILER_RT_HAS_UBSAN COMPILER_RT_RUNTIMES_TO_BUILD ubsan)
+  if(COMPILER_RT_HAS_COMMON AND NOT COMPILER_RT_HAS_UBSAN)
+    message(STATUS "Adding ubsan common components.")
+    add_subdirectory(ubsan)
   endif()
 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})
 
+check_list_contains(COMPILER_RT_HAS_LSAN COMPILER_RT_RUNTIMES_TO_BUILD lsan)
 if(COMPILER_RT_HAS_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.
 
+check_list_contains(COMPILER_RT_HAS_UBSAN COMPILER_RT_RUNTIMES_TO_BUILD 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/cfi/CMakeLists.txt

+check_list_contains(HAS_UBSAN COMPILER_RT_RUNTIMES_TO_BUILD ubsan)
+# CFI tests require diagnostic mode, which is implemented in UBSan.
+if(NOT HAS_UBSAN)
+  return()
+endif()
+
 configure_lit_site_cfg(
   ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
   ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
   )
 
 set(CFI_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
 if(NOT COMPILER_RT_STANDALONE_BUILD)
   list(APPEND CFI_TEST_DEPS

test/interception/CMakeLists.txt

+# Placeholder to avoid special casing.

test/stats/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()
 
+check_list_contains(HAS_ASAN COMPILER_RT_RUNTIMES_TO_BUILD asan)
+check_list_contains(HAS_MSAN COMPILER_RT_RUNTIMES_TO_BUILD msan)
+check_list_contains(HAS_TSAN COMPILER_RT_RUNTIMES_TO_BUILD 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};")
+  check_list_contains(ASAN_HAS_ARCH ASAN_SUPPORTED_ARCH ${arch})
+  check_list_contains(MSAN_HAS_ARCH MSAN_SUPPORTED_ARCH ${arch})
+  check_list_contains(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")