[CMake] Add compiler-rt header files to the list of sources for targets when building with an IDE

[delcypher]

Summary

[CMake] Add compiler-rt header files to the list of sources for targets
when building with an IDE so that header files show up in the UI.
This massively improves the development workflow in IDEs.

To implement this a new function compiler_rt_process_sources(...) has
been added that adds header files to the list of sources when the
generator is an IDE. For non-IDE generators (e.g. Ninja/Makefile) no
changes are made to the list of source files.

The function can be passed a list of headers via the
ADDITIONAL_HEADERS argument. For each runtime library a list of
explicit header files has been added and passed via
ADDITIONAL_HEADERS. For tsan and sanitizer_common a list of
headers was already present but it was stale and has been updated
to reflect the current state of the source tree.

The original version of this patch used file globbing (*.{h,inc,def})
to find the headers but the approach was changed due to this being a
CMake anti-pattern (if the list of headers changes CMake won't
automatically re-generate if globbing is used).

The LLVM repo contains a similar function named llvm_process_sources()
but we don't use it here for several reasons:

• It depends on the LLVM_ENABLE_OPTION cache variable which is not set in standalone compiler-rt builds.
• We would have to include(LLVMProcessSources) which I'd like to avoid because it would include a bunch of stuff we don't need.

[kubamracek]

Besides the naming nit, this looks good to me, but I'm not a CMake expert. @george.karpenkov could you review this?

cmake/Modules/AddCompilerRT.cmake

61

Please rename "crt" to "compiler_rt" (throughout the patch). I don't think we're using "crt" to mean "compiler-rt" anywhere in the codebase.

[phosek]

Personally, I'd prefer to spell out all the headers explicitly rather than using globing which is more error-prone to future changes. I also agree with @kubamracek's comment about using crt (which may be also mistaken for crt*.o) to compiler_rt.

[delcypher]

In D48422#1142634, @phosek wrote:

Personally, I'd prefer to spell out all the headers explicitly rather than using globing which is more error-prone to future changes. I also agree with @kubamracek's comment about using crt (which may be also mistaken for crt*.o) to compiler_rt.

My patch does allow for this (use ADDITIONAL_HEADERS argument). In fact I used that for clang_rt.tsan because there was already a list of TSan header files (previously unused) already there.

I already mentioned (in the commit message) that globbing for sources is generally a CMake anti-pattern. However this is the approach used the in the LLVM CMake code, which is why I adopted it.

I have no problem listing the header files explicitly, but I don't know how the rest of the compiler-rt developers feel about this. I'll add a few more reviewers to see if we can get a consensus.

cmake/Modules/AddCompilerRT.cmake

61

Sure. I'll fix that.

[delcypher]

• s/crt_process_sources/compiler_rt_process_sources/
• s/crt_find_headers_in_dir/compiler_rt_find_headers_in_dir/
• Improve commit message.

[george.karpenkov]

cmake/Modules/CompilerRTUtils.cmake

356

Since we are not testing on MSVC should we really handle it here?

361

I'm not sure what do we need here. Could we just ask Clang on each source file which headers it requires? I believe that's what CMake does behind the scenes to support incremental compilation, it's just harder for compiler-rt since we are not using the default compiler.

[george.karpenkov]

Requesting changes/clarification on the globbing approach used.

[delcypher]

cmake/Modules/CompilerRTUtils.cmake

356

This conditional is taken from cmake/modules/HandleLLVMOptions.cmake (LLVM repo) and is the expression used to initialize the default value of LLVM_ENABLE_IDE. Given that support for IDE folders was already added to compiler-rt for an in-tree build for Visual Studio (r275111) at least in one point in time Visual Studio was used to build compiler-rt.

I'd rather keep the MSVC_IDE condition and only remove it if the bots break.

361

Could we just ask Clang on each source file which headers it requires? I believe that's what CMake does behind the scenes to support incremental compilation,

No. First we can't assume we are using clang. Compiler-rt is also built by gcc (and possibly by MSVC). Also incremental compilation is actually dealt with (at least in the case of the Makefile and Ninja generators) by the generated build system by having the first invocation of a target generate dependency files that are later consumed by re-compilations of the same target.

What I'm doing here is simply what the LLVM project does (apart from TSan which already had a list lying around that I could just use). I would actually prefer to do what @phosek suggests and list all header files explicitly, however I'm not sure if people will agree with that because that's not what is done in the LLVM project.

[george.karpenkov]

@delcypher OK, I didn't know that!
I'm personally fine with either hardcoding the list of headers or using globbing, as new headers get added rather rarely.

[delcypher]

Switch to explicit lists of headers instead of globbing.

[delcypher]

@eugenis While doing this I think I spotted a typo for a hwasan target. The RTHwasan_dynamic target includes ${TSAN_RTL_CXX_SOURCES} in SOURCES which doesn't make sense. It's probably supposed to be ${HWASAN_RTL_CXX_SOURCES}. I've not fixed it in this patch but I left a FIXME near by. Do you want to fix this?

[delcypher]

@george.karpenkov @phosek I switched to using explicit lists of headers and found some problems in the process and fixed them. Could you take another look?

[delcypher]

In D48422#1146587, @delcypher wrote:

@george.karpenkov @phosek I switched to using explicit lists of headers and found some problems in the process and fixed them. Could you take another look?

Ping.

cmake/Modules/AddCompilerRT.cmake

 # architectures with name "<name>.<arch>" for non-Darwin platforms if
 # architecture can be targeted, and "<name>.<os>" for Darwin platforms.
 # add_compiler_rt_object_libraries(<name>
 #                                  OS <os names>
 #                                  ARCHS <architectures>
 #                                  SOURCES <source files>
 #                                  CFLAGS <compile flags>
 #                                  DEFS <compile definitions>
-#                                  DEPS <dependencies>)
+#                                  DEPS <dependencies>
+#                                  ADDITIONAL_HEADERS <header files>)
 function(add_compiler_rt_object_libraries name)
-  cmake_parse_arguments(LIB "" "" "OS;ARCHS;SOURCES;CFLAGS;DEFS;DEPS" ${ARGN})
+  cmake_parse_arguments(LIB "" "" "OS;ARCHS;SOURCES;CFLAGS;DEFS;DEPS;ADDITIONAL_HEADERS"
+    ${ARGN})
   set(libnames)
   if(APPLE)
     foreach(os ${LIB_OS})
       set(libname "${name}.${os}")
       set(libnames ${libnames} ${libname})
       set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS})
       list_intersect(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS)
     endforeach()
   else()
     foreach(arch ${LIB_ARCHS})
       set(libname "${name}.${arch}")
       set(libnames ${libnames} ${libname})
       set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS})
       if(NOT CAN_TARGET_${arch})
         message(FATAL_ERROR "Architecture ${arch} can't be targeted")
         return()
       endif()
     endforeach()
   endif()
 
+  # Add headers to LIB_SOURCES for IDEs
+  compiler_rt_process_sources(LIB_SOURCES
+    ${LIB_SOURCES}
+    ADDITIONAL_HEADERS
+      ${LIB_ADDITIONAL_HEADERS}
+  )
+
   foreach(libname ${libnames})
     add_library(${libname} OBJECT ${LIB_SOURCES})
     if(LIB_DEPS)
       add_dependencies(${libname} ${LIB_DEPS})
     endif()
 
     # Strip out -msse3 if this isn't macOS.
     set(target_flags ${LIB_CFLAGS})

 #                         ARCHS <architectures>
 #                         OS <os list>
 #                         SOURCES <source files>
 #                         CFLAGS <compile flags>
 #                         LINK_FLAGS <linker flags>
 #                         DEFS <compile definitions>
 #                         LINK_LIBS <linked libraries> (only for shared library)
 #                         OBJECT_LIBS <object libraries to use as sources>
