Prepare Compiler-RT for GnuInstallDirs, matching libcxx, document all

[Ericson2314]

Summary

This is a second attempt at D101497, which landed as
9a9bc76c0eb72f0f2732c729a460abbd5239c2e3 but had to be reverted in
8cf7ddbdd4e5af966a369e170c73250f2e3920e7.

This issue was that in the case that COMPILER_RT_INSTALL_PATH is
empty, expressions like "${COMPILER_RT_INSTALL_PATH}/bin" evaluated to
"/bin" not "bin" as intended and as was originally.

One solution is to make COMPILER_RT_INSTALL_PATH always non-empty,
defaulting it to CMAKE_INSTALL_PREFIX. D99636 adopted that approach.
But, I think it is more ergonomic to allow those project-specific paths
to be relative the global ones. Also, making install paths absolute by
default inhibits the proper behavior of functions like
GNUInstallDirs_get_absolute_install_dir which make relative install
paths absolute in a more complicated way.

Given all this, I will define a function like the one asked for in
https://gitlab.kitware.com/cmake/cmake/-/issues/19568 (and needed for a
similar use-case).

---

Original message:

Instead of using COMPILER_RT_INSTALL_PATH through the CMake for
complier-rt, just use it to define variables for the subdirs which
themselves are used.

This preserves compatibility, but later on we might consider getting rid
of COMPILER_RT_INSTALL_PATH and just changing the defaults for the
subdir variables directly.

---

There was a seaming bug where the (non-Apple) per-target libdir was
${target} not lib/${target}. I suspect that has to do with the docs
on COMPILER_RT_INSTALL_PATH saying was the library dir when that's no
longer true, so I just went ahead and fixed it, allowing me to define
fewer and more sensible variables.

That last part should be the only behavior changes; everything else
should be a pure refactoring.

---

I added some documentation of these variables too. In particular, I
wanted to highlight the gotcha where -DSomeCachePath=... without the
:PATH will lead CMake to make the path absolute. See [1] for
discussion of the problem, and [2] for the brief official documentation
they added as a result.

[1]: https://cmake.org/pipermail/cmake/2015-March/060204.html

[2]: https://cmake.org/cmake/help/latest/manual/cmake.1.html#options

In 38b2dec37ee735d5409148e71ecba278caf0f969 the problem was somewhat
misidentified and so :STRING was used, but :PATH is better as it
sets the correct type from the get-go.

---

D99484 is the main thrust of the GnuInstallDirs work. Once this lands,
it should be feasible to follow both of these up with a simple patch for
compiler-rt analogous to the one for libcxx.

[mstorsjo]

+1, this one works where the previous one failed for me - thanks!

I haven't followed all the intricate cmake details here so I'd prefer to leave it to @phosek to actually re-approve this, but it seems to not break things for me now at least.

[Ericson2314]

For reference, here is the "diff of diffs"

 diff --git a/compiler-rt/cmake/base-config-ix.cmake b/compiler-rt/cmake/base-config-ix.cmake
-index 1edab43e7c0d..c4d78098d070 100644
+index 1edab43e7c0d..ed2ef0e4829c 100644
 --- a/compiler-rt/cmake/base-config-ix.cmake
 +++ b/compiler-rt/cmake/base-config-ix.cmake
 @@ -68,8 +68,8 @@ else()
@@ -144,7 +166,25 @@ index 1edab43e7c0d..c4d78098d070 100644
    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.
