[compiler-rt] Switch from llvm-config to find_package(LLVM)

[mgorny]

Summary

Replace the use of the deprecated llvm-config tool with LLVM's CMake
files for detecting LLVM in standalone builds.

[phosek]

LGTM

compiler-rt/lib/xray/tests/CMakeLists.txt

68–81

Rather than manually linking against libraries and their dependencies (which may change over time and break this code), we should use import targets provided by the LLVM CMake config: LLVMXRay and LLVMTestingSupport. That can be done in a follow up change though.

[mgorny]

compiler-rt/lib/xray/tests/CMakeLists.txt

68–81

I actually wanted to do that but couldn't figure out how. Perhaps my approach was wrong, as I was trying to get linked libraries out of target properties.

[phosek]

compiler-rt/lib/xray/tests/CMakeLists.txt

68–81

I can take a look once this change lands, it might require changes to compiler-rt helpers.

[mgorny]

Gotta figure the buildbot regression out.

[mgorny]

I'd really use some help with the buildbot failures because I can't even figure out how to reproduce them:

https://lab.llvm.org/buildbot#builders/169/builds/13146
https://lab.llvm.org/buildbot#builders/70/builds/29330
https://lab.llvm.org/buildbot#builders/37/builds/17758
https://lab.llvm.org/buildbot#builders/77/builds/23089
https://lab.llvm.org/buildbot#builders/19/builds/13338

[mgorny]

Ok, I think I know what the problem is — these buildbots rely on being able to override LLVM_CONFIG_PATH. I'm going to see if I can provide backwards compatibility with it.

[mgorny]

Add a backwards compatibility path that uses LLVM_CONFIG_PATH to locate LLVM CMake files. I think it's sufficient to use path relative to the specified location, and we don't want to actually call it.

Restore the explicit warning when LLVM is not found and the fallback path is used.

[mgorny]

@phosek, could you take another look? The only changes are on top of load_llvm_config.

[phosek]

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

274–275

Is the assumption that LLVM_CMAKE_DIR is two directories up from LLVM_CONFIG_PATH? If so, I'd consider leaving a comment here to make that clear.

Is that also correct? In my build for example, I have bin/llvm-config and lib/cmake/llvm/LLVMConfig.cmake.

[mgorny]

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

274–275

One directory up, the first call just strips the progname, i.e. it's the equivalent of:

$ dirname $(dirname /usr/lib/llvm/16/bin/llvm-config)
/usr/lib/llvm/16

I'll add a comment. According to my testing, LLVM_CMAKE_DIR works with either the exact CMake file directory or the prefix containing lib*/cmake. I went for the latter because it lets me avoid having to figure out the exact subdir. I suppose it's similar to how CMake locates these files relative to PATH.

[mgorny]

Add an explanatory comment.

[phosek]

Still LGTM, thanks for the explanation.

[mgorny]

Thanks! Let's hope it works this time.

[mstorsjo]

In D137024#3901342, @mgorny wrote:

Thanks! Let's hope it works this time.