-#                         PARENT_TARGET <convenience parent target>)
+#                         PARENT_TARGET <convenience parent target>
+#                         ADDITIONAL_HEADERS <header files>)
 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;LINK_FLAGS;DEFS;LINK_LIBS;OBJECT_LIBS"
+    "OS;ARCHS;SOURCES;CFLAGS;LINK_FLAGS;DEFS;LINK_LIBS;OBJECT_LIBS;ADDITIONAL_HEADERS"
     ${ARGN})
   set(libnames)
   # Until we support this some other way, build compiler-rt runtime without LTO
   # to allow non-LTO projects to link with it.
   if(COMPILER_RT_HAS_FNO_LTO_FLAG)
     set(NO_LTO_FLAGS "-fno-lto")
   else()
     set(NO_LTO_FLAGS "")
   endif()
 
+  list(LENGTH LIB_SOURCES LIB_SOURCES_LENGTH)
+  if (${LIB_SOURCES_LENGTH} GREATER 0)
+    # Add headers to LIB_SOURCES for IDEs. It doesn't make sense to
+    # do this for a runtime library that only consists of OBJECT
+    # libraries, so only add the headers when source files are present.
+    compiler_rt_process_sources(LIB_SOURCES
+      ${LIB_SOURCES}
+      ADDITIONAL_HEADERS
+        ${LIB_ADDITIONAL_HEADERS}
+    )
+  endif()
+
   if(APPLE)
     foreach(os ${LIB_OS})
       # Strip out -msse3 if this isn't macOS.
       list(LENGTH LIB_CFLAGS HAS_EXTRA_CFLAGS)
       if(HAS_EXTRA_CFLAGS AND NOT "${os}" MATCHES "^(osx)$")
         list(REMOVE_ITEM LIB_CFLAGS "-msse3")
       endif()
       if(type STREQUAL "STATIC")

cmake/Modules/CompilerRTUtils.cmake

 function(get_compiler_rt_output_dir arch output_dir)
   if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
     get_compiler_rt_target(${arch} target)
     set(${output_dir} ${COMPILER_RT_OUTPUT_DIR}/${target}/lib PARENT_SCOPE)
   else()
     set(${output_dir} ${COMPILER_RT_LIBRARY_OUTPUT_DIR} PARENT_SCOPE)
   endif()
 endfunction()
+
+# compiler_rt_process_sources(
+#   <OUTPUT_VAR>
+#   <SOURCE_FILE> ...
+#  [ADDITIONAL_HEADERS <header> ...]
+# )
+#
+# Process the provided sources and write the list of new sources
+# into `<OUTPUT_VAR>`.
+#
+# ADDITIONAL_HEADERS     - Adds the supplied header to list of sources for IDEs.
+#
+# This function is very similar to `llvm_process_sources()` but exists here
+# because we need to support standalone builds of compiler-rt.
+function(compiler_rt_process_sources OUTPUT_VAR)
+  cmake_parse_arguments(
+    ARG
+    ""
+    ""
+    "ADDITIONAL_HEADERS"
+    ${ARGN}
+  )
+  set(sources ${ARG_UNPARSED_ARGUMENTS})
+  set(headers "")
+  if (XCODE OR MSVC_IDE OR CMAKE_EXTRA_GENERATOR)
+    # For IDEs we need to tell CMake about header files.
+    # Otherwise they won't show up in UI.
+    set(headers ${ARG_ADDITIONAL_HEADERS})
+    list(LENGTH headers headers_length)
+    if (${headers_length} GREATER 0)
+      set_source_files_properties(${headers}
+        PROPERTIES HEADER_FILE_ONLY ON)
+    endif()
+  endif()
+  set("${OUTPUT_VAR}" ${sources} ${headers} PARENT_SCOPE)
+endfunction()

lib/asan/CMakeLists.txt

set(ASAN_SOURCES
   asan_win.cc)
 
 set(ASAN_CXX_SOURCES
   asan_new_delete.cc)
 
 set(ASAN_PREINIT_SOURCES
   asan_preinit.cc)
 
+SET(ASAN_HEADERS
+  asan_activation.h
+  asan_activation_flags.inc
+  asan_allocator.h
+  asan_descriptions.h
+  asan_errors.h
+  asan_fake_stack.h
+  asan_flags.h
+  asan_flags.inc
+  asan_init_version.h
+  asan_interceptors.h
+  asan_interceptors_memintrinsics.h
+  asan_interface.inc
+  asan_interface_internal.h
+  asan_internal.h
+  asan_lock.h
+  asan_malloc_local.h
+  asan_mapping.h
+  asan_mapping_myriad.h
+  asan_poisoning.h
+  asan_premap_shadow.h
+  asan_report.h
+  asan_scariness_score.h
+  asan_stack.h
+  asan_stats.h
+  asan_suppressions.h
+  asan_thread.h)
+
 include_directories(..)
 
 set(ASAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 set(ASAN_COMMON_DEFINITIONS ${COMPILER_RT_ASAN_SHADOW_SCALE_DEFINITION})
 
 append_rtti_flag(OFF ASAN_CFLAGS)
 
 set(ASAN_DYNAMIC_LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS})

 append_list_if(COMPILER_RT_HAS_LIBLOG log ASAN_DYNAMIC_LIBS)
 
 # Compile ASan sources into an object library.
 
 add_compiler_rt_object_libraries(RTAsan_dynamic
   OS ${SANITIZER_COMMON_SUPPORTED_OS}
   ARCHS ${ASAN_SUPPORTED_ARCH}
   SOURCES ${ASAN_SOURCES} ${ASAN_CXX_SOURCES}
+  ADDITIONAL_HEADERS ${ASAN_HEADERS}
   CFLAGS ${ASAN_DYNAMIC_CFLAGS}
   DEFS ${ASAN_DYNAMIC_DEFINITIONS})
 
 if(NOT APPLE)
   add_compiler_rt_object_libraries(RTAsan
     ARCHS ${ASAN_SUPPORTED_ARCH}
-    SOURCES ${ASAN_SOURCES} CFLAGS ${ASAN_CFLAGS}
+    SOURCES ${ASAN_SOURCES}
+    ADDITIONAL_HEADERS ${ASAN_HEADERS}
+    CFLAGS ${ASAN_CFLAGS}
     DEFS ${ASAN_COMMON_DEFINITIONS})
   add_compiler_rt_object_libraries(RTAsan_cxx
     ARCHS ${ASAN_SUPPORTED_ARCH}
-    SOURCES ${ASAN_CXX_SOURCES} CFLAGS ${ASAN_CFLAGS}
+    SOURCES ${ASAN_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${ASAN_HEADERS}
+    CFLAGS ${ASAN_CFLAGS}
     DEFS ${ASAN_COMMON_DEFINITIONS})
   add_compiler_rt_object_libraries(RTAsan_preinit
     ARCHS ${ASAN_SUPPORTED_ARCH}
-    SOURCES ${ASAN_PREINIT_SOURCES} CFLAGS ${ASAN_CFLAGS}
+    SOURCES ${ASAN_PREINIT_SOURCES}
+    ADDITIONAL_HEADERS ${ASAN_HEADERS}
+    CFLAGS ${ASAN_CFLAGS}
     DEFS ${ASAN_COMMON_DEFINITIONS})
 
   file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/dummy.cc "")
   add_compiler_rt_object_libraries(RTAsan_dynamic_version_script_dummy
     ARCHS ${ASAN_SUPPORTED_ARCH}
     SOURCES ${CMAKE_CURRENT_BINARY_DIR}/dummy.cc
     CFLAGS ${ASAN_DYNAMIC_CFLAGS}
     DEFS ${ASAN_DYNAMIC_DEFINITIONS})