-@@ -89,16 +89,24 @@ if(NOT DEFINED COMPILER_RT_OS_DIR)
+@@ -85,20 +85,45 @@ else()
+   set(COMPILER_RT_TEST_COMPILER_ID GNU)
+ endif()
+
++function(extend_install_path joined_path current_segment)
++  if("${current_segment}" STREQUAL "")
++    set(temp_path "${COMPILER_RT_INSTALL_PATH}")
++  elseif("${COMPILER_RT_INSTALL_PATH}" STREQUAL "")
++    set(temp_path "${current_segment}")
++  elseif(IS_ABSOLUTE "${current_segment}")
++    message(WARNING "Since \"${current_segment}\" is absolute, it overrides COMPILER_RT_INSTALL_PATH: \"${temp_path}\".")
++    set(temp_path "${current_segment}")
++  else()
++    set(temp_path "${temp_path}/${current_segment}")
++  endif()
++  set(${joined_path} "${temp_path}" PARENT_SCOPE)
++endfunction()
++
+ 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)
@@ -156,23 +196,26 @@ index 1edab43e7c0d..c4d78098d070 100644
 -  set(COMPILER_RT_LIBRARY_OUTPUT_DIR
 +  set(COMPILER_RT_OUTPUT_LIBRARY_DIR
 +    ${COMPILER_RT_OUTPUT_DIR}/lib)
-+  set(COMPILER_RT_INSTALL_LIBRARY_DIR
-+    ${COMPILER_RT_INSTALL_PATH}/lib CACHE PATH
++  extend_install_path(default_install_path lib)
++  set(COMPILER_RT_INSTALL_LIBRARY_DIR "${default_install_path}" CACHE PATH
 +    "Path where built compiler-rt libraries should be installed.")
 +else(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
 +  set(COMPILER_RT_OUTPUT_LIBRARY_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})
-+  set(COMPILER_RT_INSTALL_LIBRARY_DIR
-+    ${COMPILER_RT_INSTALL_PATH}/lib/${COMPILER_RT_OS_DIR} CACHE PATH
++  extend_install_path(default_install_path "lib/${COMPILER_RT_OS_DIR}")
++  set(COMPILER_RT_INSTALL_LIBRARY_DIR "${default_install_path}" CACHE PATH
 +    "Path where built compiler-rt libraries should be installed.")
  endif()
-+set(COMPILER_RT_INSTALL_BINARY_DIR "${COMPILER_RT_INSTALL_PATH}/bin" CACHE PATH
++extend_install_path(default_install_path bin)
++set(COMPILER_RT_INSTALL_BINARY_DIR "${default_install_path}" CACHE PATH
 +  "Path where built compiler-rt executables should be installed.")
-+set(COMPILER_RT_INSTALL_INCLUDE_DIR "${COMPILER_RT_INSTALL_PATH}/include" CACHE PATH
++extend_install_path(default_install_path include)
++set(COMPILER_RT_INSTALL_INCLUDE_DIR "${default_install_path}" CACHE PATH
 +  "Path where compiler-rt headers should be installed.")
-+set(COMPILER_RT_INSTALL_DATA_DIR "${COMPILER_RT_INSTALL_PATH}/share" CACHE PATH
++extend_install_path(default_install_path share)
++set(COMPILER_RT_INSTALL_DATA_DIR "${default_install_path}" CACHE PATH
 +  "Path where compiler-rt data files should be installed.")

  if(APPLE)

[Ericson2314]

The test failures seem to all be libcxx and thus presumably unrelated.

[phosek]

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

97

This isn't set before so it should be always empty in which case you'll end up with an absolute path (that is /${current_segment}) right? Isn't that a bug?

[Ericson2314]

Fix bugs, add lots of docs

[Ericson2314]

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

97

Eek! that's embarrassing. Turns out that testing with -D is more fraught than I thought, and I wasn't hitting that case. Fixed the bug and documented the -D subtlety too.

[Ericson2314]

compiler-rt/docs/BuildingCompilerRT.rst

13–23

Modeled this file off libc++'s, including taking these two paragraphs. They seem appropriate enough here.

[phosek]

compiler-rt/docs/BuildingCompilerRT.rst

13–23

I'm not sure how appropriate this is actually since Compiler-RT is usually shipped together with the compiler, not the operating system (unlike libc++) since the LLVM and Compiler-RT ABI is tightly coupled. I'd omit this for now.

17

compiler-rt?

60

Is this what you meant here?

88

This variable is used for data files (like resources), not headers.

[Ericson2314]

Fixes from comments, Thanks!

compiler-rt/docs/BuildingCompilerRT.rst

13–23

Fair enough. Removed.

17

Ah there is no such section for compiler-rt/docs. I deleted and reworded.

60

Oops. Yes.

88

Says "data" like the CMake variale description does now too.

[phosek]

LGTM

[arphaman]

compiler-rt/cmake/Modules/CompilerRTDarwinUtils.cmake

509

It looks like this change broke the macho_embedded layout for Darwin's compiler-rt build, so now the clang driver isn unable to find these libraries.

I will commit a change that uses COMPILER_RT_OUTPUT_DIR again for the macho_embedded libraries.

[Ericson2314]

compiler-rt/cmake/Modules/CompilerRTDarwinUtils.cmake

509

Can you help me understand this better? COMPILER_RT_OUTPUT_LIBRARY_DIR should be defined to be the same thing unless target-specific directories are used, Is the problem in the latter case?

[arphaman]

compiler-rt/cmake/Modules/CompilerRTDarwinUtils.cmake

509

The problem is that Darwin was emitting macho_embedded libraries under usr/lib/clang/<version>/lib/darwin/macho_embedded, but this change moved them to usr/lib/clang/<version>/lib/macho_embedded, so now the clang driver isn't able to find them.

I think using COMPILER_RT_OUTPUT_LIBRARY_DIR is the right thing, but we still want to be compatible with the existing layout unless we change the driver. I think changing the driver might be a better approach though, so I will try that.

[arphaman]

compiler-rt/cmake/Modules/CompilerRTDarwinUtils.cmake

509

Sorry, I meant to say that Darwin was emitting macho_embedded libraries under usr/lib/clang/<version>/lib/macho_embedded, but this change moved them to usr/lib/clang/<version>/lib/darwin/macho_embedded, so now the clang driver isn't able to find them.

[tstellar]

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

126

Was there supposed to be an extend_install_path call here?

clang/runtime/CMakeLists.txt

CMAKE_ARGS ${CLANG_COMPILER_RT_CMAKE_ARGS}
                -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_INSTALL_PATH:PATH=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 ""

compiler-rt/cmake/Modules/AddCompilerRT.cmake

if(${type} STREQUAL "SHARED")
         set_target_properties(${libname} PROPERTIES IMPORT_PREFIX "")
         set_target_properties(${libname} PROPERTIES IMPORT_SUFFIX ".lib")
       endif()
       if(APPLE)
         # Ad-hoc sign the dylibs
         add_custom_command(TARGET ${libname}
           POST_BUILD  
           COMMAND codesign --sign - $<TARGET_FILE:${libname}>
-          WORKING_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
+          WORKING_DIRECTORY ${COMPILER_RT_OUTPUT_LIBRARY_DIR}
         )
       endif()
     endif()
 
     set(parent_target_arg)
     if(LIB_PARENT_TARGET)
       set(parent_target_arg PARENT_TARGET ${LIB_PARENT_TARGET})
     endif()
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 ${COMPILER_RT_INSTALL_DATA_DIR}
     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 ${COMPILER_RT_INSTALL_BINARY_DIR})
 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(NOT DARWIN_${os}_SKIP_CC_KEXT)
       set(archive_name clang_rt.cc_kext_${os})
       if(${os} STREQUAL "osx")
         set(archive_name clang_rt.cc_kext)
       endif()
       darwin_lipo_libs(${archive_name}
                       PARENT_TARGET builtins
                       LIPO_FLAGS ${${os}_cc_kext_lipo_flags}
                       DEPENDS ${${os}_cc_kext_libs}
-                      OUTPUT_DIR ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
-                      INSTALL_DIR ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+                      OUTPUT_DIR ${COMPILER_RT_OUTPUT_LIBRARY_DIR}
+                      INSTALL_DIR ${COMPILER_RT_INSTALL_LIBRARY_DIR})
     endif()
   endforeach()
 
   foreach (os ${ARGN})
     darwin_lipo_libs(clang_rt.${os}
                      PARENT_TARGET builtins
                      LIPO_FLAGS ${${os}_builtins_lipo_flags}
                      DEPENDS ${${os}_builtins_libs}
-                     OUTPUT_DIR ${COMPILER_RT_LIBRARY_OUTPUT_DIR}
-                     INSTALL_DIR ${COMPILER_RT_LIBRARY_INSTALL_DIR})
+                     OUTPUT_DIR ${COMPILER_RT_OUTPUT_LIBRARY_DIR}
+                     INSTALL_DIR ${COMPILER_RT_INSTALL_LIBRARY_DIR})
   endforeach()
   darwin_add_embedded_builtin_libraries()
 endmacro()
 
 macro(darwin_add_embedded_builtin_libraries)
   # this is a hacky opt-out. If you can't target both intel and arm
   # architectures we bail here.
   set(DARWIN_SOFT_FLOAT_ARCHS armv6m armv7m armv7em armv7)
if(COMPILER_RT_SUPPORTED_ARCH MATCHES ".*armv.*")
 
     set(ENABLE_PIC Off)
     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)
+      ${COMPILER_RT_OUTPUT_LIBRARY_DIR}/macho_embedded)
     set(DARWIN_macho_embedded_LIBRARY_INSTALL_DIR
-      ${COMPILER_RT_INSTALL_PATH}/lib/macho_embedded)
+      ${COMPILER_RT_INSTALL_LIBRARY_DIR}/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} ${COMPILER_RT_INSTALL_LIBRARY_DIR}/${target} PARENT_SCOPE)
   else()