FYI, this broke builds of mine (https://github.com/mstorsjo/llvm-mingw/actions/runs/3382275510/jobs/5617040099), but I just need to change/add a workaround so I don't think we need to revert it due to that.

My setup is that I'm building LLVM with -DLLVM_INSTALL_TOOLCHAIN_ONLY=TRUE, so it only installs toolchain binaries, but not files like LLVMConfig.cmake or the individual LLVM libraries. I then use this new toolchain to (cross-)build compiler-rt (and all other runtimes), to bootstrap new cross-sysroots.

Previously, the compiler-rt cmake files would pick up a distro-installed llvm-config and due to that, add systemwide install directories into the mix when building compiler-rt (for a potential cross target!). I worked around that by passing -DLLVM_CONFIG_PATH="" to make sure that it doesn't pick up an unrelated llvm-config binary. (https://github.com/mstorsjo/llvm-mingw/commit/3b96433cdf89e8ef444c6669254b386229dbddd9) Now after this change, it can again find unrelated LLVMConfig.cmake from the surrounding distribution, which ends up adding unexpected include directories. This time I'm working around it with https://github.com/mstorsjo/llvm-mingw/commit/486dcf32274ae6c3e0ea7916fd1e88a58742b7ca, by adding -DCMAKE_FIND_ROOT_PATH=$PREFIX/$arch-w64-mingw32 -DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ONLY, so that cmake won't find unrelated cmake files.

These workarounds are fine for me, but I wonder if it would be useful with a more direct cmake option to tell it not look for these files at all. I'm building out of the git monorepo checkout, so whatever source files and cmake scripts can be found there, but other LLVM build products (individual libraries etc) aren't available, and cmake shouldn't try to venture out on its own to find them in unexpected places.

@phosek - How does this work for general cross compilation of compiler-rt btw - when building compiler-rt for a cross target, but it finds LLVMConfig.cmake for the current host, and ends up including headers (and possibly more) from there? (If the include directory added from LLVMConfig.cmake is something like /usr/include/llvm-15 it's probably benign, but in the msys2 cases, the llvm headers are installed in the toplevel include directory, so it ended up adding the equivalent of -I/usr/include in something which is supposed to be a cross build.) I can manually mitigate this with the -DCMAKE_FIND_ROOT_PATH* options in my case, but I don't see e.g. llvm-project/llvm/runtimes doing this anywhere?

[mgorny]

These workarounds are fine for me, but I wonder if it would be useful with a more direct cmake option to tell it not look for these files at all.

CMake has something like that built-in. I think it's -DCMAKE_DISABLE_FIND_PACKAGE_LLVM=ON.

[mstorsjo]

In D137024#3905181, @mgorny wrote:

These workarounds are fine for me, but I wonder if it would be useful with a more direct cmake option to tell it not look for these files at all.

CMake has something like that built-in. I think it's -DCMAKE_DISABLE_FIND_PACKAGE_LLVM=ON.

Oh, interesting, I wasn't aware of that one.

I thought more of the lines of telling compiler-rt to entirely skip the codepaths that try to look for these bits, but maybe it's not necessary in the end. Anyway, I'll follow this effort if there are more refactorings coming up in this area.

[thetruestblue]

This breaks our use case. We run sanitizer tests built in a standalone build using a toolchain from an artifact built upstream-- the toolchain contains binaries only.
Compiler-rt tests rely on the llvm tools binary being in the PATH.

This patch removes the logic that sets the binary tools dir using llvm-config. We don't have llvmConfig.cmake in our toolchain or our build tree and relied on llvm-config to
set(LLVM_TOOLS_BINARY_DIR "${LLVM_TOOLS_BINARY_DIR}"directory.

We can work around this by setting the LLVM_TOOLS_BINARY_DIR directly (and potentially other paths... tbd).

But I think we need to reactor this cmake file so that this is considered a valid code path.

[mgorny]

In D137024#3931126, @thetruestblue wrote:

This patch removes the logic that sets the binary tools dir using llvm-config. We don't have llvmConfig.cmake in our toolchain or our build tree and relied on llvm-config to
set(LLVM_TOOLS_BINARY_DIR "${LLVM_TOOLS_BINARY_DIR}"directory.

While I sympathize with you, I don't think this is valid reason to maintain full compatibility with llvm-config. Unless i'm mistaken, its use for building other LLVM projects standalone was deprecated for a few years already, and compiler-rt was the last project to carry the compatibility code. Furthermore, skipping cmake files from LLVM seems wrong.

[thetruestblue]

While I sympathize with you, I don't think this is valid reason to maintain full compatibility with llvm-config.

I was suggesting a standalone build with LLVM_TOOLS_BINARY_DIR set directly could be a valid code path. We already have code to mock LLVMConfig.cmake. I believe that the mock and setting llvm_tools_dir directly allows compiler-rt is enough to build compiler-rt and run tests without llvm.
Or perhaps a flag to indicate we're mocking llvmconfig?

The goal is to generate compiler-rt lit test suites for an arbitrary LLVM toolchain and then run the tests against it.

Furthermore, skipping cmake files from LLVM seems wrong.

Not sure what you mean. Isn't this the default behavior for toolchain builds and standalone builds? If only compiler-rt is built, llvmconfig.cmake isn't built/added to build tree. Same for toolchains, which contain only binary files. I may be misunderstanding what you mean, though.

[delcypher]

In D137024#3931167, @mgorny wrote:

In D137024#3931126, @thetruestblue wrote:

This patch removes the logic that sets the binary tools dir using llvm-config. We don't have llvmConfig.cmake in our toolchain or our build tree and relied on llvm-config to
set(LLVM_TOOLS_BINARY_DIR "${LLVM_TOOLS_BINARY_DIR}"directory.

While I sympathize with you, I don't think this is valid reason to maintain full compatibility with llvm-config. Unless i'm mistaken, its use for building other LLVM projects standalone was deprecated for a few years already, and compiler-rt was the last project to carry the compatibility code. Furthermore, skipping cmake files from LLVM seems wrong.

@mgorny To add a bit of context to this discussion. We are not asking for compatibility with the llvm-config binary. I'm fine if that goes way, which it already has.

What we want to do is make sure is that our use case still works. I know that "skipping cmake files from LLVM seems wrong" but there is a very good reason for this. We have a testing configuration where we consume pre-built toolchains and run the compiler-rt tests against these. We use the standalone CMake configure of compiler-rt to generate the test suites, nothing actually gets built.
In this scenario the toolchain does not include LLVM CMake files because we do not ship them to customers. Making it a hard requirement to have those CMake files would prevent us from doing that kind of testing.

I suggest that @thetruestblue and I draft a patch so our intentions our clearer.

[mgorny]

Well, I'm certainly not opposed to making all the paths configurable. However, I'm not sure if having CMake file accessible one way or another wouldn't eventually be a necessity. For one thing, I would like to move more common code from standalone build codepaths of individual projects into a dedicated CMake file in LLVM (and while I don't want to speak of others, it seems that there are at least few other people who would like to see something similar done). I suppose this wouldn't be an outright blocker if llvm/cmake/Modules directory were present but I'm not 100% sure.

[tstellar]

@thetruestblue What paths besides LLVM_TOOLS_BINARY_DIR do you need?

[thetruestblue]

In D137024#3931497, @tstellar wrote:

@thetruestblue What paths besides LLVM_TOOLS_BINARY_DIR do you need?

TBD.
So far this seems like the only necessary path. But I am working to confirm this.

[tstellar]

In D137024#3931499, @thetruestblue wrote:

In D137024#3931497, @tstellar wrote:

@thetruestblue What paths besides LLVM_TOOLS_BINARY_DIR do you need?

TBD.
So far this seems like the only necessary path. But I am working to confirm this.

Ok, I just looked at the code and I think all the variables that were set by llvm-config can also be set on the command line, so you should be able to specify everything manually to get it to work. I'm curious where do you get your sources from? Do you start with the full monorepo sources or do you use the compiler-rt standalone tarball?

[mstorsjo]

In D137024#3931488, @mgorny wrote:

Well, I'm certainly not opposed to making all the paths configurable. However, I'm not sure if having CMake file accessible one way or another wouldn't eventually be a necessity. For one thing, I would like to move more common code from standalone build codepaths of individual projects into a dedicated CMake file in LLVM (and while I don't want to speak of others, it seems that there are at least few other people who would like to see something similar done). I suppose this wouldn't be an outright blocker if llvm/cmake/Modules directory were present but I'm not 100% sure.

Isn't this two kinda separate concerns? If I build llvm but only install the executables (no libLLVMSupport.a, no cmake files etc), there's no LLVMConfig.cmake. But if I have the full llvm-project monorepo around, all the cmake helper scripts are available to be found in the monorepo - there's just no LLVMConfig.cmake (which is specific for one build of the llvm tools).

[delcypher]

In D137024#3931488, @mgorny wrote:

Well, I'm certainly not opposed to making all the paths configurable. However, I'm not sure if having CMake file accessible one way or another wouldn't eventually be a necessity. For one thing, I would like to move more common code from standalone build codepaths of individual projects into a dedicated CMake file in LLVM (and while I don't want to speak of others, it seems that there are at least few other people who would like to see something similar done). I suppose this wouldn't be an outright blocker if llvm/cmake/Modules directory were present but I'm not 100% sure.

@mgorny In our use case the full llvm-project source tree is available. In fact CompilerRTMockLLVMCMakeConfig which we use currently relies on this. So I am 100% fine with CMake code being refactored out of compiler-rt to elsewhere in the source tree (if it makes sense). What we don't have available is the "build tree/install tree" LLVMConfig.cmake file (and friends) because we don't ship it in our toolchain.

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

function(get_compiler_rt_root_source_dir ROOT_DIR_VAR)
   if (NOT EXISTS "${PATH_TO_CURRENT_FILE}")
     message(FATAL_ERROR "Could not find \"${PATH_TO_CURRENT_FILE}\"")
   endif()
 
   set("${ROOT_DIR_VAR}" "${ROOT_DIR}" PARENT_SCOPE)
 endfunction()
 
 macro(load_llvm_config)
-  if (NOT LLVM_CONFIG_PATH)
-    find_program(LLVM_CONFIG_PATH "llvm-config"
-                 DOC "Path to llvm-config binary")
-    if (NOT LLVM_CONFIG_PATH)
-      message(WARNING "UNSUPPORTED COMPILER-RT CONFIGURATION DETECTED: "
-                      "llvm-config not found.\n"
-                      "Reconfigure with -DLLVM_CONFIG_PATH=path/to/llvm-config.")
-    endif()
+  if (LLVM_CONFIG_PATH AND NOT LLVM_CMAKE_DIR)
+    message(WARNING
+      "LLVM_CONFIG_PATH is deprecated, please use LLVM_CMAKE_DIR instead")
+    # Compute the path to the LLVM install prefix and pass it as LLVM_CMAKE_DIR,
+    # CMake will locate the appropriate lib*/cmake subdirectory from there.
+    # For example. for -DLLVM_CONFIG_PATH=/usr/lib/llvm/16/bin/llvm-config
+    # this will yield LLVM_CMAKE_DIR=/usr/lib/llvm/16.
+    get_filename_component(LLVM_CMAKE_DIR "${LLVM_CONFIG_PATH}" DIRECTORY)
+    get_filename_component(LLVM_CMAKE_DIR "${LLVM_CMAKE_DIR}" DIRECTORY)
   endif()
 
   # Compute path to LLVM sources assuming the monorepo layout.
   # We don't set `LLVM_MAIN_SRC_DIR` directly to avoid overriding a user provided
   # CMake cache value.
   get_compiler_rt_root_source_dir(COMPILER_RT_ROOT_SRC_PATH)
   get_filename_component(LLVM_MAIN_SRC_DIR_DEFAULT "${COMPILER_RT_ROOT_SRC_PATH}/../llvm" ABSOLUTE)
   if (NOT EXISTS "${LLVM_MAIN_SRC_DIR_DEFAULT}")
     # TODO(dliew): Remove this legacy fallback path.
     message(WARNING
       "LLVM source tree not found at \"${LLVM_MAIN_SRC_DIR_DEFAULT}\". "
       "You are not using the monorepo layout. This configuration is DEPRECATED.")
   endif()
 
-  set(FOUND_LLVM_CMAKE_DIR FALSE)
-  if (LLVM_CONFIG_PATH)
-    execute_process(
-      COMMAND ${LLVM_CONFIG_PATH} "--obj-root" "--bindir" "--libdir" "--src-root" "--includedir"
-      RESULT_VARIABLE HAD_ERROR
-      OUTPUT_VARIABLE CONFIG_OUTPUT)
-    if (HAD_ERROR)
-      message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}")
-    endif()
-    string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT})
-    list(GET CONFIG_OUTPUT 0 BINARY_DIR)
-    list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR)
-    list(GET CONFIG_OUTPUT 2 LIBRARY_DIR)
-    list(GET CONFIG_OUTPUT 3 MAIN_SRC_DIR)
-    list(GET CONFIG_OUTPUT 4 INCLUDE_DIR)
-
-    set(LLVM_BINARY_DIR ${BINARY_DIR} CACHE PATH "Path to LLVM build tree")
-    set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib")
-    set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin")
-    set(LLVM_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Paths to LLVM headers")
-
-    if (NOT EXISTS "${LLVM_MAIN_SRC_DIR_DEFAULT}")
-      # TODO(dliew): Remove this legacy fallback path.
-      message(WARNING
-        "Consulting llvm-config for the LLVM source path "
-        "as a fallback. This behavior will be removed in the future.")
-      # We don't set `LLVM_MAIN_SRC_DIR` directly to avoid overriding a user
-      # provided CMake cache value.
-      set(LLVM_MAIN_SRC_DIR_DEFAULT "${MAIN_SRC_DIR}")
-      message(STATUS "Using LLVM source path (${LLVM_MAIN_SRC_DIR_DEFAULT}) from llvm-config")
-    endif()
-
-    # Detect if we have the LLVMXRay and TestingSupport library installed and
-    # available from llvm-config.
-    execute_process(
-      COMMAND ${LLVM_CONFIG_PATH} "--ldflags" "--libs" "xray"
-      RESULT_VARIABLE HAD_ERROR
-      OUTPUT_VARIABLE CONFIG_OUTPUT
-      ERROR_QUIET)
-    if (HAD_ERROR)
-      message(WARNING "llvm-config finding xray failed with status ${HAD_ERROR}")
-      set(COMPILER_RT_HAS_LLVMXRAY FALSE)
-    else()
-      string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT})
-      list(GET CONFIG_OUTPUT 0 LDFLAGS)
-      list(GET CONFIG_OUTPUT 1 LIBLIST)
-      file(TO_CMAKE_PATH "${LDFLAGS}" LDFLAGS)
-      file(TO_CMAKE_PATH "${LIBLIST}" LIBLIST)
-      set(LLVM_XRAY_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMXRay library")
-      set(LLVM_XRAY_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMXRay")
-      set(COMPILER_RT_HAS_LLVMXRAY TRUE)
+  find_package(LLVM HINTS "${LLVM_CMAKE_DIR}")
+  if (NOT LLVM_FOUND)
+     message(WARNING "UNSUPPORTED COMPILER-RT CONFIGURATION DETECTED: "
+                     "LLVM cmake package not found.\n"
+                     "Reconfigure with -DLLVM_CMAKE_DIR=/path/to/llvm.")
+    list(APPEND CMAKE_MODULE_PATH "${LLVM_DIR}")
+    # Turn into CACHE PATHs for overwritting
+    set(LLVM_BINARY_DIR "${LLVM_BINARY_DIR}" CACHE PATH "Path to LLVM build tree")
+    set(LLVM_LIBRARY_DIR "${LLVM_LIBRARY_DIR}" CACHE PATH "Path to llvm/lib")
+    set(LLVM_TOOLS_BINARY_DIR "${LLVM_TOOLS_BINARY_DIR}" CACHE PATH "Path to llvm/bin")
+    set(LLVM_INCLUDE_DIR ${LLVM_INCLUDE_DIRS} CACHE PATH "Path to llvm/include and any other header dirs needed")
+
+    list(FIND LLVM_AVAILABLE_LIBS LLVMXRay XRAY_INDEX)
+    if (XRAY_INDEX EQUAL -1)
+      message(WARNING "LLVMXRay not found in LLVM_AVAILABLE_LIBS")
+      set(COMPILER_RT_HAS_LLVMXRAY FALSE)
     endif()
 
-    set(COMPILER_RT_HAS_LLVMTESTINGSUPPORT FALSE)
-    execute_process(
-      COMMAND ${LLVM_CONFIG_PATH} "--ldflags" "--libs" "testingsupport"
-      RESULT_VARIABLE HAD_ERROR
-      OUTPUT_VARIABLE CONFIG_OUTPUT
-      ERROR_QUIET)
-    if (HAD_ERROR)
-      message(WARNING "llvm-config finding testingsupport failed with status ${HAD_ERROR}")
-    elseif(COMPILER_RT_INCLUDE_TESTS)
-      string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT})
-      list(GET CONFIG_OUTPUT 0 LDFLAGS)
-      list(GET CONFIG_OUTPUT 1 LIBLIST)
-      if (LIBLIST STREQUAL "")
-        message(WARNING "testingsupport library not installed, some tests will be skipped")
-      else()
-        file(TO_CMAKE_PATH "${LDFLAGS}" LDFLAGS)
-        file(TO_CMAKE_PATH "${LIBLIST}" LIBLIST)
-        set(LLVM_TESTINGSUPPORT_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMTestingSupport library")
-        set(LLVM_TESTINGSUPPORT_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMTestingSupport")
-        set(COMPILER_RT_HAS_LLVMTESTINGSUPPORT TRUE)
-      endif()
-    endif()
+    list(FIND LLVM_AVAILABLE_LIBS LLVMTestingSupport TESTINGSUPPORT_INDEX)
+    if (TESTINGSUPPORT_INDEX EQUAL -1)
+      message(WARNING "LLVMTestingSupport not found in LLVM_AVAILABLE_LIBS")
+      set(COMPILER_RT_HAS_LLVMTESTINGSUPPORT FALSE)
 
-    # Make use of LLVM CMake modules.
-    # --cmakedir is supported since llvm r291218 (4.0 release)
-    execute_process(
-      COMMAND ${LLVM_CONFIG_PATH} --cmakedir
-      RESULT_VARIABLE HAD_ERROR
-      OUTPUT_VARIABLE CONFIG_OUTPUT)
-    if(NOT HAD_ERROR)
-      string(STRIP "${CONFIG_OUTPUT}" LLVM_CMAKE_DIR_FROM_LLVM_CONFIG)
-      file(TO_CMAKE_PATH ${LLVM_CMAKE_DIR_FROM_LLVM_CONFIG} LLVM_CMAKE_DIR)
-    else()
-      file(TO_CMAKE_PATH ${LLVM_BINARY_DIR} LLVM_BINARY_DIR_CMAKE_STYLE)
-      set(LLVM_CMAKE_DIR "${LLVM_BINARY_DIR_CMAKE_STYLE}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm")
-    endif()
-
-    set(LLVM_CMAKE_INCLUDE_FILE "${LLVM_CMAKE_DIR}/LLVMConfig.cmake")
-    if (EXISTS "${LLVM_CMAKE_INCLUDE_FILE}")
-      list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}")
-      # Get some LLVM variables from LLVMConfig.
-      include("${LLVM_CMAKE_INCLUDE_FILE}")
-      set(FOUND_LLVM_CMAKE_DIR TRUE)
-    else()
-      set(FOUND_LLVM_CMAKE_DIR FALSE)
-      message(WARNING "LLVM CMake path (${LLVM_CMAKE_INCLUDE_FILE}) reported by llvm-config does not exist")
-    endif()
-    unset(LLVM_CMAKE_INCLUDE_FILE)
-
-    set(LLVM_LIBRARY_OUTPUT_INTDIR
-      ${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
-  endif()
 
-  # Finally set the cache variable now that `llvm-config` has also had a chance
-  # to set `LLVM_MAIN_SRC_DIR_DEFAULT`.
   set(LLVM_MAIN_SRC_DIR "${LLVM_MAIN_SRC_DIR_DEFAULT}" CACHE PATH "Path to LLVM source tree")
   message(STATUS "LLVM_MAIN_SRC_DIR: \"${LLVM_MAIN_SRC_DIR}\"")
   if (NOT EXISTS "${LLVM_MAIN_SRC_DIR}")
     # TODO(dliew): Make this a hard error
     message(WARNING "LLVM_MAIN_SRC_DIR (${LLVM_MAIN_SRC_DIR}) does not exist. "
                     "You can override the inferred path by adding "
                     "`-DLLVM_MAIN_SRC_DIR=<path_to_llvm_src>` to your CMake invocation "
                     "where `<path_to_llvm_src>` is the path to the `llvm` directory in "
                     "the `llvm-project` repo. "
                     "This will be treated as error in the future.")
   endif()
 
-  if (NOT FOUND_LLVM_CMAKE_DIR)
+  if (NOT LLVM_FOUND)
     # This configuration tries to configure without the prescence of `LLVMConfig.cmake`. It is
     # intended for testing purposes (generating the lit test suites) and will likely not support
     # a build of the runtimes in compiler-rt.
     include(CompilerRTMockLLVMCMakeConfig)
     compiler_rt_mock_llvm_cmake_config()
   endif()
 
 endmacro()

compiler-rt/lib/xray/tests/CMakeLists.txt

set(XRAY_UNITTEST_LINK_FLAGS
   ${COMPILER_RT_CXX_LINK_LIBS})
 
 if (NOT APPLE)
   # Needed by LLVMSupport.
   append_list_if(
     LLVM_ENABLE_TERMINFO
     -l${COMPILER_RT_TERMINFO_LIB} XRAY_UNITTEST_LINK_FLAGS)
 
-  if (COMPILER_RT_STANDALONE_BUILD)
-    append_list_if(COMPILER_RT_HAS_LLVMXRAY ${LLVM_XRAY_LDFLAGS} XRAY_UNITTEST_LINK_FLAGS)
-    append_list_if(COMPILER_RT_HAS_LLVMXRAY ${LLVM_XRAY_LIBLIST} XRAY_UNITTEST_LINK_FLAGS)
-    append_list_if(COMPILER_RT_HAS_LLVMTESTINGSUPPORT
-      ${LLVM_TESTINGSUPPORT_LDFLAGS} XRAY_UNITTEST_LINK_FLAGS)
-    append_list_if(COMPILER_RT_HAS_LLVMTESTINGSUPPORT
-      ${LLVM_TESTINGSUPPORT_LIBLIST} XRAY_UNITTEST_LINK_FLAGS)
-  else()
-    # We add the library directories one at a time in our CFLAGS.
-    foreach (DIR ${LLVM_LIBRARY_DIR})
-      list(APPEND XRAY_UNITTEST_LINK_FLAGS -L${DIR})
-    endforeach()
 
+  if (COMPILER_RT_STANDALONE_BUILD)
+    if (COMPILER_RT_HAS_LLVMXRAY OR COMPILER_RT_HAS_LLVMTESTINGSUPPORT)
+      if (LLVM_LINK_LLVM_DYLIB)
+        list(APPEND XRAY_UNITTEST_LINK_FLAGS -lLLVM)
+      endif()
+    else()
+      if (COMPILER_RT_HAS_LLVMXRAY)
+        list(APPEND XRAY_UNITTEST_LINK_FLAGS -lLLVMXRay)
+      endif()
+      if (COMPILER_RT_HAS_TESTINGSUPPORT)
+        list(APPEND XRAY_UNITTEST_LINK_FLAGS -lLLVMTestingSupport)
+      endif()
+      list(APPEND XRAY_UNITTEST_LINK_FLAGS -lLLVMSupport -lLLVMDemangle)
+    endif()
+  else()
     # We also add the actual libraries to link as dependencies.
     list(APPEND XRAY_UNITTEST_LINK_FLAGS -lLLVMXRay -lLLVMSupport -lLLVMDemangle -lLLVMTestingSupport)
   endif()
 
   append_list_if(COMPILER_RT_HAS_LIBM -lm XRAY_UNITTEST_LINK_FLAGS)
   append_list_if(COMPILER_RT_HAS_LIBRT -lrt XRAY_UNITTEST_LINK_FLAGS)
   append_list_if(COMPILER_RT_HAS_LIBDL -ldl XRAY_UNITTEST_LINK_FLAGS)
   append_list_if(COMPILER_RT_HAS_LIBPTHREAD -pthread XRAY_UNITTEST_LINK_FLAGS)