[CMake][runtimes] Support for building target variants

[phosek]

Summary

This can be used to build non-sanitized and sanitized versions of
runtimes, where sanitized versions use the just built sanitizer
which in turn may use the non-sanitized version.

[beanz]

This looks pretty cool to me.

runtimes/CMakeLists.txt

if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
   foreach(entry ${runtimes})
     if("${entry}" MATCHES "compiler-rt")
       set(compiler_rt_path ${entry})
       break()
     endif()
   endforeach()
   if(compiler_rt_path)
     list(REMOVE_ITEM runtimes ${compiler_rt_path})
+    if(NOT LLVM_BUILD_COMPILER_RT)
       list(INSERT runtimes 0 ${compiler_rt_path})
     endif()
+  endif()
 
   # LLVMConfig.cmake contains a bunch of CMake variables from the LLVM build.
   # This file is installed as part of LLVM distributions, so this can be used
   # either from a build directory or an installed LLVM.
   include(LLVMConfig)
 
   # Setting these variables will allow the sub-build to put their outputs into
   # the library and bin directories of the top-level build.
if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
 
   # Handle common options used by all runtimes.
   include(AddLLVM)
   include(HandleLLVMOptions)
 
   set(CMAKE_REQUIRED_FLAGS ${SAFE_CMAKE_REQUIRED_FLAGS})
   set(CMAKE_REQUIRED_LIBRARIES ${SAFE_CMAKE_REQUIRED_LIBRARIES})
 
+  if(NOT LLVM_RUNTIMES_PREFIX)
+    set(LLVM_RUNTIMES_PREFIX "${LLVM_RUNTIMES_TARGET}")
+  endif()
+
   foreach(entry ${runtimes})
     get_filename_component(projName ${entry} NAME)
 
     # TODO: Clean this up as part of an interface standardization
     string(REPLACE "-" "_" canon_name ${projName})
     string(TOUPPER ${canon_name} canon_name)
     # The subdirectories need to treat this as standalone builds
     set(${canon_name}_STANDALONE_BUILD On)
 
     if(LLVM_RUNTIMES_TARGET)
       if(NOT "${entry}" MATCHES "compiler-rt")
-        set(${canon_name}_INSTALL_PREFIX "lib/${LLVM_RUNTIMES_TARGET}/" CACHE STRING "" FORCE)
+        set(${canon_name}_INSTALL_PREFIX "lib/${LLVM_RUNTIMES_PREFIX}/" CACHE STRING "" FORCE)
       endif()
     endif()
 
     # Setting a variable to let sub-projects detect which other projects
     # will be included under here.
     set(HAVE_${canon_name} On)
   endforeach()
 
   set(SAFE_LLVM_BINARY_DIR ${LLVM_BINARY_DIR})
   set(SAFE_LLVM_LIBRARY_OUTPUT_INTDIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
   set(SAFE_LLVM_RUNTIMES_OUTPUT_INTDIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
 
   # We do this in two loops so that HAVE_* is set for each runtime before the
   # other runtimes are added.
   foreach(entry ${runtimes})
     get_filename_component(projName ${entry} NAME)
 
     if(LLVM_RUNTIMES_TARGET)
       if(NOT "${entry}" MATCHES "compiler-rt")
-        set(LLVM_BINARY_DIR "${LLVM_LIBRARY_DIR}/${LLVM_RUNTIMES_TARGET}")
-        set(LLVM_LIBRARY_OUTPUT_INTDIR "${LLVM_LIBRARY_DIR}/${LLVM_RUNTIMES_TARGET}/lib")
-        set(LLVM_RUNTIME_OUTPUT_INTDIR "${LLVM_TOOLS_BINARY_DIR}/${LLVM_RUNTIMES_TARGET}")
+        set(LLVM_BINARY_DIR "${LLVM_LIBRARY_DIR}/${LLVM_RUNTIMES_PREFIX}")
+        set(LLVM_LIBRARY_OUTPUT_INTDIR "${LLVM_LIBRARY_DIR}/${LLVM_RUNTIMES_PREFIX}/lib")
+        set(LLVM_RUNTIME_OUTPUT_INTDIR "${LLVM_TOOLS_BINARY_DIR}/${LLVM_RUNTIMES_PREFIX}")
       endif()
     endif()
 
     # Between each sub-project we want to cache and clear the LIT properties
     set_property(GLOBAL PROPERTY LLVM_LIT_TESTSUITES)
     set_property(GLOBAL PROPERTY LLVM_LIT_PARAMS)
     set_property(GLOBAL PROPERTY LLVM_LIT_DEPENDS)
     set_property(GLOBAL PROPERTY LLVM_LIT_EXTRA_ARGS)
foreach(entry ${runtimes})
     if(LIB_IDX EQUAL 0)
       string(SUBSTRING ${projName} 3 -1 projName)
     endif()
     list(APPEND runtime_names ${projName})
   endforeach()
 
   # runtime_register_target(target)
   #   Utility function to register external runtime target.
-  function(runtime_register_target target)
+  function(runtime_register_target target compiler_target)
     if(target STREQUAL LLVM_DEFAULT_TARGET_TRIPLE)
       include(${LLVM_BINARY_DIR}/runtimes/Components.cmake OPTIONAL)
       set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${LLVM_BINARY_DIR}/runtimes/Components.cmake)
     else()
       include(${LLVM_BINARY_DIR}/runtimes/${target}/Components.cmake OPTIONAL)
       set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${LLVM_BINARY_DIR}/runtimes/${target}/Components.cmake)
     endif()
 
