Remove `clang/runtime`

[Ericson2314]

Summary

This patch removes clang/runtime, after COMPILER_RT_INSTALL_PATH is
removed in order to simplify things for D99484.

As @phosek said in https://reviews.llvm.org/D99484#2662806

I'm not sure if we still need COMPILER_RT_INSTALL_PATH. That
variable is only used by clang/runtime/CMakeLists.txt which
predates runtimes/CMakeLists.txt and was AFAIK only ever used by
Apple. I think we should consider removing
COMPILER_RT_INSTALL_PATH. We'll need to check if
clang/runtime/CMakeLists.txt is still being used or not.

It turns out COMPILER_RT_INSTALL_PATH isn't only used by that, but we
might (hopefully!) be able to remove it annyways. If so, clang/runtime
can still be removed, which is a simplification we might as well do if
@phosek is right that it is no longer in use.

[Ericson2314]

compiler-rt/cmake/base-config-ix.cmake

93

I'm a bit confused we'd ever want too install libs directly in ${CMAKE_INSTALL_PREFIX}, but that is technically the existing behavior, with the default value for COMPILER_RT_INSTALL_PATH, so I kept it.

[Ericson2314]

Also remove clang/runtime from a TODO comment elsewhere in the tree

I put runtimes in there as it's evidentially its spiritual successor.

[phosek]

@beanz do you know if clang/runtime is still being used?

[Ericson2314]

Remove add_subdirectory(runtime) for deleted dir

[Ericson2314]

So unfortunately it seems the clang/runtime's use was triggered by LLVM_BUILD_EXTERNAL_COMPILER_RT, which is in use in a few places still? (And not just Apple ones.)

On the other hand, since this is doing an *external* CMake for compiler-rt, I fail to see why COMPILER_RT_INSTALL_PATH is needed; why not just pass a different CMAKE_INSTALL_PREFIX?

[Ericson2314]

Remove stray COMPILER_RT_INSTALL_PATH

I am uncertain about is the redefining of CMAKE_INSTALL_PREIX in
compiler-rt/cmake/base-config-ix.cmake. This occurs under
LLVM_TREE_AVAILABLE. If this is just for separate compiler-rt builds
(separate invocation of CMake, that is), this is fine. But if on the other hand
this is for combination builds in a single CMake run, then this sort of
redefinition is no good as it will effect more than compiler-rt.

[Ericson2314]

See also D99860. We may still want to remove clang/runtime, but I don't think it's necessary. I will turn this revision into one on top of that just for for removing clang/runtime.

[Ericson2314]

Put on top of D99860

[Ericson2314]

D101497 is more safe/conservative and gets the job done to prepare for`GnuInstallDirs`. Closing in favor of that.

clang/CMakeLists.txt

 # header-wise on it as they ship all headers from the umbrella folders. Building
 # an entire module might include header, which depends on intrinsics_gen.
 if(LLVM_ENABLE_MODULES)
   list(APPEND LLVM_COMMON_DEPENDS intrinsics_gen)
 endif()
 
 add_subdirectory(lib)
 add_subdirectory(tools)
-add_subdirectory(runtime)
 
 option(CLANG_BUILD_EXAMPLES "Build CLANG example programs by default." OFF)
 add_subdirectory(examples)
 
 if(APPLE)
   # this line is needed as a cleanup to ensure that any CMakeCaches with the old
   # default value get updated to the new default.
   if(CLANG_ORDER_FILE STREQUAL "")

clang/runtime/CMakeLists.txt

