[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

58–59

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?

58–59

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

58–59

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

62

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.

76

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

100

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

100

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

102

You've already checked for that.

113

You've already checked for that.

120

You can probably do

if(NOT libnames)
  return()
endif()

and skip all the checks below.

122

COMPONENT_OPTION

lib/dfsan/CMakeLists.txt

25–26

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

58–59

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.

62

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.

[samsonov]

cmake/Modules/AddCompilerRT.cmake

62

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

60

There is no such argument now.

79

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

99

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.

lib/asan/CMakeLists.txt

194

Pass ${ASAN_DYNAMIC_LIBS} to add_compiler_rt_runtime as LINK_LIBS?

lib/profile/CMakeLists.txt

21

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

21

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

21

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

21

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

194–195

LINK_LIBS

lib/profile/CMakeLists.txt

21–27

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
-      COMPILE_DEFINITIONS ${LIB_DEFS})
-    # Setup correct output directory in the build tree.
-    set_target_properties(${name} 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})
+#                         LINK_LIBS <linked libraries> (only for shared library)
+#                         OUTPUT_NAME <output library name>
+#                         PARENT_TARGET <convenience parent target>)
+function(add_compiler_rt_runtime name type)
+  if(NOT type MATCHES "^(STATIC|SHARED)$")
+    message(FATAL_ERROR "type argument must be STATIC or SHARED")
+    return()
+  endif()
+  cmake_parse_arguments(LIB
+    ""
+    "PARENT_TARGET"
+    "OS;ARCHS;SOURCES;CFLAGS;LINKFLAGS;DEFS;LINK_LIBS"
+    ${ARGN})
+  set(libnames)
+  if(APPLE)
+    foreach(os ${LIB_OS})
+      if(type STREQUAL "STATIC")
+        set(libname "${name}_${os}")
       else()
-      set_target_properties(${name} PROPERTIES
-        OUTPUT_NAME ${LIB_OUTPUT_NAME})
+        set(libname "${name}_${os}_dynamic")
+        set(extra_linkflags_${libname} ${DARWIN_${os}_LINKFLAGS} ${LIB_CFLAGS} ${LIB_LINKFLAGS})
       endif()
-    # Add installation command.
-    install(TARGETS ${name}
-      ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
-      LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
-      RUNTIME DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+      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})
+      endif()
+    endforeach()
   else()
+    foreach(arch ${LIB_ARCHS})
+      if(NOT CAN_TARGET_${arch})
         message(FATAL_ERROR "Architecture ${arch} can't be targeted")
+        return()
       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})
+      if(type STREQUAL "STATIC")
+        set(libname "${name}-${arch}")
       else()
-      message(FATAL_ERROR "Must specified SHARED|STATIC to add_compiler_rt_darwin_runtime")
-    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(libname "${name}-dynamic-${arch}")
+        set(extra_linkflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS} ${LIB_LINKFLAGS})
+        if(WIN32)
+          set(output_name_${libname} ${name}_dynamic-${arch}${COMPILER_RT_OS_SUFFIX})
+        endif()
+      endif()
+      set(libnames ${libnames} ${libname})
+      set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS})
+    endforeach()
+  if(NOT libnames)
+    return()
+  endif()
+
+  if(LIB_PARENT_TARGET)
+    set(COMPONENT_OPTION COMPONENT ${LIB_PARENT_TARGET})
+  endif()
 
-    set_target_properties(${name} PROPERTIES
-      OSX_ARCHITECTURES "${filtered_arches}")
+  foreach(libname ${libnames})
+    add_library(${libname} ${type} ${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})
+    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 (output_name_${libname})
+      set_target_properties(${libname} PROPERTIES
+        OUTPUT_NAME ${output_name_${libname}})
+    else()
+      set_target_properties(${libname} PROPERTIES
+        OUTPUT_NAME ${libname}${COMPILER_RT_OS_SUFFIX})
+    endif()
+    if(LIB_LINK_LIBS AND ${type} STREQUAL "SHARED")
+      target_link_libraries(${libname} ${LIB_LINK_LIBS})
+    endif()
+    install(TARGETS ${libname}
+      ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
+              ${COMPONENT_OPTION}
+      LIBRARY DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
+              ${COMPONENT_OPTION}
+      RUNTIME DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}
+              ${COMPONENT_OPTION})
+    if(APPLE)
+      set_target_properties(${libname} PROPERTIES
+      OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}")
+    endif()
+  endforeach()
+  if(LIB_PARENT_TARGET)
+    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)

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
-      OUTPUT_NAME ${SHARED_ASAN_NAME}
+    add_compiler_rt_runtime(clang_rt.asan
+      SHARED
+      ARCHS ${arch}
       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})
+    CFLAGS ${DFSAN_CFLAGS}
+    PARENT_TARGET dfsan)
   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
   DEPENDS ${dfsan_abilist_filename})
 add_custom_command(OUTPUT ${dfsan_abilist_filename}
                    VERBATIM

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})
+      CFLAGS ${LSAN_CFLAGS}
+      PARENT_TARGET lsan)
   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
+    CFLAGS ${MSAN_RTL_CFLAGS}
+    PARENT_TARGET msan)
+  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})
+    CFLAGS ${MSAN_RTL_CFLAGS}
+    PARENT_TARGET msan)
   list(APPEND MSAN_RUNTIME_LIBRARIES clang_rt.msan-${arch}
                                      clang_rt.msan_cxx-${arch})
   if(UNIX)
     add_sanitizer_rt_symbols(clang_rt.msan-${arch} msan.syms.extra)
     add_sanitizer_rt_symbols(clang_rt.msan_cxx-${arch} msan.syms.extra)
     add_dependencies(msan clang_rt.msan-${arch}-symbols
                           clang_rt.msan_cxx-${arch}-symbols)
   endif()

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}
-      STATIC
-      ARCHS ${PROFILE_SUPPORTED_ARCH}
-      SOURCES ${PROFILE_SOURCES})
-    add_dependencies(profile clang_rt.profile_${os})
-  endforeach()
+  add_compiler_rt_runtime(clang_rt.profile
+    OS osx
+    SOURCES ${PROFILE_SOURCES}
+    PARENT_TARGET profile)
 else()
-  foreach(arch ${PROFILE_SUPPORTED_ARCH})
-    add_compiler_rt_runtime(clang_rt.profile-${arch} ${arch} STATIC
-      CFLAGS -fPIC
-      SOURCES ${PROFILE_SOURCES})
-    add_dependencies(profile clang_rt.profile-${arch})
-  endforeach()
+  add_compiler_rt_runtime(clang_rt.profile
+    STATIC
+    ARCHS ${PROFILE_SUPPORTED_ARCH}
+    SOURCES ${PROFILE_SOURCES}
+    PARENT_TARGET profile)
 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}
-      STATIC
-      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()
+  add_compiler_rt_runtime(clang_rt.safestack
+    OS osx
+            $<TARGET_OBJECTS:RTInterception.osx>
+            $<TARGET_OBJECTS:RTSanitizerCommon.osx>
+    CFLAGS ${SAFESTACK_CFLAGS}
+    PARENT_TARGET safestack)
 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})
+      CFLAGS ${SAFESTACK_CFLAGS}
+      PARENT_TARGET safestack)
   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)