-    string(REPLACE "/" ";" target_list ${target_components})
-    list(GET target_list 0 target)
-    list(LENGTH target_list target_list_len)
-    if(${target_list_len} GREATER 1)
-      list(GET target_list 1 target_variant)
+    set(${target}_deps ${deps})
+    if(NOT target STREQUAL compiler_target)
+      list(APPEND ${target}_deps runtimes-${compiler_target})
     endif()
 
     foreach(runtime_name ${runtime_names})
       list(APPEND ${target}_extra_targets
         ${runtime_name}-${target}
         install-${runtime_name}-${target})
       if(LLVM_INCLUDE_TESTS)
         list(APPEND ${target}_test_targets check-${runtime_name}-${target})
function(runtime_register_target target compiler_target)
     endforeach()
 
     if(NOT target STREQUAL LLVM_DEFAULT_TARGET_TRIPLE)
       list(APPEND ${target}_extra_args "-DLLVM_RUNTIMES_TARGET=${target}")
     endif()
 
     llvm_ExternalProject_Add(runtimes-${target}
                              ${CMAKE_CURRENT_SOURCE_DIR}
-                             DEPENDS ${deps}
+                             DEPENDS ${${target}_deps}
                              # Builtins were built separately above
                              CMAKE_ARGS -DCOMPILER_RT_BUILD_BUILTINS=Off
                                         -DLLVM_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
                                         -DLLVM_LIBRARY_DIR=${LLVM_LIBRARY_DIR}
-                                        -DCMAKE_C_COMPILER_TARGET=${target}
-                                        -DCMAKE_CXX_COMPILER_TARGET=${target}
-                                        -DCMAKE_ASM_COMPILER_TARGET=${target}
+                                        -DCMAKE_C_COMPILER_TARGET=${compiler_target}
+                                        -DCMAKE_CXX_COMPILER_TARGET=${compiler_target}
+                                        -DCMAKE_ASM_COMPILER_TARGET=${compiler_target}
                                         -DCMAKE_C_COMPILER_WORKS=ON
                                         -DCMAKE_CXX_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
                                         -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON
                                         ${${target}_extra_args}
                              TOOLCHAIN_TOOLS clang lld llvm-ar llvm-ranlib
                              PASSTHROUGH_PREFIXES ${prefixes}
                              EXTRA_TARGETS ${${target}_extra_targets}
else()
         set(test_targets "")
       endif()
 
       foreach(target ${LLVM_RUNTIME_TARGETS})
         if(target STREQUAL "default")
           set(target ${LLVM_DEFAULT_TARGET_TRIPLE})
         endif()
 
-        runtime_register_target(${target})
+        set(compiler_target ${target})
+        string(REPLACE "=" ";" target_list ${target})
+        list(GET target_list 0 target)
+        list(LENGTH target_list target_list_len)
+        if(${target_list_len} GREATER 1)
+          list(GET target_list 1 compiler_target)
+        endif()
+
+        runtime_register_target(${target} ${compiler_target})
 
         add_dependencies(runtimes runtimes-${target})
         add_dependencies(runtimes-configure runtimes-${target}-configure)
         add_dependencies(install-runtimes install-runtimes-${target})
         if(LLVM_INCLUDE_TESTS)
           add_dependencies(check-runtimes check-runtimes-${target})
           add_dependencies(runtimes-test-depends runtimes-test-depends-${target})
         endif()