lib/dfsan/CMakeLists.txt

 include_directories(..)
 
 # Runtime library sources and build flags.
 set(DFSAN_RTL_SOURCES
   dfsan.cc
   dfsan_custom.cc
   dfsan_interceptors.cc)
+
+set(DFSAN_RTL_HEADERS
+  dfsan.h
+  dfsan_flags.inc
+  dfsan_platform.h)
+
 set(DFSAN_COMMON_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 append_rtti_flag(OFF DFSAN_COMMON_CFLAGS)
 # Prevent clang from generating libc calls.
 append_list_if(COMPILER_RT_HAS_FFREESTANDING_FLAG -ffreestanding DFSAN_COMMON_CFLAGS)
 
 # Static runtime library.
 add_compiler_rt_component(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
     STATIC
     ARCHS ${arch}
     SOURCES ${DFSAN_RTL_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+    ADDITIONAL_HEADERS ${DFSAN_RTL_HEADERS}
     CFLAGS ${DFSAN_CFLAGS}
     PARENT_TARGET dfsan)
   add_sanitizer_rt_symbols(clang_rt.dfsan
     ARCHS ${arch}
     EXTRA dfsan.syms.extra)
   add_dependencies(dfsan
     clang_rt.dfsan-${arch}-symbols)
 endforeach()

lib/esan/CMakeLists.txt

set(ESAN_SOURCES
   esan_interface.cpp
   esan_interceptors.cpp
   esan_linux.cpp
   esan_sideline_linux.cpp
   cache_frag.cpp
   working_set.cpp
   working_set_posix.cpp)
 
+set(ESAN_HEADERS
+  cache_frag.h
+  esan.h
+  esan_circular_buffer.h
+  esan_flags.h
+  esan_flags.inc
+  esan_hashtable.h
+  esan_interface_internal.h
+  esan_shadow.h
+  esan_sideline.h
+  working_set.h)
+
 foreach (arch ${ESAN_SUPPORTED_ARCH})
   add_compiler_rt_runtime(clang_rt.esan
     STATIC
     ARCHS ${arch}
     SOURCES ${ESAN_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.${arch}>
+    ADDITIONAL_HEADERS ${ESAN_HEADERS}
     CFLAGS ${ESAN_RTL_CFLAGS})
   add_sanitizer_rt_symbols(clang_rt.esan
     ARCHS ${arch}
     EXTRA esan.syms.extra)
   add_dependencies(esan
     clang_rt.esan-${arch}
     clang_rt.esan-${arch}-symbols)
 endforeach()
 
 if (COMPILER_RT_INCLUDE_TESTS)
   # TODO(bruening): add tests via add_subdirectory(tests)
 endif()

lib/fuzzer/CMakeLists.txt

set(LIBFUZZER_SOURCES
   FuzzerShmemPosix.cpp
   FuzzerShmemWindows.cpp
   FuzzerTracePC.cpp
   FuzzerUtil.cpp
   FuzzerUtilDarwin.cpp
   FuzzerUtilFuchsia.cpp
   FuzzerUtilLinux.cpp
   FuzzerUtilPosix.cpp
-  FuzzerUtilWindows.cpp
-  )
+  FuzzerUtilWindows.cpp)
+
+set(LIBFUZZER_HEADERS
+  FuzzerCommand.h
+  FuzzerCorpus.h
+  FuzzerDataFlowTrace.h
+  FuzzerDefs.h
+  FuzzerDictionary.h
+  FuzzerExtFunctions.def
+  FuzzerExtFunctions.h
+  FuzzerFlags.def
+  FuzzerIO.h
+  FuzzerInterface.h
+  FuzzerInternal.h
+  FuzzerMerge.h
+  FuzzerMutate.h
+  FuzzerOptions.h
+  FuzzerRandom.h
+  FuzzerSHA1.h
+  FuzzerShmem.h
+  FuzzerTracePC.h
+  FuzzerUtil.h
+  FuzzerValueBitMap.h)
 
 CHECK_CXX_SOURCE_COMPILES("
   static thread_local int blah;
   int main() {
   return 0;
   }
   " HAS_THREAD_LOCAL)
 

 endif()
 
 set(FUZZER_SUPPORTED_OS ${SANITIZER_COMMON_SUPPORTED_OS})
 
 add_compiler_rt_object_libraries(RTfuzzer
   OS ${FUZZER_SUPPORTED_OS}
   ARCHS ${FUZZER_SUPPORTED_ARCH}
   SOURCES ${LIBFUZZER_SOURCES}
+  ADDITIONAL_HEADERS ${LIBFUZZER_HEADERS}
   CFLAGS ${LIBFUZZER_CFLAGS}
   DEPS ${LIBFUZZER_DEPS})
 
 add_compiler_rt_object_libraries(RTfuzzer_main
   OS ${FUZZER_SUPPORTED_OS}
   ARCHS ${FUZZER_SUPPORTED_ARCH}
   SOURCES FuzzerMain.cpp
   CFLAGS ${LIBFUZZER_CFLAGS}

lib/hwasan/CMakeLists.txt

set(HWASAN_RTL_SOURCES
   hwasan_poisoning.cc
   hwasan_report.cc
   hwasan_thread.cc
   )
 
 set(HWASAN_RTL_CXX_SOURCES
   hwasan_new_delete.cc)
 
+set(HWASAN_RTL_HEADERS
+  hwasan.h
+  hwasan_allocator.h
+  hwasan_dynamic_shadow.h
+  hwasan_flags.h
+  hwasan_flags.inc
+  hwasan_interface_internal.h
+  hwasan_mapping.h
+  hwasan_poisoning.h
+  hwasan_report.h
+  hwasan_thread.h)
+
 
 set(HWASAN_RTL_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 append_rtti_flag(OFF HWASAN_RTL_CFLAGS)
 append_list_if(COMPILER_RT_HAS_FPIC_FLAG -fPIC HWASAN_RTL_CFLAGS)
 # Prevent clang from generating libc calls.
 append_list_if(COMPILER_RT_HAS_FFREESTANDING_FLAG -ffreestanding HWASAN_RTL_CFLAGS)
 
 set(HWASAN_DYNAMIC_LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS})

 append_list_if(COMPILER_RT_HAS_LIBPTHREAD pthread HWASAN_DYNAMIC_LIBS)
 append_list_if(COMPILER_RT_HAS_LIBLOG log HWASAN_DYNAMIC_LIBS)
 
 # Static runtime library.
 add_compiler_rt_component(hwasan)
 
 add_compiler_rt_object_libraries(RTHwasan
   ARCHS ${HWASAN_SUPPORTED_ARCH}
-  SOURCES ${HWASAN_RTL_SOURCES} CFLAGS ${HWASAN_RTL_CFLAGS})
+  SOURCES ${HWASAN_RTL_SOURCES}
+  ADDITIONAL_HEADERS ${HWASAN_RTL_HEADERS}
+  CFLAGS ${HWASAN_RTL_CFLAGS})
 add_compiler_rt_object_libraries(RTHwasan_cxx
   ARCHS ${HWASAN_SUPPORTED_ARCH}
-  SOURCES ${HWASAN_RTL_CXX_SOURCES} CFLAGS ${HWASAN_RTL_CFLAGS})
+  SOURCES ${HWASAN_RTL_CXX_SOURCES}
+  ADDITIONAL_HEADERS ${HWASAN_RTL_HEADERS}
+  CFLAGS ${HWASAN_RTL_CFLAGS})
 add_compiler_rt_object_libraries(RTHwasan_dynamic
   ARCHS ${HWASAN_SUPPORTED_ARCH}
+  # FIXME: Typo? Probably should be HWASAN_RTL_CXX_SOURCES
   SOURCES ${HWASAN_RTL_SOURCES} ${TSAN_RTL_CXX_SOURCES}
+  ADDITIONAL_HEADERS ${HWASAN_RTL_HEADERS}
   CFLAGS ${HWASAN_DYNAMIC_CFLAGS})
 
 file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/dummy.cc "")
 add_compiler_rt_object_libraries(RTHwasan_dynamic_version_script_dummy
   ARCHS ${HWASAN_SUPPORTED_ARCH}
   SOURCES ${CMAKE_CURRENT_BINARY_DIR}/dummy.cc
   CFLAGS ${HWASAN_DYNAMIC_CFLAGS})
 

lib/interception/CMakeLists.txt

 # Build for the runtime interception helper library.
 
 set(INTERCEPTION_SOURCES
   interception_linux.cc
   interception_mac.cc
   interception_win.cc
-  interception_type_test.cc
-  )
+  interception_type_test.cc)
+
+set(INTERCEPTION_HEADERS
+  interception.h
+  interception_linux.h
+  interception_mac.h
+  interception_win.h)
 
 include_directories(..)
 
 set(INTERCEPTION_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 append_rtti_flag(OFF INTERCEPTION_CFLAGS)
 
 add_compiler_rt_object_libraries(RTInterception
     OS ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
     SOURCES ${INTERCEPTION_SOURCES}
+    ADDITIONAL_HEADERS ${INTERCEPTION_HEADERS}
     CFLAGS ${INTERCEPTION_CFLAGS})
 
 if(COMPILER_RT_INCLUDE_TESTS)
   add_subdirectory(tests)
 endif()

lib/lsan/CMakeLists.txt

set(LSAN_SOURCES
   lsan_allocator.cc
   lsan_linux.cc
   lsan_interceptors.cc
   lsan_mac.cc
   lsan_malloc_mac.cc
   lsan_preinit.cc
   lsan_thread.cc)
 
+set(LSAN_HEADERS
+  lsan.h
+  lsan_allocator.h
+  lsan_common.h
+  lsan_flags.inc
+  lsan_thread.h)
+
 set(LSAN_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 add_compiler_rt_object_libraries(RTLSanCommon
     OS ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${LSAN_COMMON_SUPPORTED_ARCH}
     SOURCES ${LSAN_COMMON_SOURCES}
+    ADDITIONAL_HEADERS ${LSAN_HEADERS}
     CFLAGS ${LSAN_CFLAGS})
 
 if(COMPILER_RT_HAS_LSAN)
   add_compiler_rt_component(lsan)
   if(APPLE)
     set(LSAN_LINK_LIBS ${SANITIZER_COMMON_LINK_LIBS})
 
     add_weak_symbols("lsan" WEAK_SYMBOL_LINK_FLAGS)
     add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
 
     add_compiler_rt_runtime(clang_rt.lsan
       SHARED
       OS ${SANITIZER_COMMON_SUPPORTED_OS}
       ARCHS ${LSAN_SUPPORTED_ARCH}
       SOURCES ${LSAN_SOURCES}
+      ADDITIONAL_HEADERS ${LSAN_HEADERS}
       OBJECT_LIBS RTLSanCommon
                   RTInterception
                   RTSanitizerCommon
                   RTSanitizerCommonLibc
                   RTSanitizerCommonCoverage
                   RTSanitizerCommonSymbolizer
       CFLAGS ${LSAN_CFLAGS}
       LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS}
       LINK_LIBS ${LSAN_LINK_LIBS}
       PARENT_TARGET lsan)
   else()
     foreach(arch ${LSAN_SUPPORTED_ARCH})
       add_compiler_rt_runtime(clang_rt.lsan
         STATIC
         ARCHS ${arch}
         SOURCES ${LSAN_SOURCES}
                 $<TARGET_OBJECTS:RTInterception.${arch}>
                 $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
                 $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
                 $<TARGET_OBJECTS:RTSanitizerCommonCoverage.${arch}>
                 $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.${arch}>
                 $<TARGET_OBJECTS:RTLSanCommon.${arch}>
+        ADDITIONAL_HEADERS ${LSAN_HEADERS}
         CFLAGS ${LSAN_CFLAGS}
         PARENT_TARGET lsan)
     endforeach()
   endif()
 endif()

lib/msan/CMakeLists.txt

set(MSAN_RTL_SOURCES
   msan_report.cc
   msan_thread.cc
   msan_poisoning.cc
   )
 
 set(MSAN_RTL_CXX_SOURCES
   msan_new_delete.cc)
 
+set(MSAN_RTL_HEADERS
+  msan.h
+  msan_allocator.h
+  msan_chained_origin_depot.h
+  msan_flags.h
+  msan_flags.inc
+  msan_interface_internal.h
+  msan_origin.h
+  msan_poisoning.h
+  msan_report.h
+  msan_thread.h)
 
 set(MSAN_RTL_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
   append_list_if(COMPILER_RT_HAS_FTLS_MODEL_INITIAL_EXEC -ftls-model=initial-exec MSAN_RTL_CFLAGS)
 endif()
 append_rtti_flag(OFF MSAN_RTL_CFLAGS)
 if(NOT CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
   append_list_if(COMPILER_RT_HAS_FPIE_FLAG -fPIE MSAN_RTL_CFLAGS)
add_compiler_rt_runtime(clang_rt.msan
     ARCHS ${arch}
     SOURCES ${MSAN_RTL_SOURCES}
             $<TARGET_OBJECTS:RTInterception.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonCoverage.${arch}>
             $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.${arch}>
             $<TARGET_OBJECTS:RTUbsan.${arch}>
+    ADDITIONAL_HEADERS ${MSAN_RTL_HEADERS}
     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}>
+    ADDITIONAL_HEADERS ${MSAN_RTL_HEADERS}
     CFLAGS ${MSAN_RTL_CFLAGS}
     PARENT_TARGET msan)
   list(APPEND MSAN_RUNTIME_LIBRARIES clang_rt.msan-${arch}
                                      clang_rt.msan_cxx-${arch})
   if(SANITIZER_USE_SYMBOLS)
     add_sanitizer_rt_symbols(clang_rt.msan
       ARCHS ${arch}
       EXTRA msan.syms.extra)

lib/profile/CMakeLists.txt

set(PROFILE_SOURCES
   InstrProfilingNameVar.c
   InstrProfilingWriter.c
   InstrProfilingPlatformDarwin.c
   InstrProfilingPlatformLinux.c
   InstrProfilingPlatformOther.c
   InstrProfilingRuntime.cc
   InstrProfilingUtil.c)
 
+set(PROFILE_HEADERS
+  InstrProfData.inc
+  InstrProfiling.h
+  InstrProfilingInternal.h
+  InstrProfilingPort.h
+  InstrProfilingUtil.h
+  WindowsMMap.h)
+
 if(WIN32)
     list(APPEND PROFILE_SOURCES WindowsMMap.c)
 endif()
 
 if(FUCHSIA OR UNIX)
  set(EXTRA_FLAGS
      -fPIC
      -Wno-pedantic)

 
 if(APPLE)
   add_compiler_rt_runtime(clang_rt.profile
     STATIC
     OS ${PROFILE_SUPPORTED_OS}
     ARCHS ${PROFILE_SUPPORTED_ARCH}
     CFLAGS ${EXTRA_FLAGS}
     SOURCES ${PROFILE_SOURCES}
+    ADDITIONAL_HEADERS ${PROFILE_HEADERS}
     PARENT_TARGET profile)
 else()
   add_compiler_rt_runtime(clang_rt.profile
     STATIC
     ARCHS ${PROFILE_SUPPORTED_ARCH}
     CFLAGS ${EXTRA_FLAGS}
     SOURCES ${PROFILE_SOURCES}
+    ADDITIONAL_HEADERS ${PROFILE_HEADERS}
     PARENT_TARGET profile)
 endif()

lib/sanitizer_common/CMakeLists.txt

set(SANITIZER_SYMBOLIZER_SOURCES
   sanitizer_symbolizer_win.cc
   sanitizer_unwind_linux_libcdep.cc
   sanitizer_unwind_win.cc)
 
 # Explicitly list all sanitizer_common headers. Not all of these are
 # included in sanitizer_common source files, but we need to depend on
 # headers when building our custom unit tests.
 set(SANITIZER_HEADERS
+  sancov_flags.h
+  sancov_flags.inc
   sanitizer_addrhashmap.h
   sanitizer_allocator.h
   sanitizer_allocator_bytemap.h
+  sanitizer_allocator_checks.h
   sanitizer_allocator_combined.h
   sanitizer_allocator_interface.h
   sanitizer_allocator_internal.h
   sanitizer_allocator_local_cache.h
   sanitizer_allocator_primary32.h
   sanitizer_allocator_primary64.h
   sanitizer_allocator_report.h
   sanitizer_allocator_secondary.h
   sanitizer_allocator_size_class_map.h
   sanitizer_allocator_stats.h
+  sanitizer_asm.h
   sanitizer_atomic.h
   sanitizer_atomic_clang.h
+  sanitizer_atomic_clang_mips.h
+  sanitizer_atomic_clang_other.h
+  sanitizer_atomic_clang_x86.h
   sanitizer_atomic_msvc.h
   sanitizer_bitvector.h
   sanitizer_bvgraph.h
   sanitizer_common.h
   sanitizer_common_interceptors.inc
-  sanitizer_common_interceptors_ioctl.inc
   sanitizer_common_interceptors_format.inc
+  sanitizer_common_interceptors_ioctl.inc
+  sanitizer_common_interface.inc
+  sanitizer_common_interface_posix.inc
   sanitizer_common_syscalls.inc
+  sanitizer_coverage_interface.inc
+  sanitizer_dbghelp.h
   sanitizer_deadlock_detector.h
   sanitizer_deadlock_detector_interface.h
   sanitizer_errno.h
   sanitizer_errno_codes.h
   sanitizer_file.h
   sanitizer_flag_parser.h
   sanitizer_flags.h
   sanitizer_flags.inc
+  sanitizer_freebsd.h
   sanitizer_fuchsia.h
+  sanitizer_getauxval.h
   sanitizer_interceptors_ioctl_netbsd.inc
   sanitizer_interface_internal.h
   sanitizer_internal_defs.h
   sanitizer_lfstack.h
   sanitizer_libc.h
   sanitizer_libignore.h
   sanitizer_linux.h
   sanitizer_list.h
   sanitizer_mac.h
+  sanitizer_malloc_mac.inc
   sanitizer_mutex.h
   sanitizer_persistent_allocator.h
   sanitizer_placement_new.h
   sanitizer_platform.h
   sanitizer_platform_interceptors.h
   sanitizer_platform_limits_netbsd.h
+  sanitizer_platform_limits_openbsd.h
   sanitizer_platform_limits_posix.h
   sanitizer_platform_limits_solaris.h
   sanitizer_posix.h
   sanitizer_procmaps.h
   sanitizer_quarantine.h
   sanitizer_report_decorator.h
   sanitizer_rtems.h
+  sanitizer_signal_interceptors.inc
   sanitizer_stackdepot.h
   sanitizer_stackdepotbase.h
   sanitizer_stacktrace.h
   sanitizer_stacktrace_printer.h
   sanitizer_stoptheworld.h
   sanitizer_suppressions.h
   sanitizer_symbolizer.h
   sanitizer_symbolizer_fuchsia.h
   sanitizer_symbolizer_internal.h
   sanitizer_symbolizer_libbacktrace.h
   sanitizer_symbolizer_mac.h
   sanitizer_symbolizer_rtems.h
   sanitizer_syscall_generic.inc
-  sanitizer_syscall_linux_x86_64.inc
   sanitizer_syscall_linux_aarch64.inc
+  sanitizer_syscall_linux_arm.inc
+  sanitizer_syscall_linux_x86_64.inc
   sanitizer_syscalls_netbsd.inc
   sanitizer_thread_registry.h
+  sanitizer_tls_get_addr.h
   sanitizer_vector.h
-  sanitizer_win.h)
+  sanitizer_win.h
+  sanitizer_win_defs.h
+  sanitizer_win_dll_thunk.h
+  sanitizer_win_weak_interception.h)
 
 include_directories(..)
 
 set(SANITIZER_COMMON_DEFINITIONS)
 
 include(CheckIncludeFile)
 append_have_file_definition(rpc/xdr.h HAVE_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS)
 append_have_file_definition(tirpc/rpc/xdr.h HAVE_TIRPC_RPC_XDR_H SANITIZER_COMMON_DEFINITIONS)

 if(APPLE)
   set(OS_OPTION OS ${SANITIZER_COMMON_SUPPORTED_OS})
 endif()
 
 add_compiler_rt_object_libraries(RTSanitizerCommon
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_SOURCES}
+  ADDITIONAL_HEADERS ${SANITIZER_HEADERS}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonNoTermination
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_SOURCES_NOTERMINATION}
+  ADDITIONAL_HEADERS ${SANITIZER_HEADERS}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonNoLibc
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_NOLIBC_SOURCES}
+  ADDITIONAL_HEADERS ${SANITIZER_HEADERS}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonLibc
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_LIBCDEP_SOURCES}
+  ADDITIONAL_HEADERS ${SANITIZER_HEADERS}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonCoverage
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_COVERAGE_SOURCES}
+  ADDITIONAL_HEADERS ${SANITIZER_HEADERS}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonSymbolizer
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_SYMBOLIZER_SOURCES}
+  ADDITIONAL_HEADERS ${SANITIZER_HEADERS}
   CFLAGS ${SANITIZER_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 
 set(SANITIZER_NO_WEAK_HOOKS_CFLAGS ${SANITIZER_CFLAGS})
 list(APPEND SANITIZER_NO_WEAK_HOOKS_CFLAGS "-DSANITIZER_SUPPORTS_WEAK_HOOKS=0")
 add_compiler_rt_object_libraries(RTSanitizerCommonNoHooks
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_SOURCES}
+  ADDITIONAL_HEADERS ${SANITIZER_HEADERS}
   CFLAGS ${SANITIZER_NO_WEAK_HOOKS_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonLibcNoHooks
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_LIBCDEP_SOURCES}
+  ADDITIONAL_HEADERS ${SANITIZER_HEADERS}
   CFLAGS ${SANITIZER_NO_WEAK_HOOKS_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 add_compiler_rt_object_libraries(RTSanitizerCommonSymbolizerNoHooks
   ${OS_OPTION}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   SOURCES ${SANITIZER_SYMBOLIZER_SOURCES}
+  ADDITIONAL_HEADERS ${SANITIZER_HEADERS}
   CFLAGS ${SANITIZER_NO_WEAK_HOOKS_CFLAGS}
   DEFS ${SANITIZER_COMMON_DEFINITIONS})
 
 if(OS_NAME MATCHES "SunOS")
   # Solaris ld doesn't support the non-standard GNU ld extension of adding
   # __start_SECNAME and __stop_SECNAME labels to sections whose names are
   # valid C identifiers.  Instead we add our own definitions for the
   # __sancov_guards section.

lib/scudo/CMakeLists.txt

set(SCUDO_SOURCES
   scudo_termination.cpp
   scudo_tsd_exclusive.cpp
   scudo_tsd_shared.cpp
   scudo_utils.cpp)
 
 set(SCUDO_CXX_SOURCES
   scudo_new_delete.cpp)
 
+set(SCUDO_HEADERS
+  scudo_allocator.h
+  scudo_allocator_combined.h
+  scudo_allocator_secondary.h
+  scudo_crc32.h
+  scudo_errors.h
+  scudo_flags.h
+  scudo_flags.inc
+  scudo_interface_internal.h
+  scudo_platform.h
+  scudo_tsd.h
+  scudo_tsd_exclusive.inc
+  scudo_tsd_shared.inc
+  scudo_utils.h)
+
 # Enable the SSE 4.2 instruction set for scudo_crc32.cpp, if available.
 if (COMPILER_RT_HAS_MSSE4_2_FLAG)
   set_source_files_properties(scudo_crc32.cpp PROPERTIES COMPILE_FLAGS -msse4.2)
 endif()
 
 # Enable the AArch64 CRC32 feature for scudo_crc32.cpp, if available.
 # Note that it is enabled by default starting with armv8.1-a.
 if (COMPILER_RT_HAS_MCRC_FLAG)
   set_source_files_properties(scudo_crc32.cpp PROPERTIES COMPILE_FLAGS -mcrc)
 endif()
 
 if(COMPILER_RT_HAS_SCUDO)
   add_compiler_rt_runtime(clang_rt.scudo_minimal
     STATIC
     ARCHS ${SCUDO_SUPPORTED_ARCH}
     SOURCES ${SCUDO_SOURCES}
+    ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     OBJECT_LIBS ${SCUDO_MINIMAL_OBJECT_LIBS}
     CFLAGS ${SCUDO_CFLAGS}
     PARENT_TARGET scudo)
   add_compiler_rt_runtime(clang_rt.scudo_cxx_minimal
     STATIC
     ARCHS ${SCUDO_SUPPORTED_ARCH}
     SOURCES ${SCUDO_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     CFLAGS ${SCUDO_CFLAGS}
     PARENT_TARGET scudo)
 
   add_compiler_rt_runtime(clang_rt.scudo
     STATIC
     ARCHS ${SCUDO_SUPPORTED_ARCH}
     SOURCES ${SCUDO_SOURCES}
+    ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     OBJECT_LIBS ${SCUDO_OBJECT_LIBS}
     CFLAGS ${SCUDO_CFLAGS}
     PARENT_TARGET scudo)
   add_compiler_rt_runtime(clang_rt.scudo_cxx
     STATIC
     ARCHS ${SCUDO_SUPPORTED_ARCH}
     SOURCES ${SCUDO_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     OBJECT_LIBS RTUbsan_cxx
     CFLAGS ${SCUDO_CFLAGS}
     PARENT_TARGET scudo)
 
   add_compiler_rt_runtime(clang_rt.scudo_minimal
     SHARED
     ARCHS ${SCUDO_SUPPORTED_ARCH}
     SOURCES ${SCUDO_SOURCES} ${SCUDO_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     OBJECT_LIBS ${SCUDO_MINIMAL_OBJECT_LIBS}
     CFLAGS ${SCUDO_CFLAGS}
     LINK_FLAGS ${SCUDO_DYNAMIC_LINK_FLAGS}
     LINK_LIBS ${SCUDO_MINIMAL_DYNAMIC_LIBS}
     PARENT_TARGET scudo)
 
   add_compiler_rt_runtime(clang_rt.scudo
     SHARED
     ARCHS ${SCUDO_SUPPORTED_ARCH}
     SOURCES ${SCUDO_SOURCES} ${SCUDO_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     OBJECT_LIBS ${SCUDO_OBJECT_LIBS}
     CFLAGS ${SCUDO_CFLAGS}
     LINK_FLAGS ${SCUDO_DYNAMIC_LINK_FLAGS}
     LINK_LIBS ${SCUDO_DYNAMIC_LIBS}
     PARENT_TARGET scudo)
 endif()

lib/stats/CMakeLists.txt

+set(STATS_HEADERS
+  stats.h)
+
 include_directories(..)
 
 add_custom_target(stats)
 set_target_properties(stats PROPERTIES FOLDER "Compiler-RT Misc")
 
 if(APPLE)
   set(STATS_LIB_FLAVOR SHARED)
 
   set(STATS_LINK_LIBS ${SANITIZER_COMMON_LINK_LIBS})
 
   add_weak_symbols("asan" WEAK_SYMBOL_LINK_FLAGS)
   add_weak_symbols("ubsan" WEAK_SYMBOL_LINK_FLAGS)
   add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
 else()
   set(STATS_LIB_FLAVOR STATIC)
 
   set(WEAK_SYMBOL_LINK_FLAGS)
 endif()
 
 add_compiler_rt_runtime(clang_rt.stats
   ${STATS_LIB_FLAVOR}
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   OS ${SANITIZER_COMMON_SUPPORTED_OS}
   SOURCES stats.cc
+  ADDITIONAL_HEADERS ${STATS_HEADERS}
   OBJECT_LIBS RTSanitizerCommon
               RTSanitizerCommonLibc
               RTSanitizerCommonSymbolizer
   CFLAGS ${SANITIZER_COMMON_CFLAGS}
   LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS}
   LINK_LIBS ${STATS_LINK_LIBS}
   PARENT_TARGET stats)
 
 add_compiler_rt_runtime(clang_rt.stats_client
   STATIC
   ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH}
   OS ${SANITIZER_COMMON_SUPPORTED_OS}
   SOURCES stats_client.cc
+  ADDITIONAL_HEADERS ${STATS_HEADERS}
   CFLAGS ${SANITIZER_COMMON_CFLAGS}
   LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
   PARENT_TARGET stats)

lib/tsan/CMakeLists.txt

set(TSAN_HEADERS
   rtl/tsan_clock.h
   rtl/tsan_defs.h
   rtl/tsan_dense_alloc.h
   rtl/tsan_fd.h
   rtl/tsan_flags.h
   rtl/tsan_flags.inc
   rtl/tsan_ignoreset.h
   rtl/tsan_interceptors.h
-  rtl/tsan_interface_ann.h
   rtl/tsan_interface.h
+  rtl/tsan_interface_ann.h
   rtl/tsan_interface_inl.h
   rtl/tsan_interface_java.h
   rtl/tsan_mman.h
   rtl/tsan_mutex.h
   rtl/tsan_mutexset.h
   rtl/tsan_platform.h
+  rtl/tsan_ppc_regs.h
   rtl/tsan_report.h
   rtl/tsan_rtl.h
   rtl/tsan_stack_trace.h
   rtl/tsan_stat.h
   rtl/tsan_suppressions.h
   rtl/tsan_symbolize.h
   rtl/tsan_sync.h
   rtl/tsan_trace.h
if(APPLE)
   add_weak_symbols("ubsan" WEAK_SYMBOL_LINK_FLAGS)
   add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
 
   add_compiler_rt_runtime(clang_rt.tsan
     SHARED
     OS ${TSAN_SUPPORTED_OS}
     ARCHS ${TSAN_SUPPORTED_ARCH}
     SOURCES ${TSAN_SOURCES} ${TSAN_CXX_SOURCES} ${TSAN_ASM_SOURCES}
+    ADDITIONAL_HEADERS ${TSAN_HEADERS}
     OBJECT_LIBS RTInterception
                 RTSanitizerCommon
                 RTSanitizerCommonLibc
                 RTSanitizerCommonCoverage
                 RTSanitizerCommonSymbolizer
                 RTUbsan
     CFLAGS ${TSAN_RTL_CFLAGS}
     LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS}
     LINK_LIBS ${TSAN_LINK_LIBS} objc
     PARENT_TARGET tsan)
   add_compiler_rt_object_libraries(RTTsan_dynamic
     OS ${TSAN_SUPPORTED_OS}
     ARCHS ${TSAN_SUPPORTED_ARCH}
     SOURCES ${TSAN_SOURCES} ${TSAN_CXX_SOURCES} ${TSAN_ASM_SOURCES}
+    ADDITIONAL_HEADERS ${TSAN_HEADERS}
     CFLAGS ${TSAN_RTL_CFLAGS})
 
   # Build and check Go runtime.
   set(BUILDGO_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/go/buildgo.sh)
   add_custom_target(GotsanRuntimeCheck
     COMMAND env "CC=${CMAKE_C_COMPILER} ${OSX_SYSROOT_FLAG}"
             IN_TMPDIR=1 SILENT=1 ${BUILDGO_SCRIPT}
     DEPENDS tsan ${BUILDGO_SCRIPT}
add_compiler_rt_runtime(clang_rt.tsan
       ARCHS ${arch}
       SOURCES ${TSAN_SOURCES} ${TSAN_ASM_SOURCES}
               $<TARGET_OBJECTS:RTInterception.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonCoverage.${arch}>
               $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.${arch}>
               $<TARGET_OBJECTS:RTUbsan.${arch}>
+      ADDITIONAL_HEADERS ${TSAN_HEADERS}
       CFLAGS ${TSAN_RTL_CFLAGS}
       PARENT_TARGET tsan)
     add_compiler_rt_runtime(clang_rt.tsan_cxx
       STATIC
       ARCHS ${arch}
       SOURCES ${TSAN_CXX_SOURCES}
               $<TARGET_OBJECTS:RTUbsan_cxx.${arch}>
+      ADDITIONAL_HEADERS ${TSAN_HEADERS}
       CFLAGS ${TSAN_RTL_CFLAGS}
       PARENT_TARGET tsan)
     list(APPEND TSAN_RUNTIME_LIBRARIES clang_rt.tsan-${arch}
                                        clang_rt.tsan_cxx-${arch})
     add_sanitizer_rt_symbols(clang_rt.tsan
       ARCHS ${arch}
       EXTRA rtl/tsan.syms.extra)
     add_sanitizer_rt_symbols(clang_rt.tsan_cxx

lib/ubsan/CMakeLists.txt

 # Build for the undefined behavior sanitizer runtime support library.
 
 set(UBSAN_SOURCES
   ubsan_diag.cc
   ubsan_init.cc
   ubsan_flags.cc
   ubsan_handlers.cc
   ubsan_monitor.cc
-  ubsan_value.cc
-  )
+  ubsan_value.cc)
 
 set(UBSAN_STANDALONE_SOURCES
   ubsan_diag_standalone.cc
   ubsan_init_standalone.cc
-  ubsan_signals_standalone.cc
-  )
+  ubsan_signals_standalone.cc)
 
 set(UBSAN_CXXABI_SOURCES
   ubsan_handlers_cxx.cc
   ubsan_type_hash.cc
   ubsan_type_hash_itanium.cc
-  ubsan_type_hash_win.cc
-  )
+  ubsan_type_hash_win.cc)
+
+set(UBSAN_HEADERS
+  ubsan_checks.inc
+  ubsan_diag.h
+  ubsan_flags.h
+  ubsan_flags.inc
+  ubsan_handlers.h
+  ubsan_handlers_cxx.h
+  ubsan_init.h
+  ubsan_interface.inc
+  ubsan_monitor.h
+  ubsan_platform.h
+  ubsan_signals_standalone.h
+  ubsan_type_hash.h
+  ubsan_value.h
 
 include_directories(..)
 
 set(UBSAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 append_rtti_flag(OFF UBSAN_CFLAGS)
 append_list_if(SANITIZER_CAN_USE_CXXABI -DUBSAN_CAN_USE_CXXABI UBSAN_CFLAGS)
 
 set(UBSAN_STANDALONE_CFLAGS ${SANITIZER_COMMON_CFLAGS})
if(SANITIZER_CAN_USE_CXXABI)
     list(APPEND UBSAN_COMMON_SOURCES ${UBSAN_CXXABI_SOURCES})
   endif()
 
   # Common parts of UBSan runtime.
   add_compiler_rt_object_libraries(RTUbsan
     OS ${SANITIZER_COMMON_SUPPORTED_OS}
     ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
     SOURCES ${UBSAN_COMMON_SOURCES}
+    ADDITIONAL_HEADERS ${UBSAN_HEADERS}
     CFLAGS ${UBSAN_CXXFLAGS})
 
   if(COMPILER_RT_HAS_UBSAN)
     # Initializer of standalone UBSan runtime.
     add_compiler_rt_object_libraries(RTUbsan_standalone
       OS ${SANITIZER_COMMON_SUPPORTED_OS}
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       SOURCES ${UBSAN_STANDALONE_SOURCES}
+      ADDITIONAL_HEADERS ${UBSAN_HEADERS}
       CFLAGS ${UBSAN_STANDALONE_CFLAGS})
 
     add_weak_symbols("ubsan" WEAK_SYMBOL_LINK_FLAGS)
     add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
 
     add_compiler_rt_runtime(clang_rt.ubsan
       SHARED
       OS ${SANITIZER_COMMON_SUPPORTED_OS}
add_compiler_rt_runtime(clang_rt.ubsan
       LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
       PARENT_TARGET ubsan)
   endif()
 
 else()
   # Common parts of UBSan runtime.
   add_compiler_rt_object_libraries(RTUbsan
     ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
-    SOURCES ${UBSAN_SOURCES} CFLAGS ${UBSAN_CFLAGS})
+    SOURCES ${UBSAN_SOURCES}
+    ADDITIONAL_HEADERS ${UBSAN_HEADERS}
+    CFLAGS ${UBSAN_CFLAGS})
 
   if(SANITIZER_CAN_USE_CXXABI)
     # C++-specific parts of UBSan runtime. Requires a C++ ABI library.
     set(UBSAN_CXX_SOURCES ${UBSAN_CXXABI_SOURCES})
   else()
     # Dummy target if we don't have C++ ABI library.
     file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/cxx_dummy.cc "")
     set(UBSAN_CXX_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/cxx_dummy.cc)
   endif()
 
   add_compiler_rt_object_libraries(RTUbsan_cxx
     ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
-    SOURCES ${UBSAN_CXX_SOURCES} CFLAGS ${UBSAN_CXXFLAGS})
+    SOURCES ${UBSAN_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${UBSAN_HEADERS}
+    CFLAGS ${UBSAN_CXXFLAGS})
 
   if (WIN32)
     add_compiler_rt_object_libraries(UbsanWeakInterception
       ${SANITIZER_COMMON_SUPPORTED_OS}
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       SOURCES ubsan_win_weak_interception.cc
       CFLAGS ${UBSAN_CFLAGS} -DSANITIZER_DYNAMIC
       DEFS ${UBSAN_COMMON_DEFINITIONS})
add_compiler_rt_object_libraries(UbsanDynamicRuntimeThunk
       CFLAGS ${UBSAN_CFLAGS} ${DYNAMIC_RUNTIME_THUNK_CFLAGS}
       DEFS ${UBSAN_COMMON_DEFINITIONS})
   endif()
 
   if(COMPILER_RT_HAS_UBSAN)
     add_compiler_rt_object_libraries(RTUbsan_standalone
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       SOURCES ${UBSAN_STANDALONE_SOURCES}
+      ADDITIONAL_HEADERS ${UBSAN_HEADERS}
       CFLAGS ${UBSAN_STANDALONE_CFLAGS})
 
     # Standalone UBSan runtimes.
     add_compiler_rt_runtime(clang_rt.ubsan_standalone
       STATIC
       ARCHS ${UBSAN_SUPPORTED_ARCH}
       SOURCES ubsan_init_standalone_preinit.cc
+      ADDITIONAL_HEADERS ${UBSAN_HEADERS}
       OBJECT_LIBS RTSanitizerCommon
               RTSanitizerCommonLibc
               RTSanitizerCommonCoverage
               RTSanitizerCommonSymbolizer
               RTUbsan
               RTUbsan_standalone
               RTInterception
       CFLAGS ${UBSAN_CFLAGS}

lib/xray/CMakeLists.txt

set(mips64el_SOURCES
     xray_mips64.cc
     xray_trampoline_mips64.S)
 
 set(powerpc64le_SOURCES
     xray_powerpc64.cc
     xray_trampoline_powerpc64.cc
     xray_trampoline_powerpc64_asm.S)
 
+set(XRAY_HEADERS
+  xray_allocator.h
+  xray_basic_flags.h
+  xray_basic_flags.inc
+  xray_basic_logging.h
+  xray_buffer_queue.h
+  xray_defs.h
+  xray_fdr_flags.h
+  xray_fdr_flags.inc
+  xray_fdr_log_records.h
+  xray_fdr_logging.h
+  xray_flags.h
+  xray_flags.inc
+  xray_function_call_trie.h
+  xray_interface_internal.h
+  xray_powerpc64.inc
+  xray_profile_collector.h
+  xray_profiling_flags.h
+  xray_profiling_flags.inc
+  xray_recursion_guard.h
+  xray_segmented_array.h
+  xray_tsc.h
+  xray_utils.h
+  xray_x86_64.inc)
+
 # Now put it all together...
 include_directories(..)
 include_directories(../../include)
 
 set(XRAY_CFLAGS ${SANITIZER_COMMON_CFLAGS})
 set(XRAY_COMMON_DEFINITIONS XRAY_HAS_EXCEPTIONS=1)
 
 # We don't need RTTI in XRay, so turn that off.
if (APPLE)
 
   add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
   add_weak_symbols("xray" WEAK_SYMBOL_LINK_FLAGS)
 
   add_compiler_rt_object_libraries(RTXray
     OS ${XRAY_SUPPORTED_OS}
     ARCHS ${XRAY_SUPPORTED_ARCH}
     SOURCES ${x86_64_SOURCES}
+    ADDITIONAL_HEADERS ${XRAY_HEADERS}
     CFLAGS ${XRAY_CFLAGS}
     DEFS ${XRAY_COMMON_DEFINITIONS}
     DEPS ${XRAY_DEPS})
   add_compiler_rt_object_libraries(RTXrayFDR
     OS ${XRAY_SUPPORTED_OS}
     ARCHS ${XRAY_SUPPORTED_ARCH}
     SOURCES ${XRAY_FDR_MODE_SOURCES}
+    ADDITIONAL_HEADERS ${XRAY_HEADERS}
     CFLAGS ${XRAY_CFLAGS}
     DEFS ${XRAY_COMMON_DEFINITIONS}
     DEPS ${XRAY_DEPS})
   add_compiler_rt_object_libraries(RTXrayBASIC
     OS ${XRAY_SUPPORTED_OS}
     ARCHS ${XRAY_SUPPORTED_ARCH}
     SOURCES ${XRAY_BASIC_MODE_SOURCES}
+    ADDITIONAL_HEADERS ${XRAY_HEADERS}
     CFLAGS ${XRAY_CFLAGS}
     DEFS ${XRAY_COMMON_DEFINITIONS}
     DEPS ${XRAY_DEPS})
   add_compiler_rt_object_libraries(RTXrayPROFILING
     OS ${XRAY_SUPPORTED_OS}
     ARCHS ${XRAY_SUPPORTED_ARCH}
     SOURCES ${XRAY_PROFILING_MODE_SOURCES}
+    ADDITIONAL_HEADERS ${XRAY_HEADERS}
     CFLAGS ${XRAY_CFLAGS}
     DEFS ${XRAY_COMMON_DEFINITIONS}
     DEPS ${XRAY_DEPS})
 
   # We only support running on osx for now.
   add_compiler_rt_runtime(clang_rt.xray
     STATIC
     OS ${XRAY_SUPPORTED_OS}
add_compiler_rt_runtime(clang_rt.xray-profiling
     PARENT_TARGET xray)
 else() # not Apple
   foreach(arch ${XRAY_SUPPORTED_ARCH})
     if(NOT CAN_TARGET_${arch})
       continue()
     endif()
     add_compiler_rt_object_libraries(RTXray
       ARCHS ${arch}
-      SOURCES ${XRAY_SOURCES} ${${arch}_SOURCES} CFLAGS ${XRAY_CFLAGS}
+      SOURCES ${XRAY_SOURCES} ${${arch}_SOURCES}
+      ADDITIONAL_HEADERS ${XRAY_HEADERS}
+      CFLAGS ${XRAY_CFLAGS}
       DEFS ${XRAY_COMMON_DEFINITIONS}
       DEPS ${XRAY_DEPS})
     add_compiler_rt_object_libraries(RTXrayFDR
       ARCHS ${arch}
-      SOURCES ${XRAY_FDR_MODE_SOURCES} CFLAGS ${XRAY_CFLAGS}
+      SOURCES ${XRAY_FDR_MODE_SOURCES}
+      ADDITIONAL_HEADERS ${XRAY_HEADERS}
+      CFLAGS ${XRAY_CFLAGS}
       DEFS ${XRAY_COMMON_DEFINITIONS}
       DEPS ${XRAY_DEPS})
     add_compiler_rt_object_libraries(RTXrayBASIC
       ARCHS ${arch}
-      SOURCES ${XRAY_BASIC_MODE_SOURCES} CFLAGS ${XRAY_CFLAGS}
+      SOURCES ${XRAY_BASIC_MODE_SOURCES}
+      ADDITIONAL_HEADERS ${XRAY_HEADERS}
+      CFLAGS ${XRAY_CFLAGS}
       DEFS ${XRAY_COMMON_DEFINITIONS}
       DEPS ${XRAY_DEPS})
     add_compiler_rt_object_libraries(RTXrayPROFILING
       ARCHS ${arch}
-      SOURCES ${XRAY_PROFILING_MODE_SOURCES} CFLAGS ${XRAY_CFLAGS}
+      SOURCES ${XRAY_PROFILING_MODE_SOURCES}
+      ADDITIONAL_HEADERS ${XRAY_HEADERS}
+      CFLAGS ${XRAY_CFLAGS}
       DEFS ${XRAY_COMMON_DEFINITIONS}
       DEPS ${XRAY_DEPS})
 
     # Common XRay archive for instrumented binaries.
     add_compiler_rt_runtime(clang_rt.xray
      STATIC
      ARCHS ${arch}
      CFLAGS ${XRAY_CFLAGS}