-    set(${install_dir} ${COMPILER_RT_LIBRARY_INSTALL_DIR} PARENT_SCOPE)
+    set(${install_dir} ${COMPILER_RT_INSTALL_LIBRARY_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)
-    set(${output_dir} ${COMPILER_RT_OUTPUT_DIR}/lib/${target} PARENT_SCOPE)
+    set(${output_dir} ${COMPILER_RT_OUTPUT_LIBRARY_DIR}/${target} PARENT_SCOPE)
   else()
-    set(${output_dir} ${COMPILER_RT_LIBRARY_OUTPUT_DIR} PARENT_SCOPE)
+    set(${output_dir} ${COMPILER_RT_OUTPUT_LIBRARY_DIR} PARENT_SCOPE)
   endif()
 endfunction()
 
 # compiler_rt_process_sources(
 #   <OUTPUT_VAR>
 #   <SOURCE_FILE> ...
 #  [ADDITIONAL_HEADERS <header> ...]
 # )

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

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.")
+  set(COMPILER_RT_INSTALL_PATH "" CACHE PATH
+    "Prefix for directories where built compiler-rt artifacts 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()
 
+function(extend_install_path joined_path current_segment)
+  if("${current_segment}" STREQUAL "")
+    set(temp_path "${COMPILER_RT_INSTALL_PATH}")
+  elseif("${COMPILER_RT_INSTALL_PATH}" STREQUAL "")
+    set(temp_path "${current_segment}")
+  elseif(IS_ABSOLUTE "${current_segment}")
+    message(WARNING "Since \"${current_segment}\" is absolute, it overrides COMPILER_RT_INSTALL_PATH: \"${COMPILER_RT_INSTALL_PATH}\".")
+    set(temp_path "${current_segment}")
+  else()
+    set(temp_path "${COMPILER_RT_INSTALL_PATH}/${current_segment}")
+  endif()
+  set(${joined_path} "${temp_path}" PARENT_SCOPE)
+endfunction()
+
 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
+  set(COMPILER_RT_OUTPUT_LIBRARY_DIR
+    ${COMPILER_RT_OUTPUT_DIR}/lib)
+  extend_install_path(default_install_path lib)
+  set(COMPILER_RT_INSTALL_LIBRARY_DIR "${default_install_path}" CACHE PATH
+    "Path where built compiler-rt libraries should be installed.")
+else(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
+  set(COMPILER_RT_OUTPUT_LIBRARY_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})
+  extend_install_path(default_install_path "lib/${COMPILER_RT_OS_DIR}")
+  set(COMPILER_RT_INSTALL_LIBRARY_DIR "${default_install_path}" CACHE PATH
+    "Path where built compiler-rt libraries should be installed.")
 endif()
+extend_install_path(default_install_path bin)
+set(COMPILER_RT_INSTALL_BINARY_DIR "${default_install_path}" CACHE PATH
+  "Path where built compiler-rt executables should be installed.")
+extend_install_path(default_install_path include)
+set(COMPILER_RT_INSTALL_INCLUDE_DIR "${default_install_path}" CACHE PATH
+  "Path where compiler-rt headers should be installed.")
+extend_install_path(default_install_path share)
+set(COMPILER_RT_INSTALL_DATA_DIR "${default_install_path}" CACHE PATH
+  "Path where compiler-rt data files should be installed.")
 
 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
        OUTPUT_VARIABLE OSX_SYSROOT

compiler-rt/docs/BuildingCompilerRT.rst

+.. _BuildingCompilerRT:
+
+===============
+Building Compiler-RT
+===============
+
+.. contents::
+  :local:
+
+.. _build instructions:
+
+The instructions on this page are aimed at vendors who ship Compiler-RT as part of an
+operating system distribution, a toolchain or similar shipping vehicules. If you
+are a user merely trying to use Compiler-RT in your program, you most likely want to
+refer to your vendor's documentation, or to the general documentation for using
+LLVM, Clang, the various santizers, etc.
+
+CMake Options
+=============
+
+Here are some of the CMake variables that are used often, along with a
+brief explanation and LLVM-specific notes. For full documentation, check the
+CMake docs or execute ``cmake --help-variable VARIABLE_NAME``.
+
+**CMAKE_BUILD_TYPE**:STRING
+  Sets the build type for ``make`` based generators. Possible values are
+  Release, Debug, RelWithDebInfo and MinSizeRel. On systems like Visual Studio
+  the user sets the build type with the IDE settings.
+
+**CMAKE_INSTALL_PREFIX**:PATH
+  Path where LLVM will be installed if "make install" is invoked or the
+  "INSTALL" target is built.
+
+**CMAKE_CXX_COMPILER**:STRING
+  The C++ compiler to use when building and testing Compiler-RT.
+
+
+.. _compiler-rt-specific options:
+
+Compiler-RT specific options
+-----------------------
+
+.. option:: COMPILER_RT_INSTALL_PATH:PATH
+
+  **Default**: ```` (empty relative path)
+
+  Prefix for directories where built Compiler-RT artifacts should be installed.
+  Can be an absolute path, like the default empty string, in which case it is
+  relative ``CMAKE_INSTALL_PREFIX``. If setting a relative path, make sure to
+  include the ``:PATH`` with your ``-D``, i.e. use
+  ``-DCOMPILER_RT_INSTALL_PATH:PATH=...`` not
+  ``-DCOMPILER_RT_INSTALL_PATH=...``, otherwise CMake will convert the
+  path to an absolute path.
+
+.. option:: COMPILER_RT_INSTALL_LIBRARY_DIR:PATH
+
+  **Default**: ``lib``
+
+  Path where built Compiler-RT libraries should be installed. If a relative
+  path, relative to ``COMPILER_RT_INSTALL_PATH``.
+
+.. option:: COMPILER_RT_INSTALL_BINARY_DIR:PATH
+
+  **Default**: ``bin``
+
+  Path where built Compiler-RT executables should be installed. If a relative
+  path, relative to ``COMPILER_RT_INSTALL_PATH``.
+
+.. option:: COMPILER_RT_INSTALL_INCLUDE_DIR:PATH
+
+  **Default**: ``include``
+
+  Path where Compiler-RT headers should be installed. If a relative
+  path, relative to ``COMPILER_RT_INSTALL_PATH``.
+
+.. option:: COMPILER_RT_INSTALL_DATA_DIR:PATH
+
+  **Default**: ``share``
+
+  Path where Compiler-RT data should be installed. If a relative
+  path, relative to ``COMPILER_RT_INSTALL_PATH``.
+
+.. _LLVM-specific variables:
+
+LLVM-specific options
+---------------------
+
+.. option:: LLVM_LIBDIR_SUFFIX:STRING
+
+  Extra suffix to append to the directory where libraries are to be
+  installed. On a 64-bit architecture, one could use ``-DLLVM_LIBDIR_SUFFIX=64``
+  to install libraries to ``/usr/lib64``.

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 ${COMPILER_RT_INSTALL_INCLUDE_DIR}/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 ${COMPILER_RT_INSTALL_INCLUDE_DIR}/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 ${COMPILER_RT_INSTALL_INCLUDE_DIR}/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 ${COMPILER_RT_INSTALL_INCLUDE_DIR}/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 ${COMPILER_RT_INSTALL_DATA_DIR})

libcxx/CMakeLists.txt

 #===============================================================================
 
 # TODO: Projects that depend on libc++ should use LIBCXX_GENERATED_INCLUDE_DIR
 # instead of hard-coding include/c++/v1.
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
   set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})
   set(LIBCXX_GENERATED_INCLUDE_DIR "${LLVM_BINARY_DIR}/include/c++/v1")
   set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LLVM_BINARY_DIR}/include/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1")
