[CMake] merge add_compiler_rt_runtime and add_compiler_rt_darwin_runtime into a single function

[beanz]

Summary

This refactoring moves much of the Apple-specific behavior into a function in AddCompilerRT. The next cleanup patch will remove more of the if(APPLE) checks in the outlying CMakeLists.

[beanz]

Forgot to save my latest changes to ubsan/CMakeLists.txt

[rengolin]

Hi Chris,

Have you tested this on Linux? Maybe some ARM/AArch64, too?

cheers,
--renato

[rengolin]

This comment was removed by rengolin.

[beanz]

I have tested it on Linux. I have not tested Linux ARM/AArch64, as I don’t have hardware for that config. I have tested darwin configs.

-Chris

[beanz]

In working on follow-up patches I did some cleanup that applied to these patches, and fixed an issue with hooking up dependencies.

[samsonov]

cmake/Modules/AddCompilerRT.cmake

59

LIBS->LINK_LIBS (specify that it makes sense for shared libraries only)

63

I would leave SHARED/STATIC as type argument of add_compiler_rt_runtime function. Otherwise you can specify both STATIC and SHARED, which makes no sense. You should also diagnose if none is specified.

77

Looks like type_${libname} will be the same for all ${libname}, you don't really need it now.

101

Note that currently we pass LIB_CFLAGS to as linkflags as well, you probably want to keep this behavior for now.

101

There is no such thing as ${TARGET_${arch}_LINKFLAGS}

103

You've already checked for that.

114

You've already checked for that.

121

You can probably do

if(NOT libnames)
  return()
endif()

and skip all the checks below.

123

COMPONENT_OPTION

141

This whole OUTPUT_NAME logic looks terrible now, especially assuming you can have several ${libname} libraries, but you pass a single OUTPUT_NAME for them. Ugh. Looks like it's only really used on Windows, maybe you will just adjust for naming difference on Windows and Linux at the place where you generate ${libname}, and get rid of this argument?

143

Only if we're linking SHARED compiler-rt runtime?

lib/dfsan/CMakeLists.txt

25

Why don't you use PARENT_TARGET here (and in similar places below)?

[beanz]

A few comments inline. I'll work up patches to address your feedback and send them out shortly.

cmake/Modules/AddCompilerRT.cmake

63

There are situations where we build both static and dynamic libs. tsan/dd/CMakeLists.txt is one example. I was hoping to collapse that all down to one call to add_compiler_rt_runtime

If you think it is better to support only one type I can do that. It will allow me to simplify some of the body of add_compiler_t_runtime too.

141

Yea... This is actually broken in my patches, and I think the behavior is broken. I'll try and revise it to be more sane.

[samsonov]

cmake/Modules/AddCompilerRT.cmake

63

Yes, let's just support one type for now. If absolutely necessary, we could just call add_compiler_rt_runtime twice (we most likely would need to do it anyway, because CFLAGS/DEFS would be different in that case).

[beanz]

Updates based on feedback from samsonov.

• Made add_compiler_rt_runtime only handle one type of library per call
• General cleanup
• Fixed a bunch of places where I was missing PARENT_TARGET settings
• Removed OUTPUT_NAME and special cased WIN32

[samsonov]

cmake/Modules/AddCompilerRT.cmake

150

There is no such argument now.

160

You should also set output_name for shared libraries on Unix - ${name}-${arch}${COMPILER_RT_OS_SUFFIX} (note: no dynamic here)... which probably means it's easier to set output_name_${libname} for *all* libraries here, in this loop, and then just remove special case from the loop below.

169

you don't use LIB_CFLAGS in add_compiler_rt_darwin_runtime(.. SHARED ...).

lib/asan/CMakeLists.txt

200–201

Pass ${ASAN_DYNAMIC_LIBS} to add_compiler_rt_runtime as LINK_LIBS?

lib/profile/CMakeLists.txt

30

Please leave the loop over PROFILE_SUPPORTED_ARCH here for this change, and let's collapse it here (and in similar places, like lsan) in subsequent changes.

lib/tsan/CMakeLists.txt

112

PARENT_TARGET tsan

lib/tsan/dd/CMakeLists.txt

43

Now this is named LINK_LIBS

[beanz]

Updated patches coming. One comment below.

lib/profile/CMakeLists.txt

30

Please make up your mind over whether or not you want me to adapt the CMakeLists.txt files in this patch. In your comments here you have both asked me to make more changes to the CMakeLists files, and to make less changes.

[samsonov]

lib/profile/CMakeLists.txt

30

Sorry if I wasn't clear enough. I suggest to leave

foreach(arch ${XXX_SUPPORTED_ARCH})

in every lib/xxx/CMakeLists.txt as is: that is, pass a single arch to add_compiler_rt_runtime on non-Apple platforms for now.

[beanz]

lib/profile/CMakeLists.txt

30

Why? Without this change there is no code testing the new loop.

I need you to be clear about what you want in patches. Your feedback has been very valuable, but inconsistent. Much of your feedback was calling out places where I wasn't using new functionality that these patches introduced, except this piece which is the opposite.

In writing my patches I'm trying to keep non-essential changes to a minimum, but I do want to make enough changes to exercise the new functionality. I didn't change every place to PARENT_TARGET or LINKLIBS because I figured those could be small easy follow-up patches. Your feedback has been to use those features, but not to use the multi-architecture support.

I need to understand why so that I can write my patches closer to how you want them the first time.

[beanz]

Updates based on feedback from samsonov.

[beanz]

Fixing missing '_' in LINK_LIBS

[samsonov]

LGTM

lib/asan/CMakeLists.txt

200–201

LINK_LIBS

lib/profile/CMakeLists.txt

30–31

Thank you for bringing this up, as it seems it to be the main source of confusion in the review thread (and sorry for not making my point clear). As I understand it now, you want to:

1. implement and commit add_compiler_rt_runtime with all the features you find useful (LINK_LIBS, PARENT_TARGET, multi-arch support)
2. exercise each of new features in 1-2 places to have them tested, but keep the change small.
3. (in a follow-up change) migrate everyone else to use new features.

While I was more used to (and tried to push you in that direction) a different approach, which keeps the build rules for various compiler-rt runtimes consistent at every revision: if there's a feature in add_compiler_rt_runtime function they use, then either all of them make use of it, or none of them. In that case the path could be:

1. add simple and short version of add_compiler_rt_runtime and migrage build rules to use it
2. (in a separate change) add PARENT_TARGET argument, and use it where applicable
3. (in a separate change) add LINK_LIBS argument, and use it where applicable.
4. (in a separate change) add multi-arch support and use it

...

It could make the changes smaller and more granular, and (as mentioned earlier) the code would be consistent at every point. On a flip side, each change would touch multiple files across a lot of directories. It's a matter of taste, really, and it's probably not worth to split this change into several smaller ones at this point. I'll be happy either way as long as you will lay out the plan for further refactoring in a commit message.

cmake/Modules/AddCompilerRT.cmake

set_property(TARGET ${libname} APPEND PROPERTY
       COMPILE_DEFINITIONS ${LIB_DEFS})
     if(APPLE)
       set_target_properties(${libname} PROPERTIES
         OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}")
     endif()
   endforeach()
 endfunction()
 
-# Adds static or shared runtime for a given architecture and puts it in the
-# proper directory in the build and install trees.
-# add_compiler_rt_runtime(<name> <arch> {STATIC,SHARED}
+# Adds static or shared runtime for a list of architectures and operating
+# systems and puts it in the proper directory in the build and install trees.
+# add_compiler_rt_runtime(<name>
+#                         {STATIC|SHARED}
+#                         ARCHS <architectures>
+#                         OS <os list>
 #                         SOURCES <source files>
 #                         CFLAGS <compile flags>
+#                         LINKFLAGS <linker flags>
 #                         DEFS <compile definitions>
-#                         OUTPUT_NAME <output library name>)
-macro(add_compiler_rt_runtime name arch type)
-  if(CAN_TARGET_${arch})
-    cmake_parse_arguments(LIB "" "OUTPUT_NAME" "SOURCES;CFLAGS;LINKFLAGS;DEFS" ${ARGN})
-    add_library(${name} ${type} ${LIB_SOURCES})
-    # Setup compile flags and definitions.
-    set_target_compile_flags(${name}
-      ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
-    set_target_link_flags(${name}
-      ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS} ${LIB_LINKFLAGS})
-    set_property(TARGET ${name} APPEND PROPERTY
+#                         LIBS <linked libraries>
+#                         OUTPUT_NAME <output library name>
+#                         PARENT_TARGET <convenience parent target>)
+function(add_compiler_rt_runtime name)
+  cmake_parse_arguments(LIB "SHARED;STATIC"
+    "OUTPUT_NAME;PARENT_TARGET"
+    "ARCHS;SOURCES;CFLAGS;LINKFLAGS;DEFS;OS;LIBS"
+    ${ARGN})
+  set(libnames)
+  if(APPLE)
+    foreach(os ${LIB_OS})
+      if(LIB_STATIC)
+        set(libname "${name}_${os}")
+        list_union(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS)
+        if(LIB_ARCHS_${libname})
+          list(APPEND libnames ${libname})
+          set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS} ${LIB_CFLAGS})
+          set(extra_linkflags_${libname} ${DARWIN_${os}_LINKFLAGS} ${LIB_LINKFLAGS})
+          set(type_${libname} STATIC)
+        endif()
+      endif()
+      if(LIB_SHARED)
+        set(libname "${name}_${os}_dynamic")
+        list_union(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS)
+        if(LIB_ARCHS_${libname})
+          list(APPEND libnames ${libname})
+          set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS} ${LIB_CFLAGS})
+          set(extra_linkflags_${libname} ${DARWIN_${os}_LINKFLAGS} ${LIB_LINKFLAGS})
+          set(type_${libname} SHARED)
+        endif()
+      endif()
+    endforeach()
+  else()
+    foreach(arch ${LIB_ARCHS})
+      if(NOT CAN_TARGET_${arch})
+        message(FATAL_ERROR "Architecture ${arch} can't be targeted")
+        return()
+      endif()
+      if(LIB_STATIC)
+        set(libname "${name}-${arch}")
+        set(libnames ${libnames} ${libname})
+        set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
+        set(extra_linkflags_${libname} ${TARGET_${arch}_LINKFLAGS} ${LIB_LINKFLAGS})
+        set(type_${libname} STATIC)
+        if(NOT CAN_TARGET_${arch})
+          message(FATAL_ERROR "Architecture ${arch} can't be targeted")
+          return()
+        endif()
+      endif()
+      if(LIB_SHARED)
+        set(libname "${name}-dynamic-${arch}")
+        set(libnames ${libnames} ${libname})
+        set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
+        set(extra_linkflags_${libname} ${TARGET_${arch}_LINKFLAGS} ${LIB_LINKFLAGS})
+        set(type_${libname} SHARED)
+        if(NOT CAN_TARGET_${arch})
+          message(FATAL_ERROR "Architecture ${arch} can't be targeted")
+          return()
+        endif()
+      endif()
+    endforeach()
+  endif()
+
+  if(LIB_PARENT_TARGET AND libnames)
+    set(COMONENT_OPTION COMPONENT ${LIB_PARENT_TARGET})
+  endif()
+
+  foreach(libname ${libnames})
+    add_library(${libname} ${type_${libname}} ${LIB_SOURCES})
+    set_target_compile_flags(${libname} ${extra_cflags_${libname}})
+    set_target_link_flags(${libname} ${extra_linkflags_${libname}})
+    set_property(TARGET ${libname} APPEND PROPERTY 
                 COMPILE_DEFINITIONS ${LIB_DEFS})
-    # Setup correct output directory in the build tree.
-    set_target_properties(${name} PROPERTIES
+    set_target_properties(${libname} PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
         LIBRARY_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
         RUNTIME_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
     if ("${LIB_OUTPUT_NAME}" STREQUAL "")
-      set_target_properties(${name} PROPERTIES
-        OUTPUT_NAME ${name}${COMPILER_RT_OS_SUFFIX})
+      set_target_properties(${libname} PROPERTIES
+        OUTPUT_NAME ${libname}${COMPILER_RT_OS_SUFFIX})
     else()
-      set_target_properties(${name} PROPERTIES
+      set_target_properties(${libname} PROPERTIES
         OUTPUT_NAME ${LIB_OUTPUT_NAME})
     endif()
-    # Add installation command.
-    install(TARGETS ${name}
+    if(LIB_LIBS)
+      target_link_libraries(${libname} ${LIB_LIBS})
+    endif()
+    install(TARGETS ${libname}
       ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
+              ${COMONENT_OPTION}
       LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
-      RUNTIME DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
-  else()
-    message(FATAL_ERROR "Architecture ${arch} can't be targeted")
-  endif()
-endmacro()
-
-# Adds runtime library for darwin platforms, which supports multiple
-# architectures.
-# add_compiler_rt_darwin_runtime(<name> <os>
-#                                STATIC|SHARED
-#                                ARCHS <architectures>
-#                                SOURCES <source files>
-#                                CFLAGS <compile flags>
-#                                DEFS <compile definitions>
-#                                LINKFLAGS <link flags>)
-function(add_compiler_rt_darwin_runtime name os)
-  cmake_parse_arguments(LIB "SHARED;STATIC" "" "ARCHS;SOURCES;CFLAGS;DEFS;LINKFLAGS" ${ARGN})
-  list_union(filtered_arches DARWIN_${os}_ARCHS LIB_ARCHS)
-  # if there are no supported architectures, don't create the library
-  if(filtered_arches)
-    if(LIB_SHARED)
-      add_library(${name} SHARED ${LIB_SOURCES})
-      set_target_properties(${name} PROPERTIES
-        LIBRARY_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
-      install(TARGETS ${name}
-        LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
-    elseif(LIB_STATIC)
-      add_library(${name} STATIC ${LIB_SOURCES})
-      set_target_properties(${name} PROPERTIES
-        ARCHIVE_OUTPUT_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR})
-      install(TARGETS ${name}
-        ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
-    else()
-      message(FATAL_ERROR "Must specified SHARED|STATIC to add_compiler_rt_darwin_runtime")
+              ${COMONENT_OPTION}
+      RUNTIME DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
+              ${COMONENT_OPTION})
+    if(APPLE)
+      set_target_properties(${libname} PROPERTIES
+      OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}")
     endif()
-    
-    set_target_compile_flags(${name} ${LIB_CFLAGS} ${DARWIN_${os}_CFLAGS})
-    set_target_link_flags(${name} ${LIB_LINKFLAGS} ${DARWIN_${os}_LINKFLAGS})
-    set_property(TARGET ${name} APPEND PROPERTY
-      COMPILE_DEFINITIONS ${LIB_DEFS})
-
-    set_target_properties(${name} PROPERTIES
-      OSX_ARCHITECTURES "${filtered_arches}")
+  endforeach()
+  if(LIB_PARENT_TARGET AND libnames)
+    add_dependencies(${LIB_PARENT_TARGET} ${libnames})
   endif()
 endfunction()
 
 set(COMPILER_RT_TEST_CFLAGS)
 
 # Unittests support.
 set(COMPILER_RT_GTEST_PATH ${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest)
 set(COMPILER_RT_GTEST_SOURCE ${COMPILER_RT_GTEST_PATH}/src/gtest-all.cc)
 set(COMPILER_RT_GTEST_CFLAGS
   -DGTEST_NO_LLVM_RAW_OSTREAM=1
   -DGTEST_HAS_RTTI=0
   -I${COMPILER_RT_GTEST_PATH}/include
   -I${COMPILER_RT_GTEST_PATH}
 )
 
 append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 COMPILER_RT_TEST_CFLAGS)
 
 if(MSVC)

lib/asan/CMakeLists.txt

add_compiler_rt_object_libraries(RTAsan_dynamic_version_script_dummy
     CFLAGS ${ASAN_DYNAMIC_CFLAGS}
     DEFS ${ASAN_DYNAMIC_DEFINITIONS})
 endif()
 
 # Build ASan runtimes shipped with Clang.
 add_custom_target(asan)
 if(APPLE)
   foreach (os ${SANITIZER_COMMON_SUPPORTED_OS})
-    add_compiler_rt_darwin_runtime(clang_rt.asan_${os}_dynamic ${os}
+    add_compiler_rt_runtime(clang_rt.asan
       SHARED
+      OS ${os}
       ARCHS ${ASAN_SUPPORTED_ARCH}
       SOURCES $<TARGET_OBJECTS:RTAsan.${os}>
               $<TARGET_OBJECTS:RTInterception.${os}>
               $<TARGET_OBJECTS:RTSanitizerCommon.${os}>
               $<TARGET_OBJECTS:RTLSanCommon.${os}>
               $<TARGET_OBJECTS:RTUbsan.${os}>
       CFLAGS ${ASAN_DYNAMIC_CFLAGS}
-      DEFS ${ASAN_DYNAMIC_DEFINITIONS})
-    add_dependencies(asan clang_rt.asan_${os}_dynamic)
+      DEFS ${ASAN_DYNAMIC_DEFINITIONS}
+      PARENT_TARGET asan)
   endforeach()
 else()
   # Build separate libraries for each target.
   foreach(arch ${ASAN_SUPPORTED_ARCH})
     set(ASAN_COMMON_RUNTIME_OBJECTS
       $<TARGET_OBJECTS:RTInterception.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
       $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
       $<TARGET_OBJECTS:RTLSanCommon.${arch}>
       $<TARGET_OBJECTS:RTUbsan.${arch}>)
 
-    add_compiler_rt_runtime(clang_rt.asan-${arch} ${arch} STATIC
+    add_compiler_rt_runtime(clang_rt.asan
+      STATIC
+      ARCHS ${arch}
       SOURCES $<TARGET_OBJECTS:RTAsan_preinit.${arch}>
               $<TARGET_OBJECTS:RTAsan.${arch}>
               ${ASAN_COMMON_RUNTIME_OBJECTS}
       CFLAGS ${ASAN_CFLAGS}
-      DEFS ${ASAN_COMMON_DEFINITIONS})
-    add_dependencies(asan clang_rt.asan-${arch})
+      DEFS ${ASAN_COMMON_DEFINITIONS}
+      PARENT_TARGET asan)
 
-    add_compiler_rt_runtime(clang_rt.asan_cxx-${arch} ${arch} STATIC
+    add_compiler_rt_runtime(clang_rt.asan_cxx
+      STATIC
+      ARCHS ${arch}
       SOURCES $<TARGET_OBJECTS:RTAsan_cxx.${arch}>
               $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
       CFLAGS ${ASAN_CFLAGS}
-      DEFS ${ASAN_COMMON_DEFINITIONS})
-    add_dependencies(asan clang_rt.asan_cxx-${arch})
+      DEFS ${ASAN_COMMON_DEFINITIONS}
+      PARENT_TARGET asan)
 
-    add_compiler_rt_runtime(clang_rt.asan-preinit-${arch} ${arch} STATIC
+    add_compiler_rt_runtime(clang_rt.asan-preinit
+      STATIC
+      ARCHS ${arch}
       SOURCES $<TARGET_OBJECTS:RTAsan_preinit.${arch}>
       CFLAGS ${ASAN_CFLAGS}
-      DEFS ${ASAN_COMMON_DEFINITIONS})
-    add_dependencies(asan clang_rt.asan-preinit-${arch})
+      DEFS ${ASAN_COMMON_DEFINITIONS}
+      PARENT_TARGET asan)
 
     if (UNIX AND NOT ${arch} MATCHES "i386|i686")
       add_sanitizer_rt_version_list(clang_rt.asan-dynamic-${arch}
                                     LIBS clang_rt.asan-${arch} clang_rt.asan_cxx-${arch}
                                     EXTRA asan.syms.extra)
       set(VERSION_SCRIPT_FLAG
            -Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/clang_rt.asan-dynamic-${arch}.vers)
       set_source_files_properties(
         ${CMAKE_CURRENT_BINARY_DIR}/dummy.cc
   PROPERTIES
   OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/clang_rt.asan-dynamic-${arch}.vers)
     else()
       set(VERSION_SCRIPT_FLAG)
     endif()
 
     if (WIN32)
       set(SHARED_ASAN_NAME clang_rt.asan_dynamic-${arch}${COMPILER_RT_OS_SUFFIX})
     else()
       set(SHARED_ASAN_NAME clang_rt.asan-${arch}${COMPILER_RT_OS_SUFFIX})
     endif()
-    add_compiler_rt_runtime(clang_rt.asan-dynamic-${arch} ${arch} SHARED
+    add_compiler_rt_runtime(clang_rt.asan
+      SHARED
+      ARCHS ${arch}
       OUTPUT_NAME ${SHARED_ASAN_NAME}
       SOURCES $<TARGET_OBJECTS:RTAsan_dynamic.${arch}>
               # The only purpose of RTAsan_dynamic_version_script_dummy is to carry
               # a dependency of the shared runtime on the version script. With CMake
               # 3.1 or later it can be replaced with a straightforward
               # add_dependencies(clang_rt.asan-dynamic-${arch} clang_rt.asan-dynamic-${arch}-version-list)
               $<TARGET_OBJECTS:RTAsan_dynamic_version_script_dummy.${arch}>
               $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
               ${ASAN_COMMON_RUNTIME_OBJECTS}
       CFLAGS ${ASAN_DYNAMIC_CFLAGS}
       LINKFLAGS ${ASAN_DYNAMIC_LINK_FLAGS}
                 ${VERSION_SCRIPT_FLAG}
-      DEFS ${ASAN_DYNAMIC_DEFINITIONS})
+      DEFS ${ASAN_DYNAMIC_DEFINITIONS}
+      PARENT_TARGET asan)
     target_link_libraries(clang_rt.asan-dynamic-${arch} ${ASAN_DYNAMIC_LIBS})
-    add_dependencies(asan clang_rt.asan-dynamic-${arch})
 
     if (UNIX AND NOT ${arch} MATCHES "i386|i686")
       add_sanitizer_rt_symbols(clang_rt.asan_cxx-${arch})
       add_dependencies(asan clang_rt.asan_cxx-${arch}-symbols)
       add_sanitizer_rt_symbols(clang_rt.asan-${arch} asan.syms.extra)
       add_dependencies(asan clang_rt.asan-${arch}-symbols)
     endif()
 
     if (WIN32)
-      add_compiler_rt_runtime(clang_rt.asan_dll_thunk-${arch} ${arch} STATIC
+      add_compiler_rt_runtime(clang_rt.asan_dll_thunk
+        STATIC
+        ARCHS ${arch}
         SOURCES asan_win_dll_thunk.cc
                 $<TARGET_OBJECTS:RTInterception.${arch}>
         CFLAGS ${ASAN_CFLAGS} -DASAN_DLL_THUNK
-        DEFS ${ASAN_COMMON_DEFINITIONS})
-      add_dependencies(asan clang_rt.asan_dll_thunk-${arch})
-      add_compiler_rt_runtime(clang_rt.asan_dynamic_runtime_thunk-${arch} ${arch}
+        DEFS ${ASAN_COMMON_DEFINITIONS}
+        PARENT_TARGET asan)
+      add_compiler_rt_runtime(clang_rt.asan_dynamic_runtime_thunk
         STATIC
+        ARCHS ${arch}
         SOURCES asan_win_dynamic_runtime_thunk.cc
         CFLAGS ${ASAN_CFLAGS} -DASAN_DYNAMIC_RUNTIME_THUNK -Zl
-        DEFS ${ASAN_COMMON_DEFINITIONS})
-      add_dependencies(asan clang_rt.asan_dynamic_runtime_thunk-${arch})
+        DEFS ${ASAN_COMMON_DEFINITIONS}
+        PARENT_TARGET asan)
     endif()
   endforeach()
 endif()
 
 add_compiler_rt_resource_file(asan_blacklist asan_blacklist.txt)
 add_dependencies(asan asan_blacklist)
 add_dependencies(compiler-rt asan)
 
 add_subdirectory(scripts)
 
 if(COMPILER_RT_INCLUDE_TESTS)
   add_subdirectory(tests)
 endif()

lib/builtins/CMakeLists.txt

set(aarch64_SOURCES
   floatunsitf.c
   multc3.c
   trunctfdf2.c
   trunctfsf2.c
   ${GENERIC_SOURCES})
 
 add_custom_target(builtins)
 
+if(APPLE)
+  set(OS_OPTION OS osx)
+endif()
+
 if (NOT WIN32 OR MINGW)
   foreach (arch x86_64 i386 i686 arm aarch64)
     if (CAN_TARGET_${arch})
       # Filter out generic versions of routines that are re-implemented in
       # architecture specific manner.  This prevents multiple definitions of the
       # same symbols, making the symbol selection non-deterministic.
       foreach (_file ${${arch}_SOURCES})
         if (${_file} MATCHES ${arch}/*)
           get_filename_component(_name ${_file} NAME)
           string(REPLACE ".S" ".c" _cname "${_name}")
           list(REMOVE_ITEM ${arch}_SOURCES ${_cname})
         endif ()
       endforeach ()
 
-      add_compiler_rt_runtime(clang_rt.builtins-${arch} ${arch} STATIC
+      add_compiler_rt_runtime(clang_rt.builtins
+                              STATIC
+                              ARCH ${arch}
+                              ${OS_OPTION}
                               SOURCES ${${arch}_SOURCES}
-                              CFLAGS "-std=c99")
-      add_dependencies(builtins clang_rt.builtins-${arch})
+                              CFLAGS "-std=c99"
+                              PARENT_TARGET builtins)
     endif ()
   endforeach ()
 endif ()
 
 add_dependencies(compiler-rt builtins)

lib/dfsan/CMakeLists.txt

 # Prevent clang from generating libc calls.
 append_list_if(COMPILER_RT_HAS_FFREESTANDING_FLAG -ffreestanding DFSAN_COMMON_CFLAGS)
 
 # Static runtime library.
 add_custom_target(dfsan)
 foreach(arch ${DFSAN_SUPPORTED_ARCH})
   set(DFSAN_CFLAGS ${DFSAN_COMMON_CFLAGS})
   append_list_if(COMPILER_RT_HAS_FPIE_FLAG -fPIE DFSAN_CFLAGS)
-  add_compiler_rt_runtime(clang_rt.dfsan-${arch} ${arch} STATIC
+  add_compiler_rt_runtime(clang_rt.dfsan
+    STATIC
+    ARCHS ${arch}
     SOURCES ${DFSAN_RTL_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
     CFLAGS ${DFSAN_CFLAGS})
   add_sanitizer_rt_symbols(clang_rt.dfsan-${arch} dfsan.syms.extra)
   add_dependencies(dfsan
     clang_rt.dfsan-${arch}
     clang_rt.dfsan-${arch}-symbols)
 endforeach()
 
 set(dfsan_abilist_filename ${COMPILER_RT_OUTPUT_DIR}/dfsan_abilist.txt)
 add_custom_target(dfsan_abilist ALL

lib/lsan/CMakeLists.txt

 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)
   foreach(arch ${LSAN_SUPPORTED_ARCH})
-    add_compiler_rt_runtime(clang_rt.lsan-${arch} ${arch} STATIC
+    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})
     add_dependencies(lsan clang_rt.lsan-${arch})
   endforeach()
 endif()
 
 add_dependencies(compiler-rt lsan)

lib/msan/CMakeLists.txt

 # Prevent clang from generating libc calls.
 append_list_if(COMPILER_RT_HAS_FFREESTANDING_FLAG -ffreestanding MSAN_RTL_CFLAGS)
 
 set(MSAN_RUNTIME_LIBRARIES)
 
 # Static runtime library.
 add_custom_target(msan)
 foreach(arch ${MSAN_SUPPORTED_ARCH})
-  add_compiler_rt_runtime(clang_rt.msan-${arch} ${arch} STATIC
+  add_compiler_rt_runtime(clang_rt.msan
+    STATIC
+    ARCHS ${arch}
     SOURCES ${MSAN_RTL_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
             $<TARGET_OBJECTS:RTUbsan.${arch}>
     CFLAGS ${MSAN_RTL_CFLAGS})
-  add_compiler_rt_runtime(clang_rt.msan_cxx-${arch} ${arch} STATIC
+  add_compiler_rt_runtime(clang_rt.msan_cxx
+    STATIC
+    ARCHS ${arch}
     SOURCES ${MSAN_RTL_CXX_SOURCES}
             $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
     CFLAGS ${MSAN_RTL_CFLAGS})
   add_dependencies(msan clang_rt.msan-${arch}
                         clang_rt.msan_cxx-${arch})
   list(APPEND MSAN_RUNTIME_LIBRARIES clang_rt.msan-${arch}
                                      clang_rt.msan_cxx-${arch})
   if(UNIX)

lib/profile/CMakeLists.txt

 add_custom_target(profile)
 
 set(PROFILE_SOURCES
   GCDAProfiling.c
   InstrProfiling.c
   InstrProfilingBuffer.c
   InstrProfilingFile.c
   InstrProfilingPlatformDarwin.c
   InstrProfilingPlatformOther.c
   InstrProfilingRuntime.cc
   InstrProfilingUtil.c)
 
 if(APPLE)
   foreach (os osx)
-    add_compiler_rt_darwin_runtime(clang_rt.profile_${os} ${os}
+    add_compiler_rt_runtime(clang_rt.profile
       STATIC
+      OS ${os}
       ARCHS ${PROFILE_SUPPORTED_ARCH}
       SOURCES ${PROFILE_SOURCES})
     add_dependencies(profile clang_rt.profile_${os})
   endforeach()
 else()
   foreach(arch ${PROFILE_SUPPORTED_ARCH})
-    add_compiler_rt_runtime(clang_rt.profile-${arch} ${arch} STATIC
+    add_compiler_rt_runtime(clang_rt.profile
+      STATIC
+      ARCHS ${arch}
       CFLAGS -fPIC
       SOURCES ${PROFILE_SOURCES})
     add_dependencies(profile clang_rt.profile-${arch})
   endforeach()
 endif()
 
 add_dependencies(compiler-rt profile)

lib/safestack/CMakeLists.txt

 add_custom_target(safestack)
 
 set(SAFESTACK_SOURCES safestack.cc)
 
 include_directories(..)
 
 set(SAFESTACK_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 
 if(APPLE)
   # Build universal binary on APPLE.
   foreach (os osx)
-    add_compiler_rt_darwin_runtime(clang_rt.safestack_${os} ${os}
+    add_compiler_rt_runtime(clang_rt.safestack
       STATIC
+      OS ${os}
       ARCHS ${SAFESTACK_SUPPORTED_ARCH}
       SOURCES ${SAFESTACK_SOURCES}
               $<TARGET_OBJECTS:RTInterception.${os}>
               $<TARGET_OBJECTS:RTSanitizerCommon.${os}>
       CFLAGS ${SAFESTACK_CFLAGS})
     add_dependencies(safestack clang_rt.safestack_${os})
   endforeach()
 else()
   # Otherwise, build separate libraries for each target.
   foreach(arch ${SAFESTACK_SUPPORTED_ARCH})
-    add_compiler_rt_runtime(clang_rt.safestack-${arch} ${arch} STATIC
+    add_compiler_rt_runtime(clang_rt.safestack
+      STATIC
+      ARCHS ${arch}
       SOURCES ${SAFESTACK_SOURCES}
               $<TARGET_OBJECTS:RTInterception.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonNoLibc.${arch}>
       CFLAGS ${SAFESTACK_CFLAGS})
     add_dependencies(safestack clang_rt.safestack-${arch})
   endforeach()
 endif()

lib/tsan/CMakeLists.txt

add_custom_target(GotsanRuntimeCheck
               IN_TMPDIR=1 SILENT=1 ${BUILDGO_SCRIPT}
       DEPENDS clang_rt.tsan-${arch} ${BUILDGO_SCRIPT}
       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/go
       COMMENT "Checking TSan Go runtime..."
       VERBATIM)
   else()
     set(TSAN_ASM_SOURCES)
   endif()
-  add_compiler_rt_runtime(clang_rt.tsan-${arch} ${arch} STATIC
+  add_compiler_rt_runtime(clang_rt.tsan
+    STATIC
+    ARCHS ${arch}
     SOURCES ${TSAN_SOURCES} ${TSAN_ASM_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
             $<TARGET_OBJECTS:RTUbsan.${arch}>
     CFLAGS ${TSAN_RTL_CFLAGS})
-  add_compiler_rt_runtime(clang_rt.tsan_cxx-${arch} ${arch} STATIC
+  add_compiler_rt_runtime(clang_rt.tsan_cxx
+    STATIC
+    ARCHS ${arch}
     SOURCES ${TSAN_CXX_SOURCES}
             $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
     CFLAGS ${TSAN_RTL_CFLAGS})
   list(APPEND TSAN_RUNTIME_LIBRARIES clang_rt.tsan-${arch}
                                      clang_rt.tsan_cxx-${arch})
   add_sanitizer_rt_symbols(clang_rt.tsan-${arch} rtl/tsan.syms.extra)
   add_sanitizer_rt_symbols(clang_rt.tsan_cxx-${arch} rtl/tsan.syms.extra)
   add_dependencies(tsan clang_rt.tsan-${arch}

lib/tsan/dd/CMakeLists.txt

 append_list_if(COMPILER_RT_HAS_LIBDL dl DD_LINKLIBS)
 append_list_if(COMPILER_RT_HAS_LIBRT rt DD_LINKLIBS)
 append_list_if(COMPILER_RT_HAS_LIBPTHREAD pthread DD_LINKLIBS)
 
 add_custom_target(dd)
 # Deadlock detector is currently supported on 64-bit Linux only.
 if(CAN_TARGET_x86_64 AND UNIX AND NOT APPLE AND NOT ANDROID)
   set(arch "x86_64")
-  add_compiler_rt_runtime(clang_rt.dd-${arch} ${arch} STATIC
+  add_compiler_rt_runtime(clang_rt.dd
+    STATIC
+    ARCHS ${arch}
     SOURCES ${DD_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
-    CFLAGS ${DD_CFLAGS})
-  add_dependencies(dd clang_rt.dd-${arch})
+    CFLAGS ${DD_CFLAGS}
+    PARENT_TARGET dd)
 
   add_compiler_rt_object_libraries(RTDD
     ARCHS ${arch}
     SOURCES ${DD_SOURCES} CFLAGS ${DD_CFLAGS})
 
-  add_compiler_rt_runtime(clang_rt.dyndd-${arch} ${arch} SHARED
+  add_compiler_rt_runtime(clang_rt.dyndd
+    SHARED
+    ARCHS ${arch}
     SOURCES $<TARGET_OBJECTS:RTDD.${arch}>
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
-            $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>)
-  target_link_libraries(clang_rt.dyndd-${arch} ${DD_LINKLIBS})
-  add_dependencies(dd clang_rt.dyndd-${arch})
+            $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+    LIBS ${DD_LINKLIBS}
+    PARENT_TARGET dd)
 endif()
 
 add_dependencies(compiler-rt dd)

lib/ubsan/CMakeLists.txt

if(APPLE)
   if(COMPILER_RT_HAS_UBSAN)
     # Initializer of standalone UBSan runtime.
     add_compiler_rt_object_libraries(RTUbsan_standalone
       OS ${SANITIZER_COMMON_SUPPORTED_OS}
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       SOURCES ${UBSAN_STANDALONE_SOURCES}
       CFLAGS ${UBSAN_STANDALONE_CFLAGS})
     foreach(os ${SANITIZER_COMMON_SUPPORTED_OS})
-      add_compiler_rt_darwin_runtime(clang_rt.ubsan_${os}_dynamic ${os}
+      add_compiler_rt_runtime(clang_rt.ubsan
         SHARED
+        OS ${os}
         ARCHS ${UBSAN_SUPPORTED_ARCH}
         SOURCES $<TARGET_OBJECTS:RTUbsan.${os}>
                 $<TARGET_OBJECTS:RTUbsan_standalone.${os}>
-                $<TARGET_OBJECTS:RTSanitizerCommon.${os}>)
-
-      add_dependencies(ubsan clang_rt.ubsan_${os}_dynamic)
+                $<TARGET_OBJECTS:RTSanitizerCommon.${os}>
+        PARENT_TARGET ubsan)
     endforeach()
   endif()
 
 else()
   # Common parts of UBSan runtime.
   add_compiler_rt_object_libraries(RTUbsan
     ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
     SOURCES ${UBSAN_SOURCES} CFLAGS ${UBSAN_CFLAGS})
   # C++-specific parts of UBSan runtime. Requires a C++ ABI library.
   add_compiler_rt_object_libraries(RTUbsan_cxx
     ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
     SOURCES ${UBSAN_CXX_SOURCES} CFLAGS ${UBSAN_CXXFLAGS})
 
   if(COMPILER_RT_HAS_UBSAN)
     # Initializer of standalone UBSan runtime.
     add_compiler_rt_object_libraries(RTUbsan_standalone
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       SOURCES ${UBSAN_STANDALONE_SOURCES} CFLAGS ${UBSAN_STANDALONE_CFLAGS})
     
     foreach(arch ${UBSAN_SUPPORTED_ARCH})
       # Standalone UBSan runtimes.
-      add_compiler_rt_runtime(clang_rt.ubsan_standalone-${arch} ${arch} STATIC
+      add_compiler_rt_runtime(clang_rt.ubsan_standalone
+        STATIC
+        ARCHS ${arch}
         SOURCES $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
                 $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
                 $<TARGET_OBJECTS:RTUbsan.${arch}>
                 $<TARGET_OBJECTS:RTUbsan_standalone.${arch}>
-        CFLAGS ${UBSAN_CFLAGS})
-      add_compiler_rt_runtime(clang_rt.ubsan_standalone_cxx-${arch} ${arch} STATIC
+        CFLAGS ${UBSAN_CFLAGS}
+        PARENT_TARGET ubsan)
+      add_compiler_rt_runtime(clang_rt.ubsan_standalone_cxx
+        STATIC
+        ARCHS ${arch}
         SOURCES $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
-        CFLAGS ${UBSAN_CXXFLAGS})
+        CFLAGS ${UBSAN_CXXFLAGS}
+        PARENT_TARGET ubsan)
 
-      add_dependencies(ubsan
-        clang_rt.ubsan_standalone-${arch}
-        clang_rt.ubsan_standalone_cxx-${arch})
       if (UNIX AND NOT ${arch} MATCHES "i386|i686")
         add_sanitizer_rt_symbols(clang_rt.ubsan_standalone-${arch} ubsan.syms.extra)
         add_sanitizer_rt_symbols(clang_rt.ubsan_standalone_cxx-${arch} ubsan.syms.extra)
         add_dependencies(ubsan
           clang_rt.ubsan_standalone-${arch}-symbols
           clang_rt.ubsan_standalone_cxx-${arch}-symbols)
       endif()
     endforeach()
   endif()
 endif()
 
 add_dependencies(compiler-rt ubsan)