[CMake] Add option to link LLVM/subproject executables

[aidengrossman]

Summary

This patch adds in CMake option LLVM_ENABLE_LLVM_LIBC which when set to
true will detect if LLVM libc is available from the host linker, and if it is, all built
executables will be linked against the libc overlay.

[aidengrossman]

This was mentioned at the 2022 US Dev Meeting and I've talked to some people who are interested in linking LLVM against LLVM libc, so I thought I would take a stab at it. Maybe we want to emit a warning that this isn't necessarily a supported configuration given that last I heard there were some test regressions when linking LLVM against LLVM libc?

[sivachandra]

Thanks for taking a shot at this. I will try this soon and get back.

[aidengrossman]

Ping

[phosek]

I'm not against this approach, but keep in mind that we already discussed deprecating support for building runtimes with LLVM_ENABLE_PROJECTS at which point this approach is going to break. I'd be more interested in the alternative where we build a first stage Clang, then build libc as part of the runtimes build, and then build a second stage Clang and link against the libc built in the first stage. It's how we already build and link against other runtimes (builtins, libunwind, libc++abi, libc++) in our toolchain build.

[aidengrossman]

Thanks for the feedback! That's definitely a good point. I was planning on integrating this with the three stage clang builds through the use of BOOTSTRAP_ CMake options to get the same effect as the runtime builds (building with a ToT clang), but integrating it directly into the existing runtimes build at this point makes a lot more sense.

[aidengrossman]

Changed from building libc as a project and linking against that to linking against the LLVM libc overaly if available from the system. This prevents building something that should be built as a runtime as a project, ensuring that we have an up to date compiler.

In order to effectively do multi-stage builds https://reviews.llvm.org/D151624 needs to land.

[aidengrossman]

I used llvm_check_linker_flags here to test if the library can be linked against. Using find_library seems like it would be best practice, but as far as my experimentation goes, the default search paths that find_library goes through doesn't include the <compiler binary dir>../lib/<target triple> directory that stores runtime build artifacts for multi-stage builds. I'm very open to changing that element if there's a better option.

[aidengrossman]

Ping

[phosek]

In D151013#4378129, @aidengrossman wrote:

I used llvm_check_linker_flags here to test if the library can be linked against. Using find_library seems like it would be best practice, but as far as my experimentation goes, the default search paths that find_library goes through doesn't include the <compiler binary dir>../lib/<target triple> directory that stores runtime build artifacts for multi-stage builds. I'm very open to changing that element if there's a better option.

We usually use check_library_exists for these types of checks, see https://cmake.org/cmake/help/latest/module/CheckLibraryExists.html. The name of the variable should be HAVE_LLVM_LIBC for consistency with the rest of LLVM.

llvm/cmake/modules/HandleLLVMOptions.cmake

1304

Can you make it an option akin to LLVM_ENABLE_LIBCXX and also move this to llvm/CMakeLists.txt? See https://github.com/llvm/llvm-project/blob/e9ddb584e80194ab9f54e873aa733ae97da3bb95/llvm/CMakeLists.txt#L560 for reference.

[aidengrossman]

Address reviewer feedback.

[phosek]

LGTM

llvm/cmake/modules/AddLLVM.cmake

1032

This should be HAVE_LLVM_LIBC.

llvm/CMakeLists.txt

 option(LLVM_ENABLE_MODULES "Compile with C++ modules enabled." OFF)
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   option(LLVM_ENABLE_MODULE_DEBUGGING "Compile with -gmodules." ON)
 else()
   option(LLVM_ENABLE_MODULE_DEBUGGING "Compile with -gmodules." OFF)
 endif()
 option(LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY "Compile with -fmodules-local-submodule-visibility." ON)
 option(LLVM_ENABLE_LIBCXX "Use libc++ if available." OFF)
