[sanitizers test cmake] Refactor the logic for compiling and generating the tests out into a function

[george.karpenkov]

Summary

Most CMake configuration under compiler-rt/lib/*/tests have almost-the-same-but-not-quite functions of the form add_X_[unit]tests for compiling and running the tests.
Much of the logic is duplicated with minor variations across different sub-folders.
This can harm productivity for multiple reasons:

• For newcomers, resulting CMake files are very large, hard to understand, and hide the intention of the code.
• Changes for enabling certain architectures end up being unnecessarily large, as they get duplicated across multiple folders.
• Adding new sub-projects requires more effort than it should, as a developer has to again copy-n-paste the configuration, and it's not even clear from which sub-project it should be copy-n-pasted.

With this change the logic of compile-and-generate-a-set-of-tests is extracted into a function, which hopefully makes writing and reading CMake much easier.
As a part of refactoring, I've changed affected macros to functions, as it's much easier to write "safer" CMake code using functions (if such thing exists).

[george.karpenkov]

Removed unused function.

[vitalybuka]

Is possible to split into smaller patches?

cmake/Modules/AddCompilerRT.cmake

291

Should arch be in the doc string as well.

312

Use of closing parenthesis is inconsistent

343

output_folder -> output_dir

[george.karpenkov]

@vitalybuka I could try if that's absolutely required.
At the end a single action is being done on multiple files: compile-and-generate functionality is extracted.

[george.karpenkov]

Applied review comments.

[vitalybuka]

"ninja check-asan-dynamic" fails

[3/9] Linking CXX static library lib/libgtest.a
[4/9] cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-i386-inline-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
FAILED: projects/compiler-rt/lib/asan/tests/CMakeFiles/Asan-i386-inline-DynamicTest
cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-i386-inline-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../x86_64-linux-gnu/crt1.o(.text+0x20): error: undefined reference to 'main'
clang-6.0: error: linker command failed with exit code 1 (use -v to see invocation)
[5/9] cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-i386-with-calls-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
FAILED: projects/compiler-rt/lib/asan/tests/CMakeFiles/Asan-i386-with-calls-DynamicTest
cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-i386-with-calls-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../x86_64-linux-gnu/crt1.o(.text+0x20): error: undefined reference to 'main'
clang-6.0: error: linker command failed with exit code 1 (use -v to see invocation)
[6/9] cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-x86_64-with-calls-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
FAILED: projects/compiler-rt/lib/asan/tests/CMakeFiles/Asan-x86_64-with-calls-DynamicTest
cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-x86_64-with-calls-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../x86_64-linux-gnu/crt1.o(.text+0x20): error: undefined reference to 'main'
clang-6.0: error: linker command failed with exit code 1 (use -v to see invocation)
[7/9] cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-x86_64-inline-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
FAILED: projects/compiler-rt/lib/asan/tests/CMakeFiles/Asan-x86_64-inline-DynamicTest
cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-x86_64-inline-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../x86_64-linux-gnu/crt1.o(.text+0x20): error: undefined reference to 'main'
clang-6.0: error: linker command failed with exit code 1 (use -v to see invocation)
[8/9] Running lint check for sanitizer sources...

[george.karpenkov]

@vitalybuka I can branch out a few tiny things in separate patches (function to macro, moving flags up the file in tsan), but this will make the diff only slightly smaller.

cmake/Modules/AddCompilerRT.cmake

312

Right. What would you prefer? There are no coding guidelines for CMake, and I don't think existing code is always consistent in this manner.
I was applying the following convention: keep on the same line for short argument list (for brevity),
move to it's own line for long list (useful for moving arguments around).

[george.karpenkov]

@vitalybuka

"ninja check-asan-dynamic" fails

thanks for the information, working on the fix now!
I wasn't aware that this target exists, it's not even run on ninja check-all.

[george.karpenkov]

@vitalybuka fixed ninja check-asan-dynamic, the argument order was wrong.

[vitalybuka]

Another problem

[1/6] cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang ASAN_INST_TEST_OBJECTS.gtest-all.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_asm_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_globals_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_interface_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_internal_interface_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_oob_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_mem_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_str_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_test_main.cc.i386-with-calls.o -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-i386-with-calls-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
FAILED: projects/compiler-rt/lib/asan/tests/CMakeFiles/Asan-i386-with-calls-DynamicTest 
cd /build/projects/compiler-rt/lib/asan/tests && /build/./bin/clang ASAN_INST_TEST_OBJECTS.gtest-all.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_asm_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_globals_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_interface_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_internal_interface_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_oob_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_mem_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_str_test.cc.i386-with-calls.o ASAN_INST_TEST_OBJECTS.asan_test_main.cc.i386-with-calls.o -o /build/projects/compiler-rt/lib/asan/tests/dynamic/Asan-i386-with-calls-DynamicTest -fuse-ld=gold -Wl,-allow-shlib-undefined -g --driver-mode=g++ -fsanitize=address -shared-libasan -pthread
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.gtest-all.cc.i386-with-calls.o: incompatible target
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.asan_asm_test.cc.i386-with-calls.o: incompatible target
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.asan_globals_test.cc.i386-with-calls.o: incompatible target
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.asan_interface_test.cc.i386-with-calls.o: incompatible target
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.asan_internal_interface_test.cc.i386-with-calls.o: incompatible target
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.asan_test.cc.i386-with-calls.o: incompatible target
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.asan_oob_test.cc.i386-with-calls.o: incompatible target
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.asan_mem_test.cc.i386-with-calls.o: incompatible target
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.asan_str_test.cc.i386-with-calls.o: incompatible target
/usr/local/bin/ld.gold: error: ASAN_INST_TEST_OBJECTS.asan_test_main.cc.i386-with-calls.o: incompatible target
/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../x86_64-linux-gnu/crt1.o(.text+0x20): error: undefined reference to 'main'
clang-6.0: error: linker command failed with exit code 1 (use -v to see invocation)

[george.karpenkov]

@vitalybuka thanks! Could you be a bit more explicit?
What ninja target are you running? How can one discover those (apart from knowing that they exist)?
I've run check-all and check-asan-dynamic.

[vitalybuka]

that was ninja check-asan-dynamic again

[vitalybuka]

approximate cmake command

cmake -GNinja -DLLVM_APPEND_VC_REV=OFF -DCMAKE_C_COMPILER=/build/out/build/bin/clang -DCMAKE_CXX_COMPILER=/build/out/build/bin/clang++ -DLLVM_TABLEGEN=/build/out/build/bin/llvm-tblgen -DCLANG_TABLEGEN=/build/out/build/bin/clang-tblgen -DLLVM_USE_LINKER=gold -DLLVM_ENABLE_LLD=OFF -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_ENABLE_WERROR=ON -DLLVM_PARALLEL_LINK_JOBS=10 -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=ON -DLLVM_INCLUDE_GO_TESTS=OFF -DLLVM_CCACHE_BUILD=ON -DLLVM_ENABLE_LIBCXX=OFF -DCMAKE_C_FLAGS= -DCMAKE_CXX_FLAGS= -DCMAKE_EXE_LINKER_FLAGS= /build/llvm

[george.karpenkov]

added a dependency for dynamic tests

[george.karpenkov]

@vitalybuka can't reproduce. Can you remove caching from your config? (I think DLLVM_CCACHE_BUILD, maybe others).
With caching on, I get different, also strange, errors.

[vitalybuka]

I simplified cmake command to something line this, still the same error.
cmake -GNinja -DCMAKE_C_COMPILER=/build/out/build/bin/clang -DCMAKE_CXX_COMPILER=/build/out/build/bin/clang++ -DCMAKE_BUILD_TYPE=Release -DLLVM_PARALLEL_LINK_JOBS=10 -DLLVM_ENABLE_LIBCXX=OFF -DCMAKE_C_FLAGS= -DCMAKE_CXX_FLAGS= -DCMAKE_EXE_LINKER_FLAGS= /build/llvm

I will try to debug the patch in the morning.

[vitalybuka]

Would be nice to have unrelated changes like moving core around, switch from macro to function, renames or argument changes as separate patches.

lib/asan/tests/CMakeLists.txt

187

This way it works as expected:

if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
    set(dynamic_test_name "Asan-${arch}${TEST_KIND}-Dynamic-Test")
    if(MSVC)

      # With the MSVC CRT, the choice between static and dynamic CRT is made at
      # compile time with a macro. Simulate the effect of passing /MD to clang-cl.
      set(ASAN_DYNAMIC_TEST_OBJECTS)
      generate_asan_tests(ASAN_DYNAMIC_TEST_OBJECTS
        AsanDynamicUnitTests "${dynamic_test_name}"
        SUBDIR "dynamic"
        CFLAGS ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} -D_MT -D_DLL
        SOURCES ${ASAN_INST_TEST_SOURCES}
        LINK_FLAGS ${ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINK_FLAGS}
          -Wl,-nodefaultlib:libcmt,-defaultlib:msvcrt,-defaultlib:oldnames
        )
    else()

      # Otherwise, reuse ASAN_INST_TEST_OBJECTS.
      set(ASAN_INST_TEST_OBJECTS)
      generate_asan_tests(ASAN_INST_TEST_OBJECTS
        AsanDynamicUnitTests "${dynamic_test_name}"
        SUBDIR "dynamic"
        LINK_FLAGS ${ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINK_FLAGS}
        SOURCES ${ASAN_INST_TEST_SOURCES}
        CFLAGS ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} ${TEST_CFLAGS})
    endif()
  endif()

[george.karpenkov]

@vitalybuka sorry I don't understand your patch: the whole point is not to recompile ASAN_INST_TEST_OBJECTS and to reuse them from the previous compilation.
If you reset it to empty, the test just becomes a no-OP from my understanding.
I can move out a change from function to macro if you wish so, but it's only one line. I don't see any other bits which could be easily factored out into a different review.

[george.karpenkov]

@vitalybuka found the difference: it seems, my machine couldn't compile to i386, and the multi-architecture pass was not tested. Testing now.

[vitalybuka]

Somehow tests work for me, probably because "SOURCES ${ASAN_INST_TEST_SOURCES} "

I see now that it relinks tests every time. But I reverted to the master and it still relinks 4 tests every time. So if you are trying to fix
this, please keep it out of refactoring patches.

Also if goal to reuse some build results, have you noticed that error about incompatibility:
error: ASAN_INST_TEST_OBJECTS.gtest-all.cc.i386-with-calls.o: incompatible target
Do you run both i386 and x86_64?
On x86_64 linux it builds and tests both version by default. If you run just one, maybe this is the reason why you don't see error.
Is possible that you build just one arch?
To confirm this, how many tests do you see for check-asan-dynamic

• Testing: 1638 tests, 48 threads --

Testing: 0 .. 10.. 20.. 30.. 40.. 50.. 60.. 70.. 80.. 90..
Testing Time: 42.23s

Expected Passes    : 1355
Unsupported Tests  : 283

It would be much easier to review refactoring do in something like:

1. For each sanitizer create empty own generate_xsan_tests
2. Use multiple patches to incrementally move code into that function until all sanitizers converge to the exactly the same code, similar to generate_compiler_rt_tests
3. Replace duplicates with common generate_compiler_rt_tests

[george.karpenkov]

Somehow tests work for me

Oh right, you've renamed add_compiler_rt_tests to generate_compiler_rt_tests.
Yeah, then of course it would work.

Is possible that you build just one arch?

Yeah, my machine did not have 32bit version of libstdc++ installed, hence the difference in logic.

[george.karpenkov]

Also if goal to reuse some build results

Yeah, the goal is to follow the same logic as before, which was reusing logic.
Yes, I am trying to reproduce the error now.

It would be much easier to review refactoring do in something like

Right, I see.
The disadvantage is that each individual commit might not make much sense (would be needlessly increasing, rather than decreasing the complexity).
Can we try a less radical approach? I think I see some more stuff which could be moved out into other patches.

[vitalybuka]

Can we try a less radical approach? I think I see some more stuff which could be moved out into other patches.

i leave it to your best judgement

[george.karpenkov]

Rebased.

[vitalybuka]

lib/asan/tests/CMakeLists.txt

189

Could you please make it Dynamic-Test as it was before?

206

Have you resolved the issue here?
Why not just use generate_asan_tests?

[george.karpenkov]

lib/asan/tests/CMakeLists.txt

206

In the process, took me a long time to get 32-bit builds working.
We can just use generate_asan_tests, sure, would make my job easier. I thought it's important to make it faster? But I guess we don't call it on the default test pass.

[vitalybuka]

lib/asan/tests/CMakeLists.txt

206

I'd like to ask again.
Making faster is awesome, but please separate refactorings and behavior changes.
We should check how it works on bots before optimizations.

[george.karpenkov]

lib/asan/tests/CMakeLists.txt

206

but please separate refactorings and behavior changes

@vitalybuka exactly, that's why I'm re-using previous object files --- because the previous configuration did that as well.

Anyway, I think I've found the error, pushing the update now.

[george.karpenkov]

Move detecting architecture flag to add_compiler_rt_test.

@vitalybuka could you test again on your machine? I still couldn't get compiling to 32 bits fully working.

[george.karpenkov]

updated test name

[vitalybuka]

lib/asan/tests/CMakeLists.txt

206

It was missing ${arch}?

[george.karpenkov]

lib/asan/tests/CMakeLists.txt

206

arch-specific link flags should have been inserted in the function which did linking, not in the function which did compilation.

[vitalybuka]

Thanks.
Now we probably need to look at http://google.github.io/sanitizers/show_bots.html to check if number of test is still the same.

[vitalybuka]

Uh, check-sanitizer does not work now.
It worked with previous snapshot of the patch.

[george.karpenkov]

@vitalybuka indeed can reproduce, my bad. Will rollback if I can't fix it within couple of minutes.

[vitalybuka]

cmake/Modules/AddCompilerRT.cmake

327

That's because ${TEST_LINK_FLAGS} was removed.
Could this be a quick fix?

cmake/Modules/AddCompilerRT.cmake

if(MSVC)
 
   # Clang doesn't support SEH on Windows yet.
   list(APPEND COMPILER_RT_GTEST_CFLAGS -DGTEST_HAS_SEH=0)
 
   # gtest use a lot of stuff marked as deprecated on Windows.
   list(APPEND COMPILER_RT_GTEST_CFLAGS -Wno-deprecated-declarations)
 endif()
 
+# Compile and register compiler-rt tests.
+# generate_compiler_rt_tests(<output object files> <test_suite> <test_name>
+#                           <test architecture>
+#                           KIND <custom prefix>
+#                           SUBDIR <subdirectory for testing binary>
+#                           SOURCES <sources to compile>
+#                           RUNTIME <tests runtime to link in>
+#                           CFLAGS <compile-time flags>
+#                           COMPILE_DEPS <compile-time dependencies>
+#                           DEPS <dependencies>
+#                           LINK_FLAGS <flags to use during linking>
+# )
+function(generate_compiler_rt_tests test_objects test_suite testname arch)
+  cmake_parse_arguments(TEST "" "KIND;RUNTIME;SUBDIR"
+    "SOURCES;COMPILE_DEPS;DEPS;CFLAGS;LINK_FLAGS" ${ARGN})
+
+  foreach(source ${TEST_SOURCES})
+    sanitizer_test_compile(
+      "${test_objects}" "${source}" "${arch}"
+      KIND ${TEST_KIND}
+      COMPILE_DEPS ${TEST_COMPILE_DEPS}
+      DEPS ${TEST_DEPS}
+      CFLAGS ${TEST_CFLAGS}
+      )
+  endforeach()
+  get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS)
+
+  set(TEST_DEPS ${${test_objects}})
+
+  if(NOT "${TEST_RUNTIME}" STREQUAL "")
+    list(APPEND TEST_DEPS ${TEST_RUNTIME})
+    list(APPEND "${test_objects}" $<TARGET_FILE:${TEST_RUNTIME}>)
+  endif()
+
+  add_compiler_rt_test(${test_suite} "${testname}"
+    SUBDIR ${TEST_SUBDIR}
+    OBJECTS ${${test_objects}}
+    DEPS ${TEST_DEPS}
+    LINK_FLAGS ${TARGET_LINK_FLAGS} ${TEST_LINK_FLAGS}
+    )
+  set("${test_objects}" "${${test_objects}}" PARENT_SCOPE)
+endfunction()
+
 # Link objects into a single executable with COMPILER_RT_TEST_COMPILER,
 # using specified link flags. Make executable a part of provided
 # test_suite.
 # add_compiler_rt_test(<test_suite> <test_name>
 #                      SUBDIR <subdirectory for binary>
 #                      OBJECTS <object files>
 #                      DEPS <deps (e.g. runtime libs)>
 #                      LINK_FLAGS <link flags>)
-macro(add_compiler_rt_test test_suite test_name)
+function(add_compiler_rt_test test_suite test_name)
   cmake_parse_arguments(TEST "" "SUBDIR" "OBJECTS;DEPS;LINK_FLAGS" "" ${ARGN})
-  set(output_bin ${CMAKE_CURRENT_BINARY_DIR})
+  set(output_dir ${CMAKE_CURRENT_BINARY_DIR})
   if(TEST_SUBDIR)
-    set(output_bin "${output_bin}/${TEST_SUBDIR}")
+    set(output_dir "${output_dir}/${TEST_SUBDIR}")
+  endif()
+  if(CMAKE_CONFIGURATION_TYPES)
+    set(output_dir "${output_dir}/${CMAKE_CFG_INTDIR_INTDIR}")
   endif()
-  set(output_bin "${output_bin}/${CMAKE_CFG_RESOLVED_INTDIR}${test_name}")
+  file(MAKE_DIRECTORY "${output_dir}")
+  set(output_bin "${output_dir}/${test_name}")
   if(MSVC)
     set(output_bin "${output_bin}.exe")
   endif()
 
   # Use host compiler in a standalone build, and just-built Clang otherwise.
   if(NOT COMPILER_RT_STANDALONE_BUILD)
     list(APPEND TEST_DEPS clang)
   endif()
add_custom_target(${test_name}
     COMMAND ${COMPILER_RT_TEST_COMPILER} ${TEST_OBJECTS}
             -o "${output_bin}"
             ${TEST_LINK_FLAGS}
     DEPENDS ${TEST_DEPS})
   set_target_properties(${test_name} PROPERTIES FOLDER "Compiler-RT Tests")
 
   # Make the test suite depend on the binary.
   add_dependencies(${test_suite} ${test_name})
-endmacro()
+endfunction()
 
 macro(add_compiler_rt_resource_file target_name file_name component)
   set(src_file "${CMAKE_CURRENT_SOURCE_DIR}/${file_name}")
   set(dst_file "${COMPILER_RT_OUTPUT_DIR}/${file_name}")
   add_custom_command(OUTPUT ${dst_file}
     DEPENDS ${src_file}
     COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src_file} ${dst_file}
     COMMENT "Copying ${file_name}...")

cmake/Modules/CompilerRTCompile.cmake

foreach(flag ${msvc_flags})
     endif()
   endforeach()
   set(${out_flags} "${clang_flags}" PARENT_SCOPE)
 endfunction()
 
 # Compile a sanitizer test with a freshly built clang
 # for a given architecture, adding the result to the object list.
 #  - obj_list: output list of objects, populated by path
-#              of the generated object file.
+#              of a generated object file.
 #  - source:   source file of a test.
 #  - arch:     architecture to compile for.
 # sanitizer_test_compile(<obj_list> <source> <arch>
 #                        KIND <custom namespace>
 #                        COMPILE_DEPS <list of compile-time dependencies>
 #                        DEPS <list of dependencies>
 #                        CFLAGS <list of flags>
 # )
-macro(sanitizer_test_compile obj_list source arch)
+function(sanitizer_test_compile obj_list source arch)
   cmake_parse_arguments(TEST
       "" "" "KIND;COMPILE_DEPS;DEPS;CFLAGS" ${ARGN})
   get_filename_component(basename ${source} NAME)
-  if(CMAKE_CONFIGURATION_TYPES)
-    set(output_obj
-      "${CMAKE_CFG_INTDIR}/${obj_list}.${basename}.${arch}${TEST_KIND}.o")
-  else()
-    set(output_obj "${obj_list}.${basename}.${arch}${TEST_KIND}.o")
-  endif()
+  set(output_obj "${CMAKE_CFG_RESOLVED_INTDIR}${obj_list}.${basename}.${arch}${TEST_KIND}.o")
 
   # Write out architecture-specific flags into TARGET_CFLAGS variable.
   get_target_flags_for_arch(${arch} TARGET_CFLAGS)
   set(COMPILE_DEPS ${TEST_COMPILE_DEPS})
   if(NOT COMPILER_RT_STANDALONE_BUILD)
     list(APPEND COMPILE_DEPS ${TEST_DEPS})
   endif()
   clang_compile(${output_obj} ${source}
                 CFLAGS ${TEST_CFLAGS} ${TARGET_CFLAGS}
                 DEPS ${TEST_COMPILE_DEPS})
   list(APPEND ${obj_list} ${output_obj})
-endmacro()
+  set("${obj_list}" "${${obj_list}}" PARENT_SCOPE)
+endfunction()
 
 # Compile a source into an object file with COMPILER_RT_TEST_COMPILER using
 # a provided compile flags and dependenices.
 # clang_compile(<object> <source>
 #               CFLAGS <list of compile flags>
 #               DEPS <list of dependencies>)
-macro(clang_compile object_file source)
+function(clang_compile object_file source)
   cmake_parse_arguments(SOURCE "" "" "CFLAGS;DEPS" ${ARGN})
   get_filename_component(source_rpath ${source} REALPATH)
   if(NOT COMPILER_RT_STANDALONE_BUILD)
     list(APPEND SOURCE_DEPS clang compiler-rt-headers)
   endif()
   if (TARGET CompilerRTUnitTestCheckCxx)
     list(APPEND SOURCE_DEPS CompilerRTUnitTestCheckCxx)
   endif()
   string(REGEX MATCH "[.](cc|cpp)$" is_cxx ${source_rpath})
+  string(REGEX MATCH "[.](m|mm)$" is_objc ${source_rpath})
   if(is_cxx)
     string(REPLACE " " ";" global_flags "${CMAKE_CXX_FLAGS}")
   else()
     string(REPLACE " " ";" global_flags "${CMAKE_C_FLAGS}")
   endif()
 
   if (MSVC)
     translate_msvc_cflags(global_flags "${global_flags}")
   endif()
 
   if (APPLE)
     set(global_flags ${OSX_SYSROOT_FLAG} ${global_flags})
   endif()
+  if (is_objc)
+    list(APPEND global_flags -ObjC)
+  endif()
 
   # Ignore unknown warnings. CMAKE_CXX_FLAGS may contain GCC-specific options
   # which are not supported by Clang.
   list(APPEND global_flags -Wno-unknown-warning-option)
   set(compile_flags ${global_flags} ${SOURCE_CFLAGS})
   add_custom_command(
     OUTPUT ${object_file}
     COMMAND ${COMPILER_RT_TEST_COMPILER} ${compile_flags} -c
             -o "${object_file}"
             ${source_rpath}
     MAIN_DEPENDENCY ${source}
     DEPENDS ${SOURCE_DEPS})
-endmacro()
+endfunction()
 
 # On Darwin, there are no system-wide C++ headers and the just-built clang is
 # therefore not able to compile C++ files unless they are copied/symlinked into
 # ${LLVM_BINARY_DIR}/include/c++
 # The just-built clang is used to build compiler-rt unit tests. Let's detect
 # this before we try to build the tests and print out a suggestion how to fix
 # it.
 # On other platforms, this is currently not an issue.

lib/asan/tests/CMakeLists.txt

 endif()
 
 # TODO(eugenis): move all -l flags above to _LIBS?
 set(ASAN_UNITTEST_NOINST_LIBS)
 append_list_if(COMPILER_RT_HAS_LIBLOG log ASAN_UNITTEST_NOINST_LIBS)
 # NDK r10 requires -latomic almost always.
 append_list_if(ANDROID atomic ASAN_UNITTEST_NOINST_LIBS)
 
-macro(asan_compile obj_list source arch kind)
-  cmake_parse_arguments(ASAN_TEST "" "" "CFLAGS" ${ARGN})
-  sanitizer_test_compile(${obj_list} ${source} ${arch}
-    KIND ${kind}
-    COMPILE_DEPS ${ASAN_UNITTEST_HEADERS} ${ASAN_BLACKLIST_FILE}
-    DEPS gtest asan
-    CFLAGS ${ASAN_TEST_CFLAGS}
-  )
-endmacro()
-
-# Link ASan unit test for a given architecture from a set
-# of objects in with given linker flags.
-macro(add_asan_test test_suite test_name arch kind)
-  cmake_parse_arguments(TEST "WITH_TEST_RUNTIME" "" "OBJECTS;LINK_FLAGS;SUBDIR" ${ARGN})
-  get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS)
-  set(TEST_DEPS ${TEST_OBJECTS})
-  if(NOT COMPILER_RT_STANDALONE_BUILD)
-    list(APPEND TEST_DEPS asan)
-  endif()
-  if(TEST_WITH_TEST_RUNTIME)
-    list(APPEND TEST_DEPS ${ASAN_TEST_RUNTIME})
-    list(APPEND TEST_OBJECTS $<TARGET_FILE:${ASAN_TEST_RUNTIME}>)
-  endif()
-  add_compiler_rt_test(${test_suite} ${test_name}
-                       SUBDIR ${TEST_SUBDIR}
-                       OBJECTS ${TEST_OBJECTS}
-                       DEPS ${TEST_DEPS}
-                       LINK_FLAGS ${TEST_LINK_FLAGS}
-                                  ${TARGET_LINK_FLAGS})
-endmacro()
-
 # Main AddressSanitizer unit tests.
 add_custom_target(AsanUnitTests)
 set_target_properties(AsanUnitTests PROPERTIES FOLDER "Compiler-RT Tests")
 
 # AddressSanitizer unit tests with dynamic runtime (on platforms where it's
 # not the default).
 add_custom_target(AsanDynamicUnitTests)
 set_target_properties(AsanDynamicUnitTests PROPERTIES FOLDER "Compiler-RT Tests")
set(ASAN_INST_TEST_SOURCES
   asan_interface_test.cc
   asan_internal_interface_test.cc
   asan_test.cc
   asan_oob_test.cc
   asan_mem_test.cc
   asan_str_test.cc
   asan_test_main.cc)
 if(APPLE)
-  list(APPEND ASAN_INST_TEST_SOURCES asan_mac_test.cc)
+  list(APPEND ASAN_INST_TEST_SOURCES asan_mac_test.cc asan_mac_test_helpers.mm)
 endif()
 
 set(ASAN_BENCHMARKS_SOURCES
   ${COMPILER_RT_GTEST_SOURCE}
   asan_benchmarks_test.cc)
 
-# Adds ASan unit tests and benchmarks for architecture.
-macro(add_asan_tests_for_arch_and_kind arch kind cflags)
-  # Instrumented tests.
+function(add_asan_tests arch test_runtime)
+  cmake_parse_arguments(TEST "" "KIND" "CFLAGS" ${ARGN})
+
+  # Closure to keep the values.
+  function(generate_asan_tests test_objects test_suite testname)
+    generate_compiler_rt_tests(${test_objects} ${test_suite} ${testname} ${arch}
+      COMPILE_DEPS ${ASAN_UNITTEST_HEADERS} ${ASAN_BLACKLIST_FILE}
+      DEPS gtest asan
+      KIND ${TEST_KIND}
+      ${ARGN}
+      )
+    set("${test_objects}" "${${test_objects}}" PARENT_SCOPE)
+  endfunction()
+
   set(ASAN_INST_TEST_OBJECTS)
-  foreach(src ${ASAN_INST_TEST_SOURCES})
-    asan_compile(ASAN_INST_TEST_OBJECTS ${src} ${arch} ${kind}
-                 CFLAGS ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} ${cflags})
-  endforeach()
-  if (APPLE)
-    # Add Mac-specific helper.
-    asan_compile(ASAN_INST_TEST_OBJECTS asan_mac_test_helpers.mm ${arch} ${kind}
-                 CFLAGS ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} -ObjC ${cflags})
-  endif()
+  generate_asan_tests(ASAN_INST_TEST_OBJECTS AsanUnitTests
+    "Asan-${arch}${TEST_KIND}-Test"
+    SUBDIR "default"
+    LINK_FLAGS ${ASAN_UNITTEST_INSTRUMENTED_LINK_FLAGS}
+    SOURCES ${ASAN_INST_TEST_SOURCES}
+    CFLAGS ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} ${TEST_CFLAGS})
 
-  if (MSVC)
+  if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
+    set(dynamic_test_name "Asan-${arch}${TEST_KIND}-DynamicTest")
+    if(MSVC)
+
       # With the MSVC CRT, the choice between static and dynamic CRT is made at
       # compile time with a macro. Simulate the effect of passing /MD to clang-cl.
-    set(ASAN_INST_DYNAMIC_TEST_OBJECTS)
-    foreach(src ${ASAN_INST_TEST_SOURCES})
-      asan_compile(ASAN_INST_DYNAMIC_TEST_OBJECTS ${src} ${arch} ${kind}
-        CFLAGS ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} -D_MT -D_DLL ${cflags})
-    endforeach()
-    # Clang links the static CRT by default. Override that to use the dynamic
-    # CRT.
-    set(ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINK_FLAGS
-      ${ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINK_FLAGS}
-      -Wl,-nodefaultlib:libcmt,-defaultlib:msvcrt,-defaultlib:oldnames)
+      set(ASAN_DYNAMIC_TEST_OBJECTS)
+      generate_asan_tests(ASAN_DYNAMIC_TEST_OBJECTS
+        AsanDynamicUnitTests "${dynamic_test_name}"
+        SUBDIR "dynamic"
+        CFLAGS ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} -D_MT -D_DLL
+        SOURCES ${ASAN_INST_TEST_SOURCES}
+        LINK_FLAGS ${ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINK_FLAGS}
+          -Wl,-nodefaultlib:libcmt,-defaultlib:msvcrt,-defaultlib:oldnames
+        )
     else()
-    set(ASAN_INST_DYNAMIC_TEST_OBJECTS ${ASAN_INST_TEST_OBJECTS})
+
+      # Otherwise, reuse ASAN_INST_TEST_OBJECTS.
+      add_compiler_rt_test(AsanDynamicUnitTests
+        "${dynamic_test_name}"
+        SUBDIR "dynamic"
+        OBJECTS ${ASAN_INST_TEST_OBJECTS}
+        DEPS gtest asan ${ASAN_INST_TEST_OBJECTS}
+        LINK_FLAGS ${ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINK_FLAGS}
+        )
+    endif()
   endif()
 
-  # Create the 'default' folder where ASAN tests are produced.
-  file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/default/${CMAKE_CFG_RESOLVED_INTDIR}")
+  # Uninstrumented tests.
+  set(ASAN_NOINST_TEST_OBJECTS)
+  generate_asan_tests(ASAN_NOINST_TEST_OBJECTS
+    AsanUnitTests "Asan-${arch}${TEST_KIND}-Noinst-Test"
+    SUBDIR "default"
+    CFLAGS ${ASAN_UNITTEST_COMMON_CFLAGS}
+    LINK_FLAGS ${ASAN_UNITTEST_NOINST_LINK_FLAGS}
+    SOURCES ${ASAN_NOINST_TEST_SOURCES}
+    RUNTIME ${test_runtime})
 
-  add_asan_test(AsanUnitTests "Asan-${arch}${kind}-Test"
-                ${arch} ${kind} SUBDIR "default"
-                OBJECTS ${ASAN_INST_TEST_OBJECTS}
-                LINK_FLAGS ${ASAN_UNITTEST_INSTRUMENTED_LINK_FLAGS})
-  if(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME)
-    # Create the 'dynamic' folder where ASAN tests are produced.
-    file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/dynamic/${CMAKE_CFG_RESOLVED_INTDIR}")
+  set(ASAN_BENCHMARK_OBJECTS)
+  generate_asan_tests(ASAN_BENCHMARK_OBJECTS
+    AsanBenchmarks "Asan-${arch}${TEST_KIND}-Benchmark"
+    SUBDIR "default"
+    CFLAGS ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS}
+    SOURCES ${ASAN_BENCHMARKS_SOURCES}
+endfunction()
 
-    add_asan_test(AsanDynamicUnitTests "Asan-${arch}${kind}-Dynamic-Test"
-                  ${arch} ${kind} SUBDIR "dynamic"
-                  OBJECTS ${ASAN_INST_DYNAMIC_TEST_OBJECTS}
-                  LINK_FLAGS ${ASAN_DYNAMIC_UNITTEST_INSTRUMENTED_LINK_FLAGS})
+if(COMPILER_RT_CAN_EXECUTE_TESTS AND NOT ANDROID)
+  set(ASAN_TEST_ARCH ${ASAN_SUPPORTED_ARCH})
+  if(APPLE)
+    darwin_filter_host_archs(ASAN_SUPPORTED_ARCH ASAN_TEST_ARCH)
   endif()
 
+  foreach(arch ${ASAN_TEST_ARCH})
+
     # Add static ASan runtime that will be linked with uninstrumented tests.
-  set(ASAN_TEST_RUNTIME RTAsanTest.${arch}${kind})
+    set(ASAN_TEST_RUNTIME RTAsanTest.${arch})
     if(APPLE)
       set(ASAN_TEST_RUNTIME_OBJECTS
         $<TARGET_OBJECTS:RTAsan_dynamic.osx>
         $<TARGET_OBJECTS:RTInterception.osx>
         $<TARGET_OBJECTS:RTSanitizerCommon.osx>
         $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
         $<TARGET_OBJECTS:RTLSanCommon.osx>
         $<TARGET_OBJECTS:RTUbsan.osx>)
     else()
       set(ASAN_TEST_RUNTIME_OBJECTS
         $<TARGET_OBJECTS:RTAsan.${arch}>
         $<TARGET_OBJECTS:RTAsan_cxx.${arch}>
         $<TARGET_OBJECTS:RTInterception.${arch}>
         $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
         $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
         $<TARGET_OBJECTS:RTLSanCommon.${arch}>
         $<TARGET_OBJECTS:RTUbsan.${arch}>
         $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>)
     endif()
     add_library(${ASAN_TEST_RUNTIME} STATIC ${ASAN_TEST_RUNTIME_OBJECTS})
     set_target_properties(${ASAN_TEST_RUNTIME} PROPERTIES
       ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
       FOLDER "Compiler-RT Runtime tests")
-  # Uninstrumented tests.
-  set(ASAN_NOINST_TEST_OBJECTS)
-  foreach(src ${ASAN_NOINST_TEST_SOURCES})
-    asan_compile(ASAN_NOINST_TEST_OBJECTS ${src} ${arch} ${kind}
-                CFLAGS ${ASAN_UNITTEST_COMMON_CFLAGS} ${cflags})
-  endforeach()
-  add_asan_test(AsanUnitTests "Asan-${arch}${kind}-Noinst-Test"
-                ${arch} ${kind} SUBDIR "default"
-                OBJECTS ${ASAN_NOINST_TEST_OBJECTS}
-                LINK_FLAGS ${ASAN_UNITTEST_NOINST_LINK_FLAGS}
-                WITH_TEST_RUNTIME)
-
-  # Benchmarks.
-  set(ASAN_BENCHMARKS_OBJECTS)
-  foreach(src ${ASAN_BENCHMARKS_SOURCES})
-    asan_compile(ASAN_BENCHMARKS_OBJECTS ${src} ${arch} ${kind}
-                CFLAGS ${ASAN_UNITTEST_INSTRUMENTED_CFLAGS} ${cflags})
-  endforeach()
-  add_asan_test(AsanBenchmarks "Asan-${arch}${kind}-Benchmark"
-                ${arch} ${kind} SUBDIR "default"
-                OBJECTS ${ASAN_BENCHMARKS_OBJECTS}
-                LINK_FLAGS ${ASAN_UNITTEST_INSTRUMENTED_LINK_FLAGS})
-endmacro()
 
-if(COMPILER_RT_CAN_EXECUTE_TESTS AND NOT ANDROID)
-  set(ASAN_TEST_ARCH ${ASAN_SUPPORTED_ARCH})
-  if(APPLE)
-    darwin_filter_host_archs(ASAN_SUPPORTED_ARCH ASAN_TEST_ARCH)
-  endif()
-  foreach(arch ${ASAN_TEST_ARCH})
-    add_asan_tests_for_arch_and_kind(${arch} "-inline" "")
-    add_asan_tests_for_arch_and_kind(${arch} "-with-calls"
-      "-mllvm;-asan-instrumentation-with-call-threshold=0")
+    add_asan_tests(${arch} ${ASAN_TEST_RUNTIME} KIND "-inline")
+    add_asan_tests(${arch} ${ASAN_TEST_RUNTIME} KIND "-with-calls"
+      CFLAGS -mllvm -asan-instrumentation-with-call-threshold=0)
   endforeach()
 endif()
 
 if(ANDROID)
   foreach(arch ${ASAN_SUPPORTED_ARCH})
     # Test w/o ASan instrumentation. Link it with ASan statically.
     add_executable(AsanNoinstTest # FIXME: .arch?
       $<TARGET_OBJECTS:RTAsan.${arch}>

lib/interception/tests/CMakeLists.txt

 # (universal binary on Mac and arch-specific object files on Linux).
 macro(add_interceptor_lib library)
   add_library(${library} STATIC ${ARGN})
   set_target_properties(${library} PROPERTIES
     ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     FOLDER "Compiler-RT Runtime tests")
 endmacro()
 
-function(get_interception_lib_for_arch arch lib lib_name)
+function(get_interception_lib_for_arch arch lib)
   if(APPLE)
     set(tgt_name "RTInterception.test.osx")
   else()
     set(tgt_name "RTInterception.test.${arch}")
   endif()
   set(${lib} "${tgt_name}" PARENT_SCOPE)
-  set(${lib_name} $<TARGET_FILE:${tgt_name}> PARENT_SCOPE)
 endfunction()
 
 # Interception unit tests testsuite.
 add_custom_target(InterceptionUnitTests)
 set_target_properties(InterceptionUnitTests PROPERTIES
   FOLDER "Compiler-RT Tests")
 
 # Adds interception tests for architecture.
 macro(add_interception_tests_for_arch arch)
-  get_target_flags_for_arch(${arch} TARGET_FLAGS)
-  set(INTERCEPTION_TEST_SOURCES ${INTERCEPTION_UNITTESTS}
-                             ${COMPILER_RT_GTEST_SOURCE})
-  set(INTERCEPTION_TEST_COMPILE_DEPS ${INTERCEPTION_TEST_HEADERS})
-  if(NOT COMPILER_RT_STANDALONE_BUILD)
-    list(APPEND INTERCEPTION_TEST_COMPILE_DEPS gtest)
-  endif()
   set(INTERCEPTION_TEST_OBJECTS)
-  foreach(source ${INTERCEPTION_TEST_SOURCES})
-    get_filename_component(basename ${source} NAME)
-    set(output_obj "${CMAKE_CFG_RESOLVED_INTDIR}${basename}.${arch}.o")
-    clang_compile(${output_obj} ${source}
-                  CFLAGS ${INTERCEPTION_TEST_CFLAGS_COMMON} ${TARGET_FLAGS}
-                  DEPS ${INTERCEPTION_TEST_COMPILE_DEPS})
-    list(APPEND INTERCEPTION_TEST_OBJECTS ${output_obj})
-  endforeach()
-  get_interception_lib_for_arch(${arch} INTERCEPTION_COMMON_LIB
-                                INTERCEPTION_COMMON_LIB_NAME)
-  # Add unittest target.
-  set(INTERCEPTION_TEST_NAME "Interception-${arch}-Test")
-  add_compiler_rt_test(InterceptionUnitTests ${INTERCEPTION_TEST_NAME}
-                       OBJECTS ${INTERCEPTION_TEST_OBJECTS}
-                               ${INTERCEPTION_COMMON_LIB_NAME}
-                       DEPS ${INTERCEPTION_TEST_OBJECTS} ${INTERCEPTION_COMMON_LIB}
-                       LINK_FLAGS ${INTERCEPTION_TEST_LINK_FLAGS_COMMON}
-                                  ${TARGET_FLAGS})
+  get_interception_lib_for_arch(${arch} INTERCEPTION_COMMON_LIB)
+  generate_compiler_rt_tests(INTERCEPTION_TEST_OBJECTS
+    InterceptionUnitTests "Interception-${arch}-Test" ${arch}
+    RUNTIME ${INTERCEPTION_COMMON_LIB}
+    SOURCES ${INTERCEPTION_UNITTESTS} ${COMPILER_RT_GTEST_SOURCE}
+    COMPILE_DEPS gtest ${INTERCEPTION_TEST_HEADERS}
+    DEPS gtest
+    CFLAGS ${INTERCEPTION_TEST_CFLAGS_COMMON}
+    LINK_FLAGS ${INTERCEPTION_TEST_LINK_FLAGS_COMMON})
 endmacro()
 
 if(COMPILER_RT_CAN_EXECUTE_TESTS AND NOT ANDROID AND NOT APPLE)
   # We use just-built clang to build interception unittests, so we must
   # be sure that produced binaries would work.
   if(APPLE)
     add_interceptor_lib("RTInterception.test.osx"
                         $<TARGET_OBJECTS:RTInterception.osx>)

lib/sanitizer_common/tests/CMakeLists.txt

 # (universal binary on Mac and arch-specific object files on Linux).
 macro(add_sanitizer_common_lib library)
   add_library(${library} STATIC ${ARGN})
   set_target_properties(${library} PROPERTIES
     ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     FOLDER "Compiler-RT Runtime tests")
 endmacro()
 
-function(get_sanitizer_common_lib_for_arch arch lib lib_name)
+function(get_sanitizer_common_lib_for_arch arch lib)
   if(APPLE)
     set(tgt_name "RTSanitizerCommon.test.osx")
   else()
     set(tgt_name "RTSanitizerCommon.test.${arch}")
   endif()
   set(${lib} "${tgt_name}" PARENT_SCOPE)
-  set(${lib_name} $<TARGET_FILE:${tgt_name}> PARENT_SCOPE)
 endfunction()
 
 # Sanitizer_common unit tests testsuite.
 add_custom_target(SanitizerUnitTests)
 set_target_properties(SanitizerUnitTests PROPERTIES FOLDER "Compiler-RT Tests")
 
 # Adds sanitizer tests for architecture.
 macro(add_sanitizer_tests_for_arch arch)
-  get_target_flags_for_arch(${arch} TARGET_FLAGS)
-
-  # If the sanitizer library was built with _FILE_OFFSET_BITS=64 we need
-  # to ensure that the library and tests agree on the layout of certain
-  # structures such as 'struct stat'.
+  set(extra_flags)
   if( CMAKE_SIZEOF_VOID_P EQUAL 4 )
-    list(APPEND TARGET_FLAGS "-D_LARGEFILE_SOURCE")
-    list(APPEND TARGET_FLAGS "-D_FILE_OFFSET_BITS=64")
+    list(APPEND extra_flags "-D_LARGEFILE_SOURCE")
+    list(APPEND extra_flags "-D_FILE_OFFSET_BITS=64")
   endif()
+  get_sanitizer_common_lib_for_arch(${arch} SANITIZER_COMMON_LIB)
 
-  set(SANITIZER_TEST_SOURCES ${SANITIZER_UNITTESTS}
-                             ${COMPILER_RT_GTEST_SOURCE})
-  set(SANITIZER_TEST_COMPILE_DEPS ${SANITIZER_TEST_HEADERS})
-  if(NOT COMPILER_RT_STANDALONE_BUILD)
-    list(APPEND SANITIZER_TEST_COMPILE_DEPS gtest)
-  endif()
   set(SANITIZER_TEST_OBJECTS)
-  foreach(source ${SANITIZER_TEST_SOURCES})
-    get_filename_component(basename ${source} NAME)
-    set(output_obj "${CMAKE_CFG_RESOLVED_INTDIR}${basename}.${arch}.o")
-    clang_compile(${output_obj} ${source}
-                  CFLAGS ${SANITIZER_TEST_CFLAGS_COMMON} ${TARGET_FLAGS}
-                  DEPS ${SANITIZER_TEST_COMPILE_DEPS})
-    list(APPEND SANITIZER_TEST_OBJECTS ${output_obj})
-  endforeach()
-  get_sanitizer_common_lib_for_arch(${arch} SANITIZER_COMMON_LIB
-                                    SANITIZER_COMMON_LIB_NAME)
-  # Add unittest target.
-  set(SANITIZER_TEST_NAME "Sanitizer-${arch}-Test")
-  add_compiler_rt_test(SanitizerUnitTests ${SANITIZER_TEST_NAME}
-                       OBJECTS ${SANITIZER_TEST_OBJECTS}
-                               ${SANITIZER_COMMON_LIB_NAME}
-                       DEPS ${SANITIZER_TEST_OBJECTS} ${SANITIZER_COMMON_LIB}
-                       LINK_FLAGS ${SANITIZER_TEST_LINK_FLAGS_COMMON}
-                                  ${TARGET_FLAGS})
+  generate_compiler_rt_tests(SANITIZER_TEST_OBJECTS SanitizerUnitTests
+    "Sanitizer-${arch}-Test" ${arch}
+    RUNTIME "${SANITIZER_COMMON_LIB}"
+    SOURCES ${SANITIZER_UNITTESTS} ${COMPILER_RT_GTEST_SOURCE}
+    COMPILE_DEPS ${SANITIZER_TEST_HEADERS}
+    DEPS gtest
+    CFLAGS  ${SANITIZER_TEST_CFLAGS_COMMON} ${extra_flags}
+    LINK_FLAGS ${SANITIZER_TEST_LINK_FLAGS_COMMON} ${extra_flags})
 
   if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND "${arch}" STREQUAL "x86_64")
     # Test that the libc-independent part of sanitizer_common is indeed
     # independent of libc, by linking this binary without libc (here) and
     # executing it (unit test in sanitizer_nolibc_test.cc).
     clang_compile(sanitizer_nolibc_test_main.${arch}.o
                   sanitizer_nolibc_test_main.cc
                   CFLAGS ${SANITIZER_TEST_CFLAGS_COMMON} ${TARGET_FLAGS}

lib/tsan/tests/CMakeLists.txt

set(TSAN_UNITTEST_CFLAGS
   ${COMPILER_RT_GTEST_CFLAGS}
   -I${COMPILER_RT_SOURCE_DIR}/include
   -I${COMPILER_RT_SOURCE_DIR}/lib
   -I${COMPILER_RT_SOURCE_DIR}/lib/tsan/rtl
   -DGTEST_HAS_RTTI=0)
 
 set(TSAN_TEST_ARCH ${TSAN_SUPPORTED_ARCH})
 if(APPLE)
-  darwin_filter_host_archs(TSAN_SUPPORTED_ARCH TSAN_TEST_ARCH)
-  list(APPEND TSAN_UNITTEST_CFLAGS ${DARWIN_osx_CFLAGS})
 
   # Create a static library for test dependencies.
   set(TSAN_TEST_RUNTIME_OBJECTS
     $<TARGET_OBJECTS:RTTsan_dynamic.osx>
     $<TARGET_OBJECTS:RTInterception.osx>
     $<TARGET_OBJECTS:RTSanitizerCommon.osx>
     $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
     $<TARGET_OBJECTS:RTUbsan.osx>)
   set(TSAN_TEST_RUNTIME RTTsanTest)
   add_library(${TSAN_TEST_RUNTIME} STATIC ${TSAN_TEST_RUNTIME_OBJECTS})
   set_target_properties(${TSAN_TEST_RUNTIME} PROPERTIES
     ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+  darwin_filter_host_archs(TSAN_SUPPORTED_ARCH TSAN_TEST_ARCH)
+  list(APPEND TSAN_UNITTEST_CFLAGS ${DARWIN_osx_CFLAGS})
+
+  set(LINK_FLAGS "-lc++")
+  add_weak_symbols("ubsan" LINK_FLAGS)
+  add_weak_symbols("sanitizer_common" LINK_FLAGS)
+else()
+  set(LINK_FLAGS "-fsanitize=thread;-lstdc++;-lm")
 endif()
 
 set(TSAN_RTL_HEADERS)
 foreach (header ${TSAN_HEADERS})
   list(APPEND TSAN_RTL_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../${header})
 endforeach()
 
 # add_tsan_unittest(<name>
 #                   SOURCES <sources list>
 #                   HEADERS <extra headers list>)
 macro(add_tsan_unittest testname)
   cmake_parse_arguments(TEST "" "" "SOURCES;HEADERS" ${ARGN})
   if(UNIX)
-    foreach(arch ${TSAN_TEST_ARCH})
-      set(TEST_OBJECTS)
-      foreach(SOURCE ${TEST_SOURCES} ${COMPILER_RT_GTEST_SOURCE})
-        sanitizer_test_compile(
-          TEST_OBJECTS ${SOURCE} ${arch}
-          COMPILE_DEPS ${TSAN_RTL_HEADERS} ${TEST_HEADERS}
-          DEPS gtest tsan
-          CFLAGS ${TSAN_UNITTEST_CFLAGS}
-          )
-      endforeach()
-      get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS)
-      set(TEST_DEPS ${TEST_OBJECTS})
-      if(NOT APPLE)
-        # FIXME: Looks like we should link TSan with just-built runtime,
-        # and not rely on -fsanitize=thread, as these tests are essentially
-        # unit tests.
-        add_compiler_rt_test(TsanUnitTests ${testname}
-                OBJECTS ${TEST_OBJECTS}
-                DEPS ${TEST_DEPS}
-                LINK_FLAGS ${TARGET_LINK_FLAGS}
-                           -fsanitize=thread
-                           -lstdc++ -lm)
-      else()
-        list(APPEND TEST_OBJECTS $<TARGET_FILE:${TSAN_TEST_RUNTIME}>)
-        list(APPEND TEST_DEPS ${TSAN_TEST_RUNTIME})
-
-        add_weak_symbols("ubsan" WEAK_SYMBOL_LINK_FLAGS)
-        add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
-
-        # Intentionally do *not* link with `-fsanitize=thread`. We already link
-        # against a static version of the runtime, and we don't want the dynamic
-        # one.
-        add_compiler_rt_test(TsanUnitTests "${testname}-${arch}-Test"
-                OBJECTS ${TEST_OBJECTS}
-                DEPS ${TEST_DEPS}
-                LINK_FLAGS ${TARGET_LINK_FLAGS} ${DARWIN_osx_LINK_FLAGS}
-                           ${WEAK_SYMBOL_LINK_FLAGS} -lc++)
-      endif()
+    foreach(arch ${ASAN_TEST_ARCH})
+      generate_compiler_rt_tests(TsanUnitTests ${testname} ${arch}
+        SOURCES ${TEST_SOURCES}
+        RUNTIME ${TSAN_TEST_RUNTIME}
+        COMPILE_DEPS ${TEST_HEADERS} ${TSAN_RTL_HEADERS}
+        LINK_FLAGS ${LINK_FLAGS})
     endforeach()
   endif()
 endmacro()
 
 if(COMPILER_RT_CAN_EXECUTE_TESTS)
   add_subdirectory(rtl)
   add_subdirectory(unit)
 endif()

lib/xray/tests/CMakeLists.txt

 include_directories(..)
 
 add_custom_target(XRayUnitTests)
 set_target_properties(XRayUnitTests PROPERTIES FOLDER "XRay unittests")
 
 set(XRAY_UNITTEST_CFLAGS
   ${XRAY_CFLAGS}
   ${COMPILER_RT_UNITTEST_CFLAGS}
   ${COMPILER_RT_GTEST_CFLAGS}
   -I${COMPILER_RT_SOURCE_DIR}/include
   -I${COMPILER_RT_SOURCE_DIR}/lib/xray
   -I${COMPILER_RT_SOURCE_DIR}/lib)
 
 macro(add_xray_unittest testname)
   set(XRAY_TEST_ARCH ${XRAY_SUPPORTED_ARCH})
-  if (APPLE)
-    darwin_filter_host_archs(XRAY_SUPPORTED_ARCH)
-  endif()
-  if(UNIX)
-    foreach(arch ${XRAY_TEST_ARCH})
-      cmake_parse_arguments(TEST "" "" "SOURCES;HEADERS" ${ARGN})
-      set(TEST_OBJECTS)
-      foreach(SOURCE ${TEST_SOURCES} ${COMPILER_RT_GTEST_SOURCE})
-        sanitizer_test_compile(TEST_OBJECTS ${SOURCE} ${arch}
-                               DEPS gtest_main xray
-                               CFLAGS ${XRAY_UNITTEST_CFLAGS})
-      endforeach()
-      get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS)
-      set(TEST_DEPS ${TEST_OBJECTS})
-      if(NOT COMPILER_RT_STANDALONE_BUILD)
-        list(APPEND TEST_DEPS gtest_main xray)
-      endif()
-      if(NOT APPLE)
-        add_compiler_rt_test(XRayUnitTests ${testname}-${arch}
-          OBJECTS ${TEST_OBJECTS}
-          DEPS ${TEST_DEPS}
-          LINK_FLAGS ${TARGET_LINK_FLAGS}
+  # FIXME: Figure out how to run even just the unit tests on APPLE.
+  if(UNIX AND NOT APPLE)
+    foreach(arch ${XRAY_TEST_ARCH})
+      generate_compiler_rt_tests(TEST_OBJECTS
+        XRayUnitTests "${testname}-${arch}" "${arch}"
+        SOURCES ${TEST_SOURCES} ${COMPILER_RT_GTEST_SOURCE}
+        CFLAGS ${XRAY_UNITTEST_CFLAGS}
+        LINK_FLAGS
           -lstdc++ -lm ${CMAKE_THREAD_LIBS_INIT}
           -lpthread
           -L${COMPILER_RT_LIBRARY_OUTPUT_DIR} -lclang_rt.xray-${arch}
           -ldl -lrt)
-      endif()
-      # FIXME: Figure out how to run even just the unit tests on APPLE.
     endforeach()
   endif()
 endmacro()
 
 if(COMPILER_RT_CAN_EXECUTE_TESTS)
   add_subdirectory(unit)
 endif()