-  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE})
-  set(LIBCXX_INSTALL_INCLUDE_DIR "include/c++/v1")
-  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "include/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1")
+  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH
+      "Path where built libc++ libraries should be installed.")
+  set(LIBCXX_INSTALL_INCLUDE_DIR "include/c++/v1" CACHE PATH
+      "Path where target-agnostic libc++ headers should be installed.")
+  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "include/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1" CACHE PATH
+      "Path where target-specific libc++ headers should be installed.")
   if(LIBCXX_LIBDIR_SUBDIR)
     string(APPEND LIBCXX_LIBRARY_DIR /${LIBCXX_LIBDIR_SUBDIR})
     string(APPEND LIBCXX_INSTALL_LIBRARY_DIR /${LIBCXX_LIBDIR_SUBDIR})
   endif()
 elseif(LLVM_LIBRARY_OUTPUT_INTDIR)
   set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
   set(LIBCXX_GENERATED_INCLUDE_DIR "${LLVM_BINARY_DIR}/include/c++/v1")
   set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LIBCXX_GENERATED_INCLUDE_DIR}")
-  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LIBCXX_LIBDIR_SUFFIX})
-  set(LIBCXX_INSTALL_INCLUDE_DIR "include/c++/v1")
-  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${LIBCXX_INSTALL_INCLUDE_DIR}")
+  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LIBCXX_LIBDIR_SUFFIX} CACHE PATH
+      "Path where built libc++ libraries should be installed.")
+  set(LIBCXX_INSTALL_INCLUDE_DIR "include/c++/v1" CACHE PATH
+      "Path where target-agnostic libc++ headers should be installed.")
+  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${LIBCXX_INSTALL_INCLUDE_DIR}" CACHE PATH
+      "Path where target-specific libc++ headers should be installed.")
 else()
   set(LIBCXX_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBCXX_LIBDIR_SUFFIX})
   set(LIBCXX_GENERATED_INCLUDE_DIR "${CMAKE_BINARY_DIR}/include/c++/v1")
   set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LIBCXX_GENERATED_INCLUDE_DIR}")
