[CMake][runtimes] Support monorepo layout with runtimes build

[phosek]

Summary

We introduce a new variable LLVM_ENABLE_RUNTIMES which works
similarly to LLVM_ENABLE_PROJECTS and allows specifying runtimes
that will be enabled in the runtimes build.

[beanz]

LGTM.

llvm/trunk/runtimes/CMakeLists.txt

 # Find all subdirectories containing CMake projects
 file(GLOB entries *)
 foreach(entry ${entries})
   if(IS_DIRECTORY ${entry} AND EXISTS ${entry}/CMakeLists.txt)
     list(APPEND runtimes ${entry})
   endif()
 endforeach()
 
+# Side-by-side subprojects layout.
+set(LLVM_ALL_RUNTIMES "libcxx;libcxxabi;libunwind;compiler-rt")
+set(LLVM_ENABLE_RUNTIMES "" CACHE STRING
+  "Semicolon-separated list of runtimes to build (${LLVM_ALL_RUNTIMES}), or \"all\".")
+if(LLVM_ENABLE_RUNTIMES STREQUAL "all" )
+  set(LLVM_ENABLE_RUNTIMES ${LLVM_ALL_RUNTIMES})
+endif()
+foreach(proj ${LLVM_ENABLE_RUNTIMES})
+  set(proj_dir "${CMAKE_CURRENT_SOURCE_DIR}/../../${proj}")
+  if(IS_DIRECTORY ${proj_dir} AND EXISTS ${proj_dir}/CMakeLists.txt)
+    list(APPEND runtimes ${proj_dir})
+  else()
+    message(FATAL_ERROR "LLVM_ENABLE_RUNTIMES requests ${proj} but directory not found: ${proj_dir}")
+  endif()
+  string(TOUPPER "${proj}" canon_name)
+  STRING(REGEX REPLACE "-" "_" canon_name ${canon_name})
+  set(LLVM_EXTERNAL_${canon_name}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../${proj}")
+endforeach()
+
+function(get_compiler_rt_path path)
+  foreach(entry ${runtimes})
+    get_filename_component(projName ${entry} NAME)
+    if("${projName}" MATCHES "compiler-rt")
+      set(${path} ${entry} PARENT_SCOPE)
+      return()
+    endif()
+  endforeach()
+endfunction()
+
 # If this file is acting as a top-level CMake invocation, this code path is
 # triggered by the external project call for the runtimes target below.
 if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
 
   function(runtime_register_component name)
     set_property(GLOBAL APPEND PROPERTY SUB_COMPONENTS ${name})
   endfunction()
 
   cmake_minimum_required(VERSION 3.4.3)
   project(Runtimes C CXX ASM)
 
   # Add the root project's CMake modules, and the LLVM build's modules to the
   # CMake module path.
   list(INSERT CMAKE_MODULE_PATH 0
     "${CMAKE_CURRENT_SOURCE_DIR}/../cmake"
     "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/modules"
     "${LLVM_LIBRARY_DIR}/cmake/llvm"
   )
 
   # Some of the runtimes will conditionally use the compiler-rt sanitizers
   # to make this work smoothly we ensure that compiler-rt is added first in
   # the list of sub-projects. This allows other sub-projects to have checks
   # like `if(TARGET asan)` to enable building with asan.
-  foreach(entry ${runtimes})
-    if("${entry}" MATCHES "compiler-rt")
-      set(compiler_rt_path ${entry})
-      break()
-    endif()
-  endforeach()
+  get_compiler_rt_path(compiler_rt_path)
   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.
foreach(entry ${runtimes})
 
     # 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")
+      if(NOT "${projName}" MATCHES "compiler-rt")
         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_RUNTIME_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")
+      if(NOT "${projName}" MATCHES "compiler-rt")
         set(LLVM_BINARY_DIR "${LLVM_LIBRARY_DIR}/${LLVM_RUNTIMES_PREFIX}")
         set(LLVM_LIBDIR_SUFFIX "${LLVM_RUNTIMES_LIBDIR_SUFFIX}")
         set(LLVM_LIBRARY_OUTPUT_INTDIR "${LLVM_LIBRARY_DIR}/${LLVM_RUNTIMES_PREFIX}lib${LLVM_RUNTIMES_LIBDIR_SUFFIX}")
         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)
 
-    add_subdirectory(${projName})
+    add_subdirectory(${entry} ${projName})
 
     get_property(LLVM_LIT_TESTSUITES GLOBAL PROPERTY LLVM_LIT_TESTSUITES)
     get_property(LLVM_LIT_PARAMS GLOBAL PROPERTY LLVM_LIT_PARAMS)
     get_property(LLVM_LIT_DEPENDS GLOBAL PROPERTY LLVM_LIT_DEPENDS)
     get_property(LLVM_LIT_EXTRA_ARGS GLOBAL PROPERTY LLVM_LIT_EXTRA_ARGS)
 
     list(APPEND RUNTIMES_LIT_TESTSUITES ${LLVM_LIT_TESTSUITES})
     list(APPEND RUNTIMES_LIT_PARAMS ${LLVM_LIT_PARAMS})
     list(APPEND RUNTIMES_LIT_DEPENDS ${LLVM_LIT_DEPENDS})
     list(APPEND RUNTIMES_LIT_EXTRA_ARGS ${LLVM_LIT_EXTRA_ARGS})
 
     if(LLVM_RUNTIMES_TARGET)
