[CMake] Use LLVM_RUNTIME_TARGET in runtimes

[phosek]

Summary

This variable is separate from LLVM_DEFAULT_TARGET_TRIPLE and
LLVM_TARGET_TRIPLE and is used to as per-target directory path.

[mgorny]

runtimes/CMakeLists.txt

167

Shouldn't it be a CACHE variable?

[smeenai]

runtimes/CMakeLists.txt

165

We were previously setting LLVM_DEFAULT_TARGET_TRIPLE as part of our configure, so this CACHE setting would never take effect. We'll now set it to the host triple, which seems potentially undesirable?

[smeenai]

LGTM. I didn't realize the LLVM_TARGET_TRIPLE variable already existed and you were just making use of it in more places earlier.

runtimes/CMakeLists.txt

166–169

Should we error if this isn't set, instead of defaulting to the host triple? All call sites from the runtimes build should be setting a value, right?

[mgorny]

LGTM

[phosek]

runtimes/CMakeLists.txt

165

Great point, after thinking about this a bit more, I think it'd be best to drop LLVM_DEFAULT_TARGET_TRIPLE altogether and replace it with LLVM_TARGET_TRIPLE.

[daltenty]

This patch seem to do a bit more than it's description implies. It makes LLVM_DEFAULT_TARGET_TRIPLE no longer an valid option on the runtimes path:

CMake Warning:
  Manually-specified variables were not used by the project:

    LLVM_DEFAULT_TARGET_TRIPLE

