[CMake] Add LLVM runtimes directory

Summary:
There are a few LLVM projects that produce runtime libraries. Ideally
runtime libraries should be built differently than other projects,
specifically they should be built using the just-built toolchain.

There is support for building compiler-rt in this way from the clang
build. Moving this logic into the LLVM build is interesting because it
provides a simpler way to extend the just-built toolchain to include
LLD and the LLVM object file tools.

Once this functionality is better fleshed out and tested we’ll want to
encapsulate it in a module that can be used for clang standalone
builds, and we’ll want to make it the default way to build compiler-rt.

With this patch applied there is no immediate change in the build.
Moving compiler-rt out from llvm/projects into llvm/runtimes enables
the functionality.

This code has a few improvements over the method provided by
LLVM_BUILD_EXTERNAL_COMPILER_RT. Specifically the sub-ninja command is
always invoked, so changes to compiler-rt source files will get built
properly, so this patch can be used for iterative development with
just-built tools.

This first patch only works with compiler-rt. Support for other
runtime projects will be coming in follow-up patches.

Reviewers: chandlerc, bogner

Subscribers: kubabrecka, llvm-commits

Differential Revision: http://reviews.llvm.org/D20992

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@273620 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 90 insertions, 0 deletions

diff --git a/runtimes/CMakeLists.txt b/runtimes/CMakeLists.txt
new file mode 100644
index 000000000000..4fe5f0036fc9
--- /dev/null
+++ b/runtimes/CMakeLists.txt
@@ -0,0 +1,90 @@
+# This file handles building LLVM runtime sub-projects.
+
+# Runtimes are different from tools or other drop-in projects because runtimes
+# should be built with the LLVM toolchain from the build directory. This file is
+# a first step to formalizing runtime build interfaces.
+
+# In the current state this file only works with compiler-rt, other runtimes
+# will work as the runtime build interface standardizes.
+
+# 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()
+
+# 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})
+
+  cmake_minimum_required(VERSION 3.4.3)
+
+  # 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_BINARY_DIR}/lib/cmake/llvm"
+  )
+
+  # 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.
+  set(LLVM_LIBRARY_OUTPUT_INTDIR ${LLVM_LIBRARY_DIR})
+  set(LLVM_RUNTIME_OUTPUT_INTDIR ${LLVM_BINARY_DIR})
+
+  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)
+
+    add_subdirectory(${projName})
+  endforeach()
+
+else() # if this is included from LLVM's CMake
+  include(LLVMExternalProjectUtils)
+
+  # 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)
+    llvm_ExternalProject_Add(builtins
+                             ${CMAKE_CURRENT_SOURCE_DIR}/compiler-rt/lib/builtins
+                             PASSTHROUGH_PREFIXES COMPILER_RT
+                             USE_TOOLCHAIN)
+    set(deps builtins)
+  endif()
+
+  # We create a list the names of all the runtime projects in all uppercase and
+  # with dashes turned to underscores. This gives us the CMake variable prefixes
+  # for all variables that will apply to runtimes.
+  foreach(entry ${runtimes})
+    get_filename_component(projName ${entry} NAME)
+    string(REPLACE "-" "_" canon_name ${projName})
+    string(TOUPPER ${canon_name} canon_name)
+    list(APPEND prefixes ${canon_name})
+  endforeach()
+
+  if(runtimes)
+    # Create a runtimes target that uses this file as its top-level CMake file.
+    # The runtimes target is a configuration of all the runtime libraries
+    # together in a single CMake invocaiton.
+    llvm_ExternalProject_Add(runtimes
+                             ${CMAKE_CURRENT_SOURCE_DIR}
+                             DEPENDS ${deps} llvm-config
+                             # Builtins were built separately above
+                             CMAKE_ARGS -DCOMPILER_RT_BUILD_BUILTINS=Off
+                             PASSTHROUGH_PREFIXES ${prefixes}
+                             USE_TOOLCHAIN)
+  endif()
+endif()