-# TODO: Set the install directory.
-
-include(ExternalProject)
-
-set(known_subdirs
-  "libcxx"
-  )
-
-foreach (dir ${known_subdirs})
-  if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/CMakeLists.txt)
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${dir})
-  endif()
-endforeach()
-
-function(get_ext_project_build_command out_var target)
-  if (CMAKE_GENERATOR MATCHES "Make")
-    # Use special command for Makefiles to support parallelism.
-    set(${out_var} "$(MAKE)" "${target}" PARENT_SCOPE)
-  else()
-    set(${out_var} ${CMAKE_COMMAND} --build . --target ${target}
-                                    --config $<CONFIG> PARENT_SCOPE)
-  endif()
-endfunction()
-
-set(COMPILER_RT_SRC_ROOT ${LLVM_MAIN_SRC_DIR}/projects/compiler-rt)
-# Fallback to the external path, if the other one isn't available.
-# This is the same behavior (try "internal", then check the LLVM_EXTERNAL_...
-# variable) as in add_llvm_external_project
-if(NOT EXISTS ${COMPILER_RT_SRC_ROOT})
-  # We don't want to set it if LLVM_EXTERNAL_COMPILER_RT_SOURCE_DIR is ""
-  if(LLVM_EXTERNAL_COMPILER_RT_SOURCE_DIR)
-    set(COMPILER_RT_SRC_ROOT ${LLVM_EXTERNAL_COMPILER_RT_SOURCE_DIR})
-  endif()
-endif()
-
-if(LLVM_BUILD_EXTERNAL_COMPILER_RT AND EXISTS ${COMPILER_RT_SRC_ROOT}/)
-
-  # Add compiler-rt as an external project.
-  set(COMPILER_RT_PREFIX ${CMAKE_BINARY_DIR}/projects/compiler-rt)
-
-  set(STAMP_DIR ${CMAKE_CURRENT_BINARY_DIR}/compiler-rt-stamps/)
-  set(BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/compiler-rt-bins/)
-
-  add_custom_target(compiler-rt-clear
-    COMMAND ${CMAKE_COMMAND} -E remove_directory ${BINARY_DIR}
-    COMMAND ${CMAKE_COMMAND} -E remove_directory ${STAMP_DIR}
-    COMMENT "Clobberring compiler-rt build and stamp directories"
-    )
-
-  # Find all variables that start with COMPILER_RT and populate a variable with
-  # them.
-  get_cmake_property(variableNames VARIABLES)
-  foreach(variableName ${variableNames})
-    if(variableName MATCHES "^COMPILER_RT")
-      string(REPLACE ";" "\;" value "${${variableName}}")
-      list(APPEND COMPILER_RT_PASSTHROUGH_VARIABLES
-        -D${variableName}=${value})
-    endif()
-  endforeach()
-
-  set(compiler_rt_configure_deps)
-  if(TARGET cxx-headers)
-    list(APPEND compiler_rt_configure_deps "cxx-headers")
-  endif()
-  if(LLVM_INCLUDE_TESTS)
-    list(APPEND compiler_rt_configure_deps LLVMTestingSupport)
-  endif()
-
-  ExternalProject_Add(compiler-rt
-    DEPENDS llvm-config clang ${compiler_rt_configure_deps}
-    PREFIX ${COMPILER_RT_PREFIX}
-    SOURCE_DIR ${COMPILER_RT_SRC_ROOT}
-    STAMP_DIR ${STAMP_DIR}
-    BINARY_DIR ${BINARY_DIR}
-    CMAKE_ARGS ${CLANG_COMPILER_RT_CMAKE_ARGS}
-               -DCMAKE_C_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang
-               -DCMAKE_CXX_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++
-               -DCMAKE_ASM_COMPILER=${LLVM_RUNTIME_OUTPUT_INTDIR}/clang
-               -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-               -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
-               -DLLVM_CONFIG_PATH=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-config
-               -DLLVM_LIT_ARGS=${LLVM_LIT_ARGS}
-               -DCOMPILER_RT_OUTPUT_DIR=${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION}
-               -DCOMPILER_RT_EXEC_OUTPUT_DIR=${LLVM_RUNTIME_OUTPUT_INTDIR}
-               -DCOMPILER_RT_INSTALL_PATH:STRING=lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}
-               -DCOMPILER_RT_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
-               -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
-               -DLLVM_LIBDIR_SUFFIX=${LLVM_LIBDIR_SUFFIX}
-               -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_RUNTIME_OUTPUT_INTDIR}
-               -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}
-               -DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT}
-               ${COMPILER_RT_PASSTHROUGH_VARIABLES}
-    INSTALL_COMMAND ""
-    STEP_TARGETS configure build
-    USES_TERMINAL_CONFIGURE 1
-    USES_TERMINAL_BUILD 1
-    USES_TERMINAL_INSTALL 1
-    # Always run the build command so that incremental builds are correct.
-    BUILD_ALWAYS 1
-    )
-
-  get_ext_project_build_command(run_clean_compiler_rt clean)
-  ExternalProject_Add_Step(compiler-rt clean
-    COMMAND ${run_clean_compiler_rt}
-    COMMENT "Cleaning compiler-rt..."
-    DEPENDEES configure
-    DEPENDERS build
-    DEPENDS clang
-    WORKING_DIRECTORY ${BINARY_DIR}
-    )
-
-  install(CODE "execute_process\(COMMAND \${CMAKE_COMMAND} -DCMAKE_INSTALL_PREFIX=\${CMAKE_INSTALL_PREFIX} -P ${BINARY_DIR}/cmake_install.cmake \)"
-    COMPONENT compiler-rt)
-
-  add_llvm_install_targets(install-compiler-rt
-                           DEPENDS compiler-rt
-                           COMPONENT compiler-rt)
-
-  # Add top-level targets that build specific compiler-rt runtimes.
-  set(COMPILER_RT_RUNTIMES fuzzer asan builtins dfsan lsan msan profile tsan ubsan ubsan-minimal)
-  foreach(runtime ${COMPILER_RT_RUNTIMES})
-    get_ext_project_build_command(build_runtime_cmd ${runtime})
-    add_custom_target(${runtime}
-      COMMAND ${build_runtime_cmd}
-      DEPENDS compiler-rt-configure
-      WORKING_DIRECTORY ${BINARY_DIR}
-      VERBATIM USES_TERMINAL)
-  endforeach()
-
-  if(LLVM_INCLUDE_TESTS)
-    # Add binaries that compiler-rt tests depend on.
-    set(COMPILER_RT_TEST_DEPENDENCIES
-      FileCheck count not llvm-nm llvm-objdump llvm-symbolizer)
-
-    # Add top-level targets for various compiler-rt test suites.
-    set(COMPILER_RT_TEST_SUITES check-fuzzer check-asan check-hwasan check-asan-dynamic check-dfsan
-      check-lsan check-msan check-sanitizer check-tsan check-ubsan check-ubsan-minimal
-      check-profile check-cfi check-cfi-and-supported check-safestack check-gwp_asan)
-    foreach(test_suite ${COMPILER_RT_TEST_SUITES})
-      get_ext_project_build_command(run_test_suite ${test_suite})
-      add_custom_target(${test_suite}
-        COMMAND ${run_test_suite}
-        DEPENDS compiler-rt-build ${COMPILER_RT_TEST_DEPENDENCIES}
-        WORKING_DIRECTORY ${BINARY_DIR}
-        VERBATIM
-        USES_TERMINAL
-        )
-    endforeach()
-
-    # Add special target to run all compiler-rt test suites.
-    get_ext_project_build_command(run_check_compiler_rt check-all)
-    add_custom_target(check-compiler-rt
-      COMMAND ${run_check_compiler_rt}
-      DEPENDS compiler-rt-build ${COMPILER_RT_TEST_DEPENDENCIES}
-      WORKING_DIRECTORY ${BINARY_DIR}
-      VERBATIM USES_TERMINAL)
-
-    # Add special target to run all compiler-rt test suites.
-    get_ext_project_build_command(run_check_compiler_rt compiler-rt-test-depends)
-    add_custom_target(compiler-rt-test-depends
-      COMMAND ${run_check_compiler_rt}
-      DEPENDS compiler-rt-build ${COMPILER_RT_TEST_DEPENDENCIES}
-      WORKING_DIRECTORY ${BINARY_DIR}
-      VERBATIM USES_TERMINAL)
-    set_property(GLOBAL APPEND PROPERTY LLVM_ADDITIONAL_TEST_DEPENDS compiler-rt-test-depends)
-    set_property(GLOBAL APPEND PROPERTY LLVM_ADDITIONAL_TEST_TARGETS check-compiler-rt)
-  endif()
-endif()