Is this intended? Currently LLVM_DEFAULT_TARGET_TRIPLE is the only option we actually document for changing the target triple (https://llvm.org/docs/CMake.html), so now the support options seem kind of inconsistent (though I don't fully grok the intended distinction between LLVM_DEFAULT_TARGET_TRIPLE and LLVM_TARGET_TRIPLE, which may be part of the problem).

[phosek]

In D137451#3957333, @daltenty wrote:

This patch seem to do a bit more than it's description implies. It makes LLVM_DEFAULT_TARGET_TRIPLE no longer an valid option on the runtimes path:

CMake Warning:
  Manually-specified variables were not used by the project:

    LLVM_DEFAULT_TARGET_TRIPLE

Is this intended? Currently LLVM_DEFAULT_TARGET_TRIPLE is the only option we actually document for changing the target triple (https://llvm.org/docs/CMake.html), so now the support options seem kind of inconsistent (though I don't fully grok the intended distinction between LLVM_DEFAULT_TARGET_TRIPLE and LLVM_TARGET_TRIPLE, which may be part of the problem).

LLVM_DEFAULT_TARGET_TRIPLE is the default value that's used by tools like clang or llc when you don't explicitly specify --target or --triple. LLVM_TARGET_TRIPLE is the target triple we're building for. LLVM_DEFAULT_TARGET_TRIPLE is used as a the default value for LLVM_TARGET_TRIPLE but they're independent.

I couldn't come up with a use case for LLVM_DEFAULT_TARGET_TRIPLE in the runtimes build which is why I dropped it, but I'm open to revisiting that if you have other suggestions. I can also update the documentation to make sure this difference is covered.

[mstorsjo]

In D137451#3959515, @phosek wrote:

In D137451#3957333, @daltenty wrote:

This patch seem to do a bit more than it's description implies. It makes LLVM_DEFAULT_TARGET_TRIPLE no longer an valid option on the runtimes path:

CMake Warning:
  Manually-specified variables were not used by the project:

    LLVM_DEFAULT_TARGET_TRIPLE

Is this intended? Currently LLVM_DEFAULT_TARGET_TRIPLE is the only option we actually document for changing the target triple (https://llvm.org/docs/CMake.html), so now the support options seem kind of inconsistent (though I don't fully grok the intended distinction between LLVM_DEFAULT_TARGET_TRIPLE and LLVM_TARGET_TRIPLE, which may be part of the problem).

LLVM_DEFAULT_TARGET_TRIPLE is the default value that's used by tools like clang or llc when you don't explicitly specify --target or --triple. LLVM_TARGET_TRIPLE is the target triple we're building for. LLVM_DEFAULT_TARGET_TRIPLE is used as a the default value for LLVM_TARGET_TRIPLE but they're independent.

I couldn't come up with a use case for LLVM_DEFAULT_TARGET_TRIPLE in the runtimes build which is why I dropped it, but I'm open to revisiting that if you have other suggestions. I can also update the documentation to make sure this difference is covered.

I think the point that @daltenty raises, is that if you're currently building the runtimes (by manually invoking cmake on the llvm-project/runtimes directory), you might be setting LLVM_DEFAULT_TARGET_TRIPLE which previously worked for setting it, but after this patch no longer works. My branch for llvm-mingw to make it use the per-target directory does exactly that: https://github.com/mstorsjo/llvm-mingw/commit/2cf53146bb94e0cd56b36b4c71ef09753143389f

I tried setting LLVM_TARGET_TRIPLE instead of LLVM_DEFAULT_TARGET_TRIPLE here, but that doesn't seem to work - with current git main, the only way of setting the triple for the purposes of the per-target runtime directories, is to set LLVM_DEFAULT_TARGET_TRIPLE. So in that respect, it's a public interface, and it'd at least be courteous to keep the old one working for some transition time while switching to a different way of setting it.

Curiously, for compiler-rt, it seems to infer it from CMAKE_C_COMPILER_TARGET, while libcxx/libunwind/libcxxabi seem to require it to be set via LLVM_DEFAULT_TARGET_TRIPLE.

[phosek]

In D137451#4076376, @mstorsjo wrote:

In D137451#3959515, @phosek wrote:

In D137451#3957333, @daltenty wrote:

This patch seem to do a bit more than it's description implies. It makes LLVM_DEFAULT_TARGET_TRIPLE no longer an valid option on the runtimes path:

CMake Warning:
  Manually-specified variables were not used by the project:

    LLVM_DEFAULT_TARGET_TRIPLE

Is this intended? Currently LLVM_DEFAULT_TARGET_TRIPLE is the only option we actually document for changing the target triple (https://llvm.org/docs/CMake.html), so now the support options seem kind of inconsistent (though I don't fully grok the intended distinction between LLVM_DEFAULT_TARGET_TRIPLE and LLVM_TARGET_TRIPLE, which may be part of the problem).

LLVM_DEFAULT_TARGET_TRIPLE is the default value that's used by tools like clang or llc when you don't explicitly specify --target or --triple. LLVM_TARGET_TRIPLE is the target triple we're building for. LLVM_DEFAULT_TARGET_TRIPLE is used as a the default value for LLVM_TARGET_TRIPLE but they're independent.

I couldn't come up with a use case for LLVM_DEFAULT_TARGET_TRIPLE in the runtimes build which is why I dropped it, but I'm open to revisiting that if you have other suggestions. I can also update the documentation to make sure this difference is covered.

I think the point that @daltenty raises, is that if you're currently building the runtimes (by manually invoking cmake on the llvm-project/runtimes directory), you might be setting LLVM_DEFAULT_TARGET_TRIPLE which previously worked for setting it, but after this patch no longer works. My branch for llvm-mingw to make it use the per-target directory does exactly that: https://github.com/mstorsjo/llvm-mingw/commit/2cf53146bb94e0cd56b36b4c71ef09753143389f

I tried setting LLVM_TARGET_TRIPLE instead of LLVM_DEFAULT_TARGET_TRIPLE here, but that doesn't seem to work - with current git main, the only way of setting the triple for the purposes of the per-target runtime directories, is to set LLVM_DEFAULT_TARGET_TRIPLE. So in that respect, it's a public interface, and it'd at least be courteous to keep the old one working for some transition time while switching to a different way of setting it.

Curiously, for compiler-rt, it seems to infer it from CMAKE_C_COMPILER_TARGET, while libcxx/libunwind/libcxxabi seem to require it to be set via LLVM_DEFAULT_TARGET_TRIPLE.

This should be addressed in the latest version. I plan on landing this change today unless there are any concerns as a prerequisite for D140925.

[mstorsjo]

In D137451#4651362, @phosek wrote:

This should be addressed in the latest version.

Ok, so this now retains LLVM_DEFAULT_TARGET_TRIPLE as the external user-settable cache variable that controls this, while the internal code is refactored to use LLVM_RUNTIME_TARGET instead? And I guess it's possible to build this by just setting LLVM_RUNTIME_TARGET directly too, even if that's not a cache variable?

That seems reasonable to me. Would the next steps after that be to do an actual deprecation cycle - warning users if they're setting the old variable name and making LLVM_RUNTIME_TARGET a cache variable as well? And then after the next release (or later?), remove handling of the old variable name here?

[phosek]

In D137451#4651440, @mstorsjo wrote:

In D137451#4651362, @phosek wrote:

This should be addressed in the latest version.

Ok, so this now retains LLVM_DEFAULT_TARGET_TRIPLE as the external user-settable cache variable that controls this, while the internal code is refactored to use LLVM_RUNTIME_TARGET instead? And I guess it's possible to build this by just setting LLVM_RUNTIME_TARGET directly too, even if that's not a cache variable?

Yes, that's correct.

That seems reasonable to me. Would the next steps after that be to do an actual deprecation cycle - warning users if they're setting the old variable name and making LLVM_RUNTIME_TARGET a cache variable as well? And then after the next release (or later?), remove handling of the old variable name here?

That was my plan assuming we don't want to keep support for LLVM_DEFAULT_TARGET_TRIPLE which would be my preference.

[mstorsjo]

In D137451#4651752, @phosek wrote:

In D137451#4651440, @mstorsjo wrote:

That seems reasonable to me. Would the next steps after that be to do an actual deprecation cycle - warning users if they're setting the old variable name and making LLVM_RUNTIME_TARGET a cache variable as well? And then after the next release (or later?), remove handling of the old variable name here?

That was my plan assuming we don't want to keep support for LLVM_DEFAULT_TARGET_TRIPLE which would be my preference.

That sounds very good to me, if given a reasonable deprecation cycle (one major release with both setups working, with warnings suggesting moving from old to new).

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

function(get_compiler_rt_target arch variable)
   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)
+    if(COMPILER_RT_DEFAULT_TARGET_ONLY)
+      set(target ${LLVM_RUNTIME_TARGET})
+    else()
       get_compiler_rt_target(${arch} target)
+    endif()
     set(${install_dir} ${COMPILER_RT_INSTALL_LIBRARY_DIR}/${target} PARENT_SCOPE)
   else()
     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)
+    if(COMPILER_RT_DEFAULT_TARGET_ONLY)
+      set(target ${LLVM_RUNTIME_TARGET})
+    else()
       get_compiler_rt_target(${arch} target)
+    endif()
     set(${output_dir} ${COMPILER_RT_OUTPUT_LIBRARY_DIR}/${target} PARENT_SCOPE)
   else()
     set(${output_dir} ${COMPILER_RT_OUTPUT_LIBRARY_DIR} PARENT_SCOPE)
   endif()
 endfunction()
 
 # compiler_rt_process_sources(
 #   <OUTPUT_VAR>

compiler-rt/cmake/config-ix.cmake

if (IS_DIRECTORY ${MSVC_DIA_SDK_DIR})
     set(CAN_SYMBOLIZE 1)
   else()
     set(CAN_SYMBOLIZE 0)
   endif()
 else()
   set(CAN_SYMBOLIZE 1)
 endif()
 
-find_program(GNU_LD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.bfd ld.bfd DOC "GNU ld")
-find_program(GOLD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.gold ld.gold DOC "GNU gold")
+find_program(GNU_LD_EXECUTABLE NAMES ${LLVM_RUNTIME_TARGET}-ld.bfd ld.bfd DOC "GNU ld")
+find_program(GOLD_EXECUTABLE NAMES ${LLVM_RUNTIME_TARGET}-ld.gold ld.gold DOC "GNU gold")
 
 if(COMPILER_RT_SUPPORTED_ARCH)
   list(REMOVE_DUPLICATES COMPILER_RT_SUPPORTED_ARCH)
 endif()
 message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
 
 set(ALL_SANITIZERS asan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo_standalone;ubsan_minimal;gwp_asan;asan_abi)
 set(COMPILER_RT_SANITIZERS_TO_BUILD all CACHE STRING

compiler-rt/lib/builtins/CMakeLists.txt

list(INSERT CMAKE_MODULE_PATH 0
     "${COMPILER_RT_SOURCE_DIR}/cmake/Modules"
     "${LLVM_COMMON_CMAKE_UTILS}"
     "${LLVM_COMMON_CMAKE_UTILS}/Modules"
     )
 
   include(base-config-ix)
   include(CompilerRTUtils)
 
+  set(LLVM_DEFAULT_TARGET_TRIPLE "" CACHE STRING
+      "Default target for which the builtins will be built.")
+
+  set(LLVM_RUNTIME_TARGET "${LLVM_DEFAULT_TARGET_TRIPLE}")
+
   if (NOT LLVM_RUNTIMES_BUILD)
     load_llvm_config()
   endif()
   construct_compiler_rt_default_triple()
 
   include(SetPlatformToolchainTools)
   if(APPLE)
     include(CompilerRTDarwinUtils)

libc/CMakeLists.txt

 load_libc_config(${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/config.json ${cmd_line_conf})
 load_libc_config(${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_ARCHITECTURE}/config.json ${cmd_line_conf})
 
 if(LIBC_TARGET_ARCHITECTURE_IS_GPU)
   set(LIBC_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/include)
   set(LIBC_INSTALL_INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR}/gpu-none-llvm)
   set(LIBC_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
 elseif(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND LIBC_ENABLE_USE_BY_CLANG)
-  set(LIBC_INCLUDE_DIR ${LLVM_BINARY_DIR}/include/${LLVM_DEFAULT_TARGET_TRIPLE})
-  set(LIBC_INSTALL_INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})
-  set(LIBC_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})
+  set(LIBC_INCLUDE_DIR ${LLVM_BINARY_DIR}/include/${LLVM_RUNTIME_TARGET})
+  set(LIBC_INSTALL_INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR}/${LLVM_RUNTIME_TARGET})
+  set(LIBC_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_RUNTIME_TARGET})
 else()
   if(NOT LIBC_ENABLE_USE_BY_CLANG)
     set(LIBC_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/include)
     set(LIBC_LIBRARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/lib)
   elseif(LLVM_LIBRARY_OUTPUT_INTDIR)
     set(LIBC_INCLUDE_DIR ${LLVM_BINARY_DIR}/include)
     set(LIBC_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
   else()

libc/lib/CMakeLists.txt

foreach(archive IN ZIP_LISTS
   )
   list(APPEND added_archive_targets ${archive_1})
 endforeach()
 
 if(LIBC_TARGET_TRIPLE)
   set(LIBC_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LIBC_TARGET_TRIPLE})
 elseif(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT LIBC_GPU_BUILD)
   set(LIBC_INSTALL_LIBRARY_DIR
-      lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE})
+      lib${LLVM_LIBDIR_SUFFIX}/${LLVM_RUNTIME_TARGET})
 else()
   set(LIBC_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX})
 endif()
 
 install(
   TARGETS ${added_archive_targets}
   ARCHIVE DESTINATION ${LIBC_INSTALL_LIBRARY_DIR}
   COMPONENT libc-static-archives
 )
 
 add_llvm_install_targets(
   install-libc-static-archives
   DEPENDS ${added_archive_targets}
   COMPONENT libc-static-archives
 )