-  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LIBCXX_LIBDIR_SUFFIX})
-  set(LIBCXX_INSTALL_INCLUDE_DIR "include/c++/v1")
-  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${LIBCXX_INSTALL_INCLUDE_DIR}")
+  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LIBCXX_LIBDIR_SUFFIX} CACHE PATH
+      "Path where built libc++ libraries should be installed.")
+  set(LIBCXX_INSTALL_INCLUDE_DIR "include/c++/v1" CACHE PATH
+      "Path where target-agnostic libc++ headers should be installed.")
+  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${LIBCXX_INSTALL_INCLUDE_DIR}" CACHE PATH
+      "Path where target-specific libc++ headers should be installed.")
 endif()
 
 file(MAKE_DIRECTORY "${LIBCXX_BINARY_INCLUDE_DIR}")
 
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIBCXX_LIBRARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIBCXX_LIBRARY_DIR})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIBCXX_LIBRARY_DIR})
 

libcxx/docs/BuildingLibcxx.rst

 
 .. option:: LIBCXX_ENABLE_FILESYSTEM:BOOL
 
    **Default**: ``ON`` except on Windows.
 
    This option can be used to enable or disable the filesystem components on
    platforms that may not support them. For example on Windows.
 
+.. option:: LIBCXX_INSTALL_LIBRARY_DIR:PATH
+
+  **Default**: ``lib${LIBCXX_LIBDIR_SUFFIX}``
+
+  Path where built libc++ libraries should be installed. If a relative path,
+  relative to ``CMAKE_INSTALL_PREFIX``.
+
+.. option:: LIBCXX_INSTALL_INCLUDE_DIR:PATH
+
+  **Default**: ``include/c++/v1``
+
+  Path where target-agnostic libc++ headers should be installed. If a relative
+  path, relative to ``CMAKE_INSTALL_PREFIX``.
+
+.. option:: LIBCXX_INSTALL_INCLUDE_TARGET_DIR:PATH
+
+  **Default**: ``include/c++/v1`` or
+  ``include/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1``
+
+  Path where target-specific libc++ headers should be installed. If a relative
+  path, relative to ``CMAKE_INSTALL_PREFIX``.
+
 .. _libc++experimental options:
 
 libc++experimental Specific Options
 ------------------------------------
 
 .. option:: LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY:BOOL
 
   **Default**: ``ON``

libcxxabi/CMakeLists.txt

set(CMAKE_MODULE_PATH
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
   ${CMAKE_MODULE_PATH}
   )
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
   set(LIBCXXABI_HEADER_DIR ${LLVM_BINARY_DIR})
   set(LIBCXXABI_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})
-  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE})
+  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH
+      "Path where built libc++abi libraries should be installed.")
   if(LIBCXX_LIBDIR_SUBDIR)
     string(APPEND LIBCXXABI_LIBRARY_DIR /${LIBCXXABI_LIBDIR_SUBDIR})
     string(APPEND LIBCXXABI_INSTALL_LIBRARY_DIR /${LIBCXXABI_LIBDIR_SUBDIR})
   endif()
 elseif(LLVM_LIBRARY_OUTPUT_INTDIR)
   set(LIBCXXABI_HEADER_DIR ${LLVM_BINARY_DIR})
   set(LIBCXXABI_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
-  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LIBCXXABI_LIBDIR_SUFFIX})
+  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LIBCXXABI_LIBDIR_SUFFIX} CACHE PATH
+      "Path where built libc++abi libraries should be installed.")
 else()
   set(LIBCXXABI_HEADER_DIR ${CMAKE_BINARY_DIR})
   set(LIBCXXABI_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBCXXABI_LIBDIR_SUFFIX})