+option(LLVM_ENABLE_LLVM_LIBC "Set to on to link all LLVM executables against LLVM libc, assuming it is accessible by the host compiler." OFF)
 option(LLVM_STATIC_LINK_CXX_STDLIB "Statically link the standard library." OFF)
 option(LLVM_ENABLE_LLD "Use lld as C and C++ linker." OFF)
 option(LLVM_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 option(LLVM_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
 
 option(LLVM_ENABLE_DUMP "Enable dump functions even when assertions are disabled" OFF)
 option(LLVM_UNREACHABLE_OPTIMIZE "Optimize llvm_unreachable() as undefined behavior (default), guaranteed trap when OFF" ON)
 

llvm/cmake/modules/AddLLVM.cmake

macro(add_llvm_executable name)
   endif()
   if (LLVM_PTHREAD_LIB)
     # libpthreads overrides some standard library symbols, so main
     # executable must be linked with it in order to provide consistent
     # API for all shared libaries loaded by this executable.
     target_link_libraries(${name} PRIVATE ${LLVM_PTHREAD_LIB})
   endif()
 
+  if(HAVE_LLVM_LIBC)
+    target_link_libraries(${name} PRIVATE llvmlibc)
+  endif()
+
   llvm_codesign(${name} ENTITLEMENTS ${ARG_ENTITLEMENTS} BUNDLE_PATH ${ARG_BUNDLE_PATH})
 endmacro(add_llvm_executable name)
 
 # add_llvm_pass_plugin(name [NO_MODULE] ...)
 #   Add ${name} as an llvm plugin.
 #   If option LLVM_${name_upper}_LINK_INTO_TOOLS is set to ON, the plugin is registered statically.
 #   Otherwise a pluggable shared library is registered.
 #

llvm/cmake/modules/HandleLLVMOptions.cmake

if(LLVM_USE_RELATIVE_PATHS_IN_FILES)
   file(RELATIVE_PATH relative_root "${source_root}" "${CMAKE_BINARY_DIR}")
   append_if(SUPPORTS_FFILE_PREFIX_MAP "-ffile-prefix-map=${CMAKE_BINARY_DIR}=${relative_root}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
   append_if(SUPPORTS_FFILE_PREFIX_MAP "-ffile-prefix-map=${source_root}/=${LLVM_SOURCE_PREFIX}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
   add_flag_if_supported("-no-canonical-prefixes" NO_CANONICAL_PREFIXES)
 endif()
 
 set(LLVM_THIRD_PARTY_DIR  ${CMAKE_CURRENT_SOURCE_DIR}/../third-party CACHE STRING
     "Directory containing third party software used by LLVM (e.g. googletest)")
+
+if(LLVM_ENABLE_LLVM_LIBC)
+  check_library_exists(llvmlibc printf "" HAVE_LLVM_LIBC)
+  if(NOT HAVE_LLVM_LIBC)
+    message(WARNING "Unable to link against LLVM libc. LLVM will be built without linking against the LLVM libc overlay.")
+  endif()
+endif()

llvm/docs/CMake.rst

**LLVM_ENABLE_IDE**:BOOL
   a large number of targets. This is usually autodetected, but it can be
   configured manually to explicitly control the generation of those targets.
 
 **LLVM_ENABLE_LIBCXX**:BOOL
   If the host compiler and linker supports the stdlib flag, -stdlib=libc++ is
   passed to invocations of both so that the project is built using libc++
   instead of stdlibc++. Defaults to OFF.
 
+**LLVM_ENABLE_LLVM_LIBC**: BOOL
+  If the LLVM libc overlay is installed in a location where the host linker
+  can access it, all built executables will be linked against the LLVM libc
+  overlay before linking against the system libc. Defaults to OFF.
+
 **LLVM_ENABLE_LIBPFM**:BOOL
   Enable building with libpfm to support hardware counter measurements in LLVM
   tools.
   Defaults to ON.
 
 **LLVM_ENABLE_LLD**:BOOL
   This option is equivalent to `-DLLVM_USE_LINKER=lld`, except during a 2-stage
   build where a dependency is added from the first stage to the second ensuring