Add support for using BuildCache (CMake)

[mbitsnbites]

Summary

BuildCache [1] is a compilation cache similar to ccache (which is already supported by the LLVM CMake build system).

This change adds a CMake option, LLVM_BUILDCACHE_BUILD, that enables the use of BuildCache for accelerating LLVM builds.

[1] https://github.com/mbitsnbites/buildcache

[bogner]

I'm not sure this (or the ccache variant) is really necessary any more with modern cmake. Does this do anything different from -DCMAKE_CXX_COMPILER_LAUNCHER=buildcache in practice at this point?

If we do in fact need this we should probably look at consolidating the logic for compiler launcher workflows, rather than starting a path of duplicating this block for each one in existence.

[mbitsnbites]

Sorry for the delay.

You are correct: -DCMAKE_CXX_COMPILER_LAUNCHER=buildcache works perfectly fine, so this review is moot.

llvm/CMakeLists.txt

if(CCACHE_PROGRAM)
         set(CCACHE_PROGRAM "CCACHE_DIR=${LLVM_CCACHE_DIR} ${CCACHE_PROGRAM}")
       endif()
       set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_PROGRAM})
   else()
     message(FATAL_ERROR "Unable to find the program ccache. Set LLVM_CCACHE_BUILD to OFF")
   endif()
 endif()
 
+# Build llvm with BuildCache if the package is present
+set(LLVM_BUILDCACHE_BUILD OFF CACHE BOOL "Set to ON for a BuildCache enabled build")
+if(LLVM_BUILDCACHE_BUILD)
+  find_program(BUILDCACHE_PROGRAM buildcache)
+  if(BUILDCACHE_PROGRAM)
+      set(LLVM_BUILDCACHE_DIR "" CACHE STRING "Directory to keep BuildCached data")
+      if (LLVM_BUILDCACHE_DIR)
+        set(BUILDCACHE_PROGRAM "BUILDCACHE_DIR=${LLVM_BUILDCACHE_DIR} ${BUILDCACHE_PROGRAM}")
+      endif()
+      set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${BUILDCACHE_PROGRAM})
+  else()
+    message(FATAL_ERROR "Unable to find the program BuildCache. Set LLVM_BUILDCACHE_BUILD to OFF")
+  endif()
+endif()
+
 option(LLVM_DEPENDENCY_DEBUGGING "Dependency debugging mode to verify correctly expressed library dependencies (Darwin only)" OFF)
 
 # Some features of the LLVM build may be disallowed when dependency debugging is
-# enabled. In particular you cannot use ccache because we want to force compile
-# operations to always happen.
+# enabled. In particular you cannot use ccache or BuildCache because we want to
+# force compile operations to always happen.
 if(LLVM_DEPENDENCY_DEBUGGING)
   if(NOT CMAKE_HOST_APPLE)
     message(FATAL_ERROR "Dependency debugging is only currently supported on Darwin hosts.")
   endif()
-  if(LLVM_CCACHE_BUILD)
-    message(FATAL_ERROR "Cannot enable dependency debugging while using ccache.")
+  if(LLVM_CCACHE_BUILD OR LLVM_BUILDCACHE_BUILD)
+    message(FATAL_ERROR "Cannot enable dependency debugging while using ccache or BuildCache.")
   endif()
 endif()
 
 option(LLVM_ENABLE_DAGISEL_COV "Debug: Prints tablegen patterns that were used for selecting" OFF)
 option(LLVM_ENABLE_GISEL_COV "Enable collection of GlobalISel rule coverage" OFF)
 if(LLVM_ENABLE_GISEL_COV)
   set(LLVM_GISEL_COV_PREFIX "${CMAKE_BINARY_DIR}/gisel-coverage-" CACHE STRING "Provide a filename prefix to collect the GlobalISel rule coverage")
 endif()

llvm/docs/CMake.rst

 **LLVM_CCACHE_BUILD**:BOOL
   If enabled and the ``ccache`` program is available, then LLVM will be
   built using ``ccache`` to speed up rebuilds of LLVM and its components.
   Defaults to OFF.  The size and location of the cache maintained
   by ``ccache`` can be adjusted via the LLVM_CCACHE_MAXSIZE and LLVM_CCACHE_DIR
   options, which are passed to the CCACHE_MAXSIZE and CCACHE_DIR environment
   variables, respectively.
 
+**LLVM_BUILDCACHE_BUILD**:BOOL
+  If enabled and the ``buildcache`` program is available, then LLVM will be
+  built using ``buildcache`` to speed up rebuilds of LLVM and its components.
+  Defaults to OFF.
+
 **LLVM_FORCE_USE_OLD_TOOLCHAIN**:BOOL
   If enabled, the compiler and standard library versions won't be checked. LLVM
   may not compile at all, or might fail at runtime due to known bugs in these
   toolchains.
 
 **LLVM_TEMPORARILY_ALLOW_OLD_TOOLCHAIN**:BOOL
   If enabled, the compiler version check will only warn when using a toolchain
   which is about to be deprecated, instead of emitting an error.