clang/runtime/compiler-rt/clang_linux_test_input.c

-// This file is used to check if we can produce working executables
-// for i386 and x86_64 archs on Linux.
-#include <stdlib.h>
-int main(){}

compiler-rt/cmake/Modules/AddCompilerRT.cmake

macro(add_compiler_rt_resource_file target_name file_name component)
   set(dst_file "${COMPILER_RT_OUTPUT_DIR}/share/${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}...")
   add_custom_target(${target_name} DEPENDS ${dst_file})
   # Install in Clang resource directory.
   install(FILES ${file_name}
-    DESTINATION ${COMPILER_RT_INSTALL_PATH}/share
+    DESTINATION share
     COMPONENT ${component})
   add_dependencies(${component} ${target_name})
 
   set_target_properties(${target_name} PROPERTIES FOLDER "Compiler-RT Misc")
 endmacro()
 
 macro(add_compiler_rt_script name)
   set(dst ${COMPILER_RT_EXEC_OUTPUT_DIR}/${name})
   set(src ${CMAKE_CURRENT_SOURCE_DIR}/${name})
   add_custom_command(OUTPUT ${dst}
     DEPENDS ${src}
     COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
     COMMENT "Copying ${name}...")
   add_custom_target(${name} DEPENDS ${dst})
   install(FILES ${dst}
     PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
-    DESTINATION ${COMPILER_RT_INSTALL_PATH}/bin)
+    DESTINATION bin)
 endmacro(add_compiler_rt_script src name)
 
 # Builds custom version of libc++ and installs it in <prefix>.
 # Can be used to build sanitized versions of libc++ for running unit tests.
 # add_custom_libcxx(<name> <prefix>
 #                   DEPS <list of build deps>
 #                   CFLAGS <list of compile flags>
 #                   USE_TOOLCHAIN)