-  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LIBCXXABI_LIBDIR_SUFFIX})
+  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LIBCXXABI_LIBDIR_SUFFIX} CACHE PATH
+      "Path where built libc++abi libraries should be installed.")
 endif()
 
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIBCXXABI_LIBRARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIBCXXABI_LIBRARY_DIR})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIBCXXABI_LIBRARY_DIR})
 
 # By default, for non-standalone builds, libcxx and libcxxabi share a library
 # directory.

libunwind/CMakeLists.txt

 
 # Add path for custom modules
 set(CMAKE_MODULE_PATH
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
     ${CMAKE_MODULE_PATH})
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
   set(LIBUNWIND_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})
-  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE})
+  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE} CACHE PATH
+      "Path where built libunwind libraries should be installed.")
   if(LIBCXX_LIBDIR_SUBDIR)
     string(APPEND LIBUNWIND_LIBRARY_DIR /${LIBUNWIND_LIBDIR_SUBDIR})
     string(APPEND LIBUNWIND_INSTALL_LIBRARY_DIR /${LIBUNWIND_LIBDIR_SUBDIR})
   endif()
 elseif(LLVM_LIBRARY_OUTPUT_INTDIR)
   set(LIBUNWIND_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
-  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LIBUNWIND_LIBDIR_SUFFIX})
+  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LIBUNWIND_LIBDIR_SUFFIX} CACHE PATH
+      "Path where built libunwind libraries should be installed.")
 else()
   set(LIBUNWIND_LIBRARY_DIR ${CMAKE_BINARY_DIR}/lib${LIBUNWIND_LIBDIR_SUFFIX})
-  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LIBUNWIND_LIBDIR_SUFFIX})
+  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LIBUNWIND_LIBDIR_SUFFIX} CACHE PATH
+      "Path where built libunwind libraries should be installed.")
 endif()
 
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIBUNWIND_LIBRARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIBUNWIND_LIBRARY_DIR})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIBUNWIND_LIBRARY_DIR})
 
 set(LIBUNWIND_C_FLAGS "")
 set(LIBUNWIND_CXX_FLAGS "")

libunwind/docs/BuildingLibunwind.rst

 
 .. option:: LIBUNWIND_GCC_TOOLCHAIN:PATH
 
   GCC toolchain for cross compiling
 
 .. option:: LIBUNWIND_SYSROOT
 
   Sysroot for cross compiling
+
+.. option:: LIBUNWIND_INSTALL_LIBRARY_DIR:PATH
+
+  **Default**: ``lib${LIBUNWIND_LIBDIR_SUFFIX}``
+
+  Path where built libunwind libraries should be installed. If a relative path,
+  relative to ``CMAKE_INSTALL_PREFIX``.