libcxx/CMakeLists.txt

set(LIBCXX_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}/c++/v1" CACHE STRING
     "Path where target-agnostic libc++ headers should be installed.")
 set(LIBCXX_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE STRING
     "Path where built libc++ runtime libraries should be installed.")
 
 set(LIBCXX_SHARED_OUTPUT_NAME "c++" CACHE STRING "Output name for the shared libc++ runtime library.")
 set(LIBCXX_STATIC_OUTPUT_NAME "c++" CACHE STRING "Output name for the static libc++ runtime library.")
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
-  set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})
+  set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_RUNTIME_TARGET})
   set(LIBCXX_GENERATED_INCLUDE_DIR "${LLVM_BINARY_DIR}/include/c++/v1")
   set(LIBCXX_GENERATED_MODULE_DIR "${LLVM_BINARY_DIR}/modules/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} CACHE STRING
+  set(LIBCXX_GENERATED_INCLUDE_TARGET_DIR "${LLVM_BINARY_DIR}/include/${LLVM_RUNTIME_TARGET}/c++/v1")
+  set(LIBCXX_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_RUNTIME_TARGET} CACHE STRING
       "Path where built libc++ libraries should be installed.")
-  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${CMAKE_INSTALL_INCLUDEDIR}/${LLVM_DEFAULT_TARGET_TRIPLE}/c++/v1" CACHE STRING
+  set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${CMAKE_INSTALL_INCLUDEDIR}/${LLVM_RUNTIME_TARGET}/c++/v1" CACHE STRING
       "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()
 else()
   if(LLVM_LIBRARY_OUTPUT_INTDIR)
     set(LIBCXX_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})

libcxx/docs/BuildingLibcxx.rst

.. 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``
+  ``include/${LLVM_RUNTIME_TARGET}/c++/v1``
 
   Path where target-specific libc++ headers should be installed. If a relative
   path, relative to ``CMAKE_INSTALL_PREFIX``.
 
 .. option:: LIBCXX_SHARED_OUTPUT_NAME:STRING
 
   **Default**: ``c++``
 

libcxx/lib/abi/CMakeLists.txt

function(cxx_abi_list_identifier result triple abi_library abi_version unstable exceptions new_delete_in_libcxx)
 
   list(JOIN abi_properties "." tmp)
   set(${result} "${tmp}" PARENT_SCOPE)
 endfunction()
 
 if (CMAKE_CXX_COMPILER_TARGET)
   set(triple "${CMAKE_CXX_COMPILER_TARGET}")
 else()
-  set(triple "${LLVM_DEFAULT_TARGET_TRIPLE}")
+  set(triple "${LLVM_RUNTIME_TARGET}")
 endif()
 cxx_abi_list_identifier(abi_list_identifier
   "${triple}"
   "${LIBCXX_CXX_ABI}"
   "${LIBCXX_ABI_VERSION}"
   "${LIBCXX_ABI_UNSTABLE}"
   "${LIBCXX_ENABLE_EXCEPTIONS}"
   "${LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS}"

libcxx/test/CMakeLists.txt

if (NOT LIBCXX_ENABLE_RTTI)
   serialize_lit_param(enable_rtti False)
 endif()
 
 serialize_lit_param(hardening_mode "\"${LIBCXX_HARDENING_MODE}\"")
 
 if (CMAKE_CXX_COMPILER_TARGET)
   serialize_lit_param(target_triple "\"${CMAKE_CXX_COMPILER_TARGET}\"")
 else()
-  serialize_lit_param(target_triple "\"${LLVM_DEFAULT_TARGET_TRIPLE}\"")
+  serialize_lit_param(target_triple "\"${LLVM_RUNTIME_TARGET}\"")
 endif()
 
 if (LLVM_USE_SANITIZER)
   serialize_lit_param(use_sanitizer "\"${LLVM_USE_SANITIZER}\"")
 endif()
 
 foreach(param IN LISTS LIBCXX_TEST_PARAMS)
   string(REGEX REPLACE "(.+)=(.+)" "\\1" name "${param}")

libcxxabi/CMakeLists.txt

set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   )
 
 set(LIBCXXABI_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE STRING
     "Path where built libc++abi runtime libraries should be installed.")
 
 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} CACHE STRING
+  set(LIBCXXABI_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_RUNTIME_TARGET})
+  set(LIBCXXABI_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_RUNTIME_TARGET} CACHE STRING
       "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()
 else()
   if(LLVM_LIBRARY_OUTPUT_INTDIR)
     set(LIBCXXABI_HEADER_DIR ${LLVM_BINARY_DIR})

libcxxabi/test/CMakeLists.txt

 
 if (LLVM_USE_SANITIZER)
   serialize_lit_param(use_sanitizer "\"${LLVM_USE_SANITIZER}\"")
 endif()
 
 if (CMAKE_CXX_COMPILER_TARGET)
   serialize_lit_param(target_triple "\"${CMAKE_CXX_COMPILER_TARGET}\"")
 else()
-  serialize_lit_param(target_triple "\"${LLVM_DEFAULT_TARGET_TRIPLE}\"")
+  serialize_lit_param(target_triple "\"${LLVM_RUNTIME_TARGET}\"")
 endif()
 
 foreach(param IN LISTS LIBCXXABI_TEST_PARAMS)
   string(REGEX REPLACE "(.+)=(.+)" "\\1" name "${param}")
   string(REGEX REPLACE "(.+)=(.+)" "\\2" value "${param}")
   serialize_lit_param("${name}" "\"${value}\"")
 endforeach()
 

libunwind/CMakeLists.txt

set(LIBUNWIND_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}" CACHE PATH
     "Path where built libunwind headers should be installed.")
 set(LIBUNWIND_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
     "Path where built libunwind runtime libraries should be installed.")
 
 set(LIBUNWIND_SHARED_OUTPUT_NAME "unwind" CACHE STRING "Output name for the shared libunwind runtime library.")
 set(LIBUNWIND_STATIC_OUTPUT_NAME "unwind" CACHE STRING "Output name for the static libunwind runtime library.")
 
 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} CACHE PATH
+  set(LIBUNWIND_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/${LLVM_RUNTIME_TARGET})
+  set(LIBUNWIND_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_RUNTIME_TARGET} 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()
 else()
   if(LLVM_LIBRARY_OUTPUT_INTDIR)
     set(LIBUNWIND_LIBRARY_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR})

libunwind/test/CMakeLists.txt

 
 if (LLVM_USE_SANITIZER)
   serialize_lit_param(use_sanitizer "\"${LLVM_USE_SANITIZER}\"")
 endif()
 
 if (CMAKE_CXX_COMPILER_TARGET)
   serialize_lit_param(target_triple "\"${CMAKE_CXX_COMPILER_TARGET}\"")
 else()
-  serialize_lit_param(target_triple "\"${LLVM_DEFAULT_TARGET_TRIPLE}\"")
+  serialize_lit_param(target_triple "\"${LLVM_RUNTIME_TARGET}\"")
 endif()
 
 foreach(param IN LISTS LIBUNWIND_TEST_PARAMS)
   string(REGEX REPLACE "(.+)=(.+)" "\\1" name "${param}")
   string(REGEX REPLACE "(.+)=(.+)" "\\2" value "${param}")
   serialize_lit_param("${name}" "\"${value}\"")
 endforeach()
 

llvm/CMakeLists.txt

 endif()
 
 set(LLVM_DEFAULT_TARGET_TRIPLE "${LLVM_DEFAULT_TARGET_TRIPLE_DEFAULT}" CACHE STRING
     "Default target for which LLVM will generate code." )
 message(STATUS "LLVM default target triple: ${LLVM_DEFAULT_TARGET_TRIPLE}")
 
 set(LLVM_TARGET_TRIPLE "${LLVM_DEFAULT_TARGET_TRIPLE}")
 
+# TODO: This would ideally only be set in the runtimes build, but not until
+# we deprecate support for building compiler-rt with LLVM_ENABLE_PROJECTS.
+set(LLVM_RUNTIME_TARGET "${LLVM_TARGET_TRIPLE}")
+
 if(WIN32 OR CYGWIN)
   if(BUILD_SHARED_LIBS OR LLVM_BUILD_LLVM_DYLIB)
     set(LLVM_ENABLE_PLUGINS_default ON)
   else()
     set(LLVM_ENABLE_PLUGINS_default OFF)
   endif()
 else()
   set(LLVM_ENABLE_PLUGINS_default ${LLVM_ENABLE_PIC})

llvm/cmake/modules/LLVMExternalProjectUtils.cmake

function(llvm_ExternalProject_Add name source_dir)
 
   # If CMAKE_SYSTEM_NAME is not set explicitly in the arguments passed to us,
   # reflect CMake's own default.
   if (NOT _cmake_system_name)
     set(_cmake_system_name "${CMAKE_HOST_SYSTEM_NAME}")
   endif()
 
   if(NOT ARG_TARGET_TRIPLE)
-    set(target_triple ${LLVM_DEFAULT_TARGET_TRIPLE})
+    set(target_triple ${LLVM_RUNTIME_TARGET})
   else()
     set(target_triple ${ARG_TARGET_TRIPLE})
   endif()
 
   is_msvc_triple(is_msvc_target ${target_triple})
 
   if(NOT ARG_TOOLCHAIN_TOOLS)
     set(ARG_TOOLCHAIN_TOOLS clang)

runtimes/CMakeLists.txt

 
 find_package(Python3 REQUIRED COMPONENTS Interpreter)
 
 # Host triple is used by tests to check if they are running natively.
 include(GetHostTriple)
 get_host_triple(LLVM_HOST_TRIPLE)
 message(STATUS "LLVM host triple: ${LLVM_HOST_TRIPLE}")
 
-# TODO: We shouldn't be using LLVM_DEFAULT_TARGET_TRIPLE for runtimes since we
-# aren't generating code, LLVM_TARGET_TRIPLE is a better fit.
 set(LLVM_DEFAULT_TARGET_TRIPLE "${LLVM_HOST_TRIPLE}" CACHE STRING
     "Default target for which the runtimes will be built.")
 message(STATUS "LLVM default target triple: ${LLVM_DEFAULT_TARGET_TRIPLE}")
 
-set(LLVM_TARGET_TRIPLE "${LLVM_DEFAULT_TARGET_TRIPLE}")
+set(LLVM_RUNTIME_TARGET "${LLVM_DEFAULT_TARGET_TRIPLE}")
 
 option(LLVM_INCLUDE_TESTS "Generate build targets for the runtimes unit tests." ON)
 option(LLVM_INCLUDE_DOCS "Generate build targets for the runtimes documentation." ON)
 option(LLVM_ENABLE_SPHINX "Use Sphinx to generate the runtimes documentation." OFF)
 
 # Use libtool instead of ar if you are both on an Apple host, and targeting Apple.
 if(CMAKE_HOST_APPLE AND APPLE)
   include(UseLibtool)