compiler-rt/cmake/Modules/CompilerRTDarwinUtils.cmake

if(COMPILER_RT_SUPPORTED_ARCH MATCHES ".*armv.*")
     set(PIC_FLAG -fPIC)
     set(STATIC_FLAG -static)
 
     set(DARWIN_macho_embedded_ARCHS armv6m armv7m armv7em armv7 i386 x86_64)
 
     set(DARWIN_macho_embedded_LIBRARY_OUTPUT_DIR
       ${COMPILER_RT_OUTPUT_DIR}/lib/macho_embedded)
     set(DARWIN_macho_embedded_LIBRARY_INSTALL_DIR
-      ${COMPILER_RT_INSTALL_PATH}/lib/macho_embedded)
+      lib/macho_embedded)
       
     set(CFLAGS_armv7 "-target thumbv7-apple-darwin-eabi")
     set(CFLAGS_i386 "-march=pentium")
 
     darwin_read_list_from_file(common_FUNCTIONS ${MACHO_SYM_DIR}/common.txt)
     darwin_read_list_from_file(thumb2_FUNCTIONS ${MACHO_SYM_DIR}/thumb2.txt)
     darwin_read_list_from_file(thumb2_64_FUNCTIONS ${MACHO_SYM_DIR}/thumb2-64.txt)
     darwin_read_list_from_file(arm_FUNCTIONS ${MACHO_SYM_DIR}/arm.txt)

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

else()
     set(target "${arch}${triple_suffix}")
   endif()
   set(${variable} ${target} PARENT_SCOPE)
 endfunction()
 
 function(get_compiler_rt_install_dir arch install_dir)
   if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
     get_compiler_rt_target(${arch} target)