-      if(NOT "${entry}" MATCHES "compiler-rt")
+      if(NOT "${projName}" MATCHES "compiler-rt")
         set(LLVM_BINARY_DIR "${SAFE_LLVM_BINARY_DIR}")
         set(LLVM_LIBRARY_OUTPUT_INTDIR "${SAFE_LLVM_LIBRARY_OUTPUT_INTDIR}")
         set(LLVM_RUNTIME_OUTPUT_INTDIR "${SAFE_LLVM_RUNTIME_OUTPUT_INTDIR}")
       endif()
     endif()
   endforeach()
 
   if(LLVM_INCLUDE_TESTS)

 
 else() # if this is included from LLVM's CMake
   include(LLVMExternalProjectUtils)
 
   if(NOT LLVM_BUILD_RUNTIMES)
     set(EXTRA_ARGS EXCLUDE_FROM_ALL)
   endif()
 
-  function(builtin_default_target)
+  function(builtin_default_target compiler_rt_path)
     llvm_ExternalProject_Add(builtins
-                             ${CMAKE_CURRENT_SOURCE_DIR}/compiler-rt/lib/builtins
+                             ${compiler_rt_path}/lib/builtins
                              CMAKE_ARGS -DLLVM_LIBRARY_OUTPUT_INTDIR=${LLVM_LIBRARY_DIR}
                                         -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_TOOLS_BINARY_DIR}
                                         -DCMAKE_C_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_ASM_COMPILER_TARGET=${TARGET_TRIPLE}
                                         -DCMAKE_C_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
                              PASSTHROUGH_PREFIXES COMPILER_RT
                              USE_TOOLCHAIN
                              ${EXTRA_ARGS})
   endfunction()
 
-  function(builtin_register_target target)
+  function(builtin_register_target compiler_rt_path target)
     string(REPLACE "-" ";" builtin_target_list ${target})
     foreach(item ${builtin_target_list})
       string(TOLOWER "${item}" item_lower)
       if(item_lower MATCHES "darwin")
         message(FATAL_ERROR "LLVM_BUILTIN_TARGETS isn't implemented for Darwin platform!")
       endif()
     endforeach()
 
     get_cmake_property(variableNames VARIABLES)
     foreach(variableName ${variableNames})
       if(variableName MATCHES "^BUILTINS_${target}")
         string(REPLACE "BUILTINS_${target}_" "" new_name ${variableName})
         list(APPEND ${target}_extra_args "-D${new_name}=${${variableName}}")
       endif()
     endforeach()
 
     llvm_ExternalProject_Add(builtins-${target}
-                             ${CMAKE_CURRENT_SOURCE_DIR}/compiler-rt/lib/builtins
+                             ${compiler_rt_path}/lib/builtins
                              CMAKE_ARGS -DLLVM_LIBRARY_OUTPUT_INTDIR=${LLVM_LIBRARY_DIR}
                                         -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_TOOLS_BINARY_DIR}
                                         -DCMAKE_C_COMPILER_TARGET=${target}
                                         -DCMAKE_ASM_COMPILER_TARGET=${target}
                                         -DCMAKE_C_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
                              USE_TOOLCHAIN
                              ${EXTRA_ARGS})
   endfunction()
 
   # If compiler-rt is present we need to build the builtin libraries first. This
   # is required because the other runtimes need the builtin libraries present
   # before the just-built compiler can pass the configuration tests.
-  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/compiler-rt)
+  get_compiler_rt_path(compiler_rt_path)
+  if(compiler_rt_path)
     if(NOT LLVM_BUILTIN_TARGETS)
-      builtin_default_target()
+      builtin_default_target(${compiler_rt_path})
     else()
       if("default" IN_LIST LLVM_BUILTIN_TARGETS)
-        builtin_default_target()
+        builtin_default_target(${compiler_rt_path})
         list(REMOVE_ITEM LLVM_BUILTIN_TARGETS "default")
       else()
         add_custom_target(builtins)
         add_custom_target(install-builtins)
       endif()
 
       foreach(target ${LLVM_BUILTIN_TARGETS})
-        builtin_register_target(${target})
+        builtin_register_target(${compiler_rt_path} ${target})
 
         add_dependencies(builtins builtins-${target})
         add_dependencies(install-builtins install-builtins-${target})
       endforeach()
     endif()
     set(deps builtins)
     # We don't need to depend on the builtins if we're building instrumented
     # because the next stage will use the same compiler used to build this stage.
llvm_ExternalProject_Add(runtimes
                              DEPENDS ${ARG_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_WORKS=ON
                                         -DCMAKE_CXX_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
-                             PASSTHROUGH_PREFIXES ${ARG_PREFIXES}
+                             PASSTHROUGH_PREFIXES LLVM_ENABLE_RUNTIMES
+                                                  ${ARG_PREFIXES}
                              EXTRA_TARGETS ${extra_targets}
                                            ${test_targets}
                                            ${SUB_COMPONENTS}
                                            ${SUB_CHECK_TARGETS}
                                            ${SUB_INSTALL_TARGETS}
                              USE_TOOLCHAIN
                              ${EXTRA_ARGS})
   endfunction()
llvm_ExternalProject_Add(runtimes-${name}
                                         -DCMAKE_CXX_COMPILER_TARGET=${target}
                                         -DCMAKE_ASM_COMPILER_TARGET=${target}
                                         -DCMAKE_C_COMPILER_WORKS=ON
                                         -DCMAKE_CXX_COMPILER_WORKS=ON
                                         -DCMAKE_ASM_COMPILER_WORKS=ON
                                         -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON
                                         -DLLVM_RUNTIMES_TARGET=${name}
                                         ${${name}_extra_args}
+                             PASSTHROUGH_PREFIXES LLVM_ENABLE_RUNTIMES
                              TOOLCHAIN_TOOLS clang lld llvm-ar llvm-ranlib
                              EXTRA_TARGETS ${${name}_extra_targets}
                                            ${${name}_test_targets}
                              USE_TOOLCHAIN
                              ${EXTRA_ARGS})
   endfunction()
 
   if(runtimes)