[compiler-rt] separate lsan, ubsan, stats configuration from SANITIZER_COMMON_SUPPORTED_OS

[aralisza]

Summary

Currently, SANITIZER_COMMON_SUPPORTED_OS is being used to enable many libraries.
Unfortunately this makes it impossible to selectively disable a library based on the OS.
This patch removes this limitation by adding a separate list of supported OSs for the lsan, ubsan, ubsan_minimal, and stats libraries.

[aralisza]

mimic existing code instead of copying SANITIZER_COMMON_SUPPORTED_OS

[aralisza]

add convert ubsan (non-minimal) to use UBSAN_SUPPORTED_OS as well

[delcypher]

You probably need to mention the ubsan runtime library in your commit message. Other than that LGTM.

[aralisza]

review

compiler-rt/cmake/config-ix.cmake

if(APPLE)
   endif()
 
   set(SANITIZER_COMMON_SUPPORTED_OS osx)
   set(PROFILE_SUPPORTED_OS osx)
   set(TSAN_SUPPORTED_OS osx)
   set(XRAY_SUPPORTED_OS osx)
   set(FUZZER_SUPPORTED_OS osx)
   set(ORC_SUPPORTED_OS osx)
+  set(UBSAN_SUPPORTED_OS osx)
+  set(LSAN_SUPPORTED_OS osx)
+  set(STATS_SUPPORTED_OS osx)
 
   # Note: In order to target x86_64h on OS X the minimum deployment target must
   # be 10.8 or higher.
   set(DEFAULT_SANITIZER_MIN_OSX_VERSION 10.10)
   set(DARWIN_osx_MIN_VER_FLAG "-mmacosx-version-min")
   if(NOT SANITIZER_MIN_OSX_VERSION)
     string(REGEX MATCH "${DARWIN_osx_MIN_VER_FLAG}=([.0-9]+)"
            MACOSX_VERSION_MIN_FLAG "${CMAKE_CXX_FLAGS}")
foreach(platform ${DARWIN_EMBEDDED_PLATFORMS})
           ${toolchain_arches})
         message(STATUS "${platform} Simulator supported arches: ${DARWIN_${platform}sim_ARCHS}")
         if(DARWIN_${platform}sim_ARCHS)
           list(APPEND SANITIZER_COMMON_SUPPORTED_OS ${platform}sim)
           list(APPEND PROFILE_SUPPORTED_OS ${platform}sim)
           list(APPEND TSAN_SUPPORTED_OS ${platform}sim)
           list(APPEND FUZZER_SUPPORTED_OS ${platform}sim)
           list(APPEND ORC_SUPPORTED_OS ${platform}sim)
+          list(APPEND UBSAN_SUPPORTED_OS ${platform}sim)
+          list(APPEND LSAN_SUPPORTED_OS ${platform}sim)
+          list(APPEND STATS_SUPPORTED_OS ${platform}sim)
         endif()
         foreach(arch ${DARWIN_${platform}sim_ARCHS})
           list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
           set(CAN_TARGET_${arch} 1)
         endforeach()
       endif()
 
       if(DARWIN_${platform}_SYSROOT)
foreach(platform ${DARWIN_EMBEDDED_PLATFORMS})
           list(APPEND PROFILE_SUPPORTED_OS ${platform})
 
           list_intersect(DARWIN_${platform}_TSAN_ARCHS DARWIN_${platform}_ARCHS ALL_TSAN_SUPPORTED_ARCH)
           if(DARWIN_${platform}_TSAN_ARCHS)
             list(APPEND TSAN_SUPPORTED_OS ${platform})
           endif()
           list(APPEND FUZZER_SUPPORTED_OS ${platform})
           list(APPEND ORC_SUPPORTED_OS ${platform})
+          list(APPEND UBSAN_SUPPORTED_OS ${platform})
+          list(APPEND LSAN_SUPPORTED_OS ${platform})
+          list(APPEND STATS_SUPPORTED_OS ${platform})
         endif()
         foreach(arch ${DARWIN_${platform}_ARCHS})
           list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
           set(CAN_TARGET_${arch} 1)
         endforeach()
       endif()
     endforeach()
   endif()

compiler-rt/lib/lsan/CMakeLists.txt

if(COMPILER_RT_HAS_LSAN)
   if(APPLE)
     set(LSAN_LINK_LIBS ${SANITIZER_COMMON_LINK_LIBS})
 
     add_weak_symbols("lsan" WEAK_SYMBOL_LINK_FLAGS)
     add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
 
     add_compiler_rt_runtime(clang_rt.lsan
       SHARED
-      OS ${SANITIZER_COMMON_SUPPORTED_OS}
+      OS ${LSAN_SUPPORTED_OS}
       ARCHS ${LSAN_SUPPORTED_ARCH}
       SOURCES ${LSAN_SOURCES}
       ADDITIONAL_HEADERS ${LSAN_HEADERS}
       OBJECT_LIBS RTLSanCommon
                   RTInterception
                   RTSanitizerCommon
                   RTSanitizerCommonLibc
                   RTSanitizerCommonCoverage

compiler-rt/lib/stats/CMakeLists.txt

else()
   set(STATS_LIB_FLAVOR STATIC)
 
   set(WEAK_SYMBOL_LINK_FLAGS)
 endif()
 
 add_compiler_rt_runtime(clang_rt.stats
   ${STATS_LIB_FLAVOR}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
-  OS ${SANITIZER_COMMON_SUPPORTED_OS}
+  OS ${STATS_SUPPORTED_OS}
   SOURCES stats.cpp
   ADDITIONAL_HEADERS ${STATS_HEADERS}
   OBJECT_LIBS RTSanitizerCommon
               RTSanitizerCommonLibc
               RTSanitizerCommonSymbolizer
   CFLAGS ${SANITIZER_COMMON_CFLAGS}
   LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS}
   LINK_LIBS ${STATS_LINK_LIBS}
   PARENT_TARGET stats)
 
 add_compiler_rt_runtime(clang_rt.stats_client
   STATIC
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
-  OS ${SANITIZER_COMMON_SUPPORTED_OS}
+  OS ${STATS_SUPPORTED_OS}
   SOURCES stats_client.cpp
   ADDITIONAL_HEADERS ${STATS_HEADERS}
   CFLAGS ${SANITIZER_COMMON_CFLAGS}
   LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
   PARENT_TARGET stats)

compiler-rt/lib/ubsan/CMakeLists.txt

add_compiler_rt_object_libraries(RTUbsan
     ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
     SOURCES ${UBSAN_COMMON_SOURCES}
     ADDITIONAL_HEADERS ${UBSAN_HEADERS}
     CFLAGS ${UBSAN_CXXFLAGS})
 
   if(COMPILER_RT_HAS_UBSAN)
     # Initializer of standalone UBSan runtime.
     add_compiler_rt_object_libraries(RTUbsan_standalone
-      OS ${SANITIZER_COMMON_SUPPORTED_OS}
+      OS ${UBSAN_SUPPORTED_OS}
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       SOURCES ${UBSAN_STANDALONE_SOURCES}
       ADDITIONAL_HEADERS ${UBSAN_HEADERS}
       CFLAGS ${UBSAN_STANDALONE_CFLAGS})
 
     add_weak_symbols("ubsan" WEAK_SYMBOL_LINK_FLAGS)
     add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
 
     add_compiler_rt_runtime(clang_rt.ubsan
       SHARED
-      OS ${SANITIZER_COMMON_SUPPORTED_OS}
+      OS ${UBSAN_SUPPORTED_OS}
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       OBJECT_LIBS RTUbsan
                   RTUbsan_standalone
                   RTSanitizerCommon
                   RTSanitizerCommonLibc
                   RTSanitizerCommonCoverage
                   RTSanitizerCommonSymbolizer
                   RTInterception
       LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
       PARENT_TARGET ubsan)
 
     add_compiler_rt_runtime(clang_rt.ubsan
       STATIC
-      OS ${SANITIZER_COMMON_SUPPORTED_OS}
+      OS ${UBSAN_SUPPORTED_OS}
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       OBJECT_LIBS RTUbsan
                   RTUbsan_standalone
                   RTSanitizerCommonNoHooks
                   RTSanitizerCommonLibcNoHooks
                   RTSanitizerCommonCoverage
                   RTSanitizerCommonSymbolizerNoHooks
                   RTInterception

compiler-rt/lib/ubsan_minimal/CMakeLists.txt

add_compiler_rt_object_libraries(RTUbsan_minimal
   ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
   SOURCES ${UBSAN_MINIMAL_SOURCES} CFLAGS ${UBSAN_CFLAGS})
 
 
 if(COMPILER_RT_HAS_UBSAN_MINIMAL)
   # Standalone minimal UBSan runtimes.
   add_compiler_rt_runtime(clang_rt.ubsan_minimal
     STATIC
-    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    OS ${UBSAN_SUPPORTED_OS}
     ARCHS ${UBSAN_SUPPORTED_ARCH}
     OBJECT_LIBS RTUbsan_minimal
     CFLAGS ${UBSAN_CFLAGS}
     PARENT_TARGET ubsan-minimal)
 
   add_compiler_rt_runtime(clang_rt.ubsan_minimal
     SHARED
-    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    OS ${UBSAN_SUPPORTED_OS}
     ARCHS ${UBSAN_SUPPORTED_ARCH}
     OBJECT_LIBS RTUbsan_minimal
     CFLAGS ${UBSAN_CFLAGS}
     LINK_FLAGS ${UBSAN_LINK_FLAGS}
     LINK_LIBS ${UBSAN_DYNAMIC_LIBS}
     PARENT_TARGET ubsan-minimal)
 
   if (SANITIZER_USE_SYMBOLS AND NOT APPLE)
     set(ARCHS_FOR_SYMBOLS ${UBSAN_SUPPORTED_ARCH})
     list(REMOVE_ITEM ARCHS_FOR_SYMBOLS i386 i686)
     add_sanitizer_rt_symbols(clang_rt.ubsan_minimal
       ARCHS ${ARCHS_FOR_SYMBOLS}
       PARENT_TARGET ubsan-minimal
       EXTRA ubsan.syms.extra)
   endif()
 endif()

compiler-rt/test/ubsan/CMakeLists.txt

foreach(arch ${UBSAN_TEST_ARCH})
     add_ubsan_testsuites("StandaloneStatic" ubsan ${arch})
   endforeach()
 
   # Device and simulator test suites.
   # These are not added into "check-all", in order to run these tests, use
   # "check-asan-iossim-x86_64" and similar. They also require that an extra env
   # variable to select which iOS device or simulator to use, e.g.:
   # SANITIZER_IOSSIM_TEST_DEVICE_IDENTIFIER="iPhone 6"
-  set(UBSAN_APPLE_PLATFORMS ${SANITIZER_COMMON_SUPPORTED_OS})
+  set(UBSAN_APPLE_PLATFORMS ${UBSAN_SUPPORTED_OS})
   foreach(platform ${UBSAN_APPLE_PLATFORMS})
     list_intersect(
       UBSAN_TEST_${platform}_ARCHS
       UBSAN_SUPPORTED_ARCH
       DARWIN_${platform}_ARCHS
       )
     foreach(arch ${UBSAN_TEST_${platform}_ARCHS})
       get_test_cflags_for_apple_platform(