-    set(${install_dir} ${COMPILER_RT_INSTALL_PATH}/lib/${target} PARENT_SCOPE)
+    set(${install_dir} lib/${target} PARENT_SCOPE)
   else()
     set(${install_dir} ${COMPILER_RT_LIBRARY_INSTALL_DIR} PARENT_SCOPE)
   endif()
 endfunction()
 
 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)

compiler-rt/cmake/base-config-ix.cmake

if (LLVM_TREE_AVAILABLE)
   # Compute the Clang version from the LLVM version.
   # FIXME: We should be able to reuse CLANG_VERSION variable calculated
   #        in Clang cmake files, instead of copying the rules here.
   string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" CLANG_VERSION
          ${PACKAGE_VERSION})
   # Setup the paths where compiler-rt runtimes and headers should be stored.
   set(COMPILER_RT_OUTPUT_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION})
   set(COMPILER_RT_EXEC_OUTPUT_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
-  set(COMPILER_RT_INSTALL_PATH lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION})
+  set(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION})
   option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests."
          ${LLVM_INCLUDE_TESTS})
   option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered"
          ${LLVM_ENABLE_WERROR})
 
   # Use just-built Clang to compile/link tests on all platforms.
   if (CMAKE_CROSSCOMPILING)
     if (CMAKE_HOST_WIN32)
if (LLVM_TREE_AVAILABLE)
   set(COMPILER_RT_TEST_CXX_COMPILER
     ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++${_host_executable_suffix})
 else()
     # Take output dir and install path from the user.
   set(COMPILER_RT_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE PATH
     "Path where built compiler-rt libraries should be stored.")
   set(COMPILER_RT_EXEC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/bin CACHE PATH
     "Path where built compiler-rt executables should be stored.")
-  set(COMPILER_RT_INSTALL_PATH ${CMAKE_INSTALL_PREFIX} CACHE PATH
-    "Path where built compiler-rt libraries should be installed.")
   option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests." OFF)
   option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered" OFF)
   # Use a host compiler to compile/link tests.
   set(COMPILER_RT_TEST_COMPILER ${CMAKE_C_COMPILER} CACHE PATH "Compiler to use for testing")
   set(COMPILER_RT_TEST_CXX_COMPILER ${CMAKE_CXX_COMPILER} CACHE PATH "C++ Compiler to use for testing")
 endif()
 
 if("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang[+]*$")
   set(COMPILER_RT_TEST_COMPILER_ID Clang)
 elseif("${COMPILER_RT_TEST_COMPILER}" MATCHES "clang.*.exe$")
   set(COMPILER_RT_TEST_COMPILER_ID Clang)
 else()
   set(COMPILER_RT_TEST_COMPILER_ID GNU)
 endif()
 
 if(NOT DEFINED COMPILER_RT_OS_DIR)
   string(TOLOWER ${CMAKE_SYSTEM_NAME} COMPILER_RT_OS_DIR)
 endif()
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
   set(COMPILER_RT_LIBRARY_OUTPUT_DIR
     ${COMPILER_RT_OUTPUT_DIR})
   set(COMPILER_RT_LIBRARY_INSTALL_DIR
-    ${COMPILER_RT_INSTALL_PATH})
+    "")
 else(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR)
   set(COMPILER_RT_LIBRARY_OUTPUT_DIR
     ${COMPILER_RT_OUTPUT_DIR}/lib/${COMPILER_RT_OS_DIR})
   set(COMPILER_RT_LIBRARY_INSTALL_DIR
-    ${COMPILER_RT_INSTALL_PATH}/lib/${COMPILER_RT_OS_DIR})
+    lib/${COMPILER_RT_OS_DIR})
 endif()
 
 if(APPLE)
   # On Darwin if /usr/include/c++ doesn't exist, the user probably has Xcode but
   # not the command line tools (or is using macOS 10.14 or newer). If this is
   # the case, we need to find the OS X sysroot to pass to clang.
   if(NOT EXISTS /usr/include/c++)
     execute_process(COMMAND xcrun -sdk macosx --show-sdk-path

compiler-rt/include/CMakeLists.txt

 add_custom_target(compiler-rt-headers ALL DEPENDS ${out_files})
 add_dependencies(compiler-rt compiler-rt-headers)
 set_target_properties(compiler-rt-headers PROPERTIES FOLDER "Compiler-RT Misc")
 
 # Install sanitizer headers.
 install(FILES ${SANITIZER_HEADERS}
   COMPONENT compiler-rt-headers
   PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-  DESTINATION ${COMPILER_RT_INSTALL_PATH}/include/sanitizer)
+  DESTINATION include/sanitizer)
 # Install fuzzer headers.
 install(FILES ${FUZZER_HEADERS}
   COMPONENT compiler-rt-headers
   PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-  DESTINATION ${COMPILER_RT_INSTALL_PATH}/include/fuzzer)
+  DESTINATION include/fuzzer)
 # Install xray headers.
 install(FILES ${XRAY_HEADERS}
   COMPONENT compiler-rt-headers
   PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-  DESTINATION ${COMPILER_RT_INSTALL_PATH}/include/xray)
+  DESTINATION include/xray)
 # Install profile headers.
 install(FILES ${PROFILE_HEADERS}
   COMPONENT compiler-rt-headers
   PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
-  DESTINATION ${COMPILER_RT_INSTALL_PATH}/include/profile)
+  DESTINATION include/profile)
 
 if (NOT CMAKE_CONFIGURATION_TYPES) # don't add this for IDEs.
   add_custom_target(install-compiler-rt-headers
                     DEPENDS compiler-rt-headers
                     COMMAND "${CMAKE_COMMAND}"
                             -DCMAKE_INSTALL_COMPONENT="compiler-rt-headers"
                             -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
                     USES_TERMINAL)
   add_custom_target(install-compiler-rt-headers-stripped
                     DEPENDS compiler-rt-headers
                     COMMAND "${CMAKE_COMMAND}"
                             -DCMAKE_INSTALL_COMPONENT="compiler-rt-headers"
                             -DCMAKE_INSTALL_DO_STRIP=1
                             -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
                     USES_TERMINAL)
 endif()

compiler-rt/lib/dfsan/CMakeLists.txt

add_custom_command(OUTPUT ${dfsan_abilist_filename}
                     ${CMAKE_COMMAND} -E make_directory ${dfsan_abilist_dir}
                    COMMAND
                      cat ${CMAKE_CURRENT_SOURCE_DIR}/done_abilist.txt
                          ${CMAKE_CURRENT_SOURCE_DIR}/libc_ubuntu1404_abilist.txt
                          > ${dfsan_abilist_filename}
                    DEPENDS done_abilist.txt libc_ubuntu1404_abilist.txt)
 add_dependencies(dfsan dfsan_abilist)
 install(FILES ${dfsan_abilist_filename}
-        DESTINATION ${COMPILER_RT_INSTALL_PATH}/share)
+        DESTINATION share)

llvm/runtimes/CMakeLists.txt

 # TODO: This file assumes the Clang toolchain so it'd be better if it lived in
-# Clang, except there already is clang/runtime directory which contains
-# similar although simpler functionality. We should figure out how to merge
+# Clang, except there already is runtimes directory which contains
+# similar functionality. We should figure out how to merge
 # the two files.
 
 # TODO: Selecting runtimes should be always performed inside the runtimes
 # build, see runtimes/CMakeLists.txt, except that we currently check whether
 # compiler-rt is being built to determine whether to first build builtins
 # or not so we need that information in this file as well.
 set(LLVM_ALL_RUNTIMES "compiler-rt;libc;libcxx;libcxxabi;libunwind;openmp")
 set(LLVM_ENABLE_RUNTIMES "" CACHE STRING