[cmake] Don't export `LLVM_TOOLS_INSTALL_DIR` anymore

[Ericson2314]

Summary

First of all, LLVM_TOOLS_INSTALL_DIR put there breaks our NixOS
builds, because LLVM_TOOLS_INSTALL_DIR defined the same as
CMAKE_INSTALL_BINDIR becomes an *absolute* path, and then when
downstream projects try to install there too this breaks because our
builds always install to fresh directories for isolation's sake.

Second of all, note that LLVM_TOOLS_INSTALL_DIR stands out against the
other specially crafted LLVM_CONFIG_* variables substituted in
llvm/cmake/modules/LLVMConfig.cmake.in.

@beanz added it in d0e1c2a550ef348aae036d0fe78cab6f038c420c to fix a
dangling reference in AddLLVM, but I am suspicious of how this
variable doesn't follow the pattern.

Those other ones are carefully made to be build-time vs install-time
variables depending on which LLVMConfig.cmake is being generated, are
carefully made relative as appropriate, etc. etc. For my NixOS use-case
they are also fine because they are never used as downstream install
variables, only for reading not writing.

To avoid the problems I face, and restore symmetry, I deleted the
exported and arranged to have many ${project}_TOOLS_INSTALL_DIRs.
AddLLVM now instead expects each project to define its own, and they
do so based on CMAKE_INSTALL_BINDIR. LLVMConfig still exports
LLVM_TOOLS_BINARY_DIR which is the location for the tools defined in
the usual way, matching the other remaining exported variables.

For the AddLLVM changes, I tried to copy the existing pattern of
internal vs non-internal or for LLVM vs for downstream function/macro
names, but it would good to confirm I did that correctly.

[Ericson2314]

Could one of you review this?

[protze.joachim]

I think in openmp/tools currently only libraries and header files get installed, but no binaries.

I suggest to define OPENMP_TOOLS_INSTALL_BINDIR, OPENMP_TOOLS_INSTALL_LIBDIR, and OPENMP_TOOLS_INSTALL_INCLUDEDIR and probably base these variables on OPENMP_TOOLS_INSTALL_DIR, if defined (e.g., for distro builds), or OPENMP_INSTALL_{BIN|LIB|INCLUDE}DIR as fallback.

openmp/tools/*/CMakeLists.txt should then use these variables instead of the various variables they use currently.

openmp/tools/CMakeLists.txt

1–3 ↗

(On Diff #402289)

Is this variable used anywhere?

[Ericson2314]

I moved the openmp definitions so they should be used. Don't need the other variables yet I don't think?

openmp/tools/CMakeLists.txt

1–3 ↗

(On Diff #402289)

llvm_add_tool computes a usage.

[Ericson2314]

Rebase

[Ericson2314]

@nikic @mizvekov inspired by the recent activity in D126308, I rebased this. Would you mind giving it a review or trying out a local build?

[mizvekov]

bolt/tools/CMakeLists.txt

12–14

Instead of each project having to define a different macro for this, why not just do this based on the current project in scope?
I think this would be a less invasive change.

FWIW my review can only help in these small matters of coding, I can't really review this from the perspective of the intended effect, I am just a clang developer and I never have to package or install LLVM I built myself, I just test stuff from the build dir :)

[Ericson2314]

bolt/tools/CMakeLists.txt

12–14

project is not redefined in the unified / monorepo build, so we cannot rely on it.

12–14

I am just a clang developer and I never have to package or install LLVM I built myself, I just test stuff from the build dir :)

You mean you build clang against a prebuilt LLVM? I am confused.

[nikic]

Looks reasonable to me.

[sberg]

There might be something fishy with this commit. My fresh from-scratch cmake --build . && cmake --build . --target install monorepo build now lacked e.g. the bin/clang++ symlink in the installation dir, and locally reverting this commit fixed that.

[dyung]

Just another data point, but we noticed the same issue of clang++ missing after install on our internal Windows builds, and I bisected it to this commit.

[aaron.ballman]

We saw the same thing at Intel FWIW. When I investigated it, all of the symlinks were being created as name} instead of whatever you'd expect the symlink to be named.

[nikic]

clang/cmake/modules/AddClang.cmake

183–190

Yeah, there's a typo on this line. Should be ${name}.

[Ericson2314]

Thanks for finding this and sorry for the disruption. Hope the revert didn't come to slowly.

[Ericson2314]

Fix typo

Thank you @aaron.ballman and @nikic for finding the culprit!

[Ericson2314]

openmp/tools/CMakeLists.txt

1–3 ↗

(On Diff #402289)

Moved this stuff make sure it is used properly.

[Ericson2314]

Hmm, are all those errors from running out of file system space, or might there be another issue?

[Ericson2314]

Rebase again, to try to figure out if last round of errors were spurious

[Ericson2314]

Rebase

[Ericson2314]

https://reviews.llvm.org/D130254 oh yay I learned from this the openmp failure is in fact spurious!

[nikic]

Still LGTM

[Ericson2314]

Thanks @nikic

[tstellar]

I think this commit broke our standalone builds:

CMake Error at utils/hmaptool/CMakeLists.txt:1 (install):

install PROGRAMS given no DESTINATION!

Was the LLVM_TOOLS_INSTALL_DIR in this file supposed to be changed to CLANG_TOOLS_INSTALL_DIR ?

[Ericson2314]

https://lab.llvm.org/buildbot#builders/74/builds/12262 here is a failure with only me in the blamelist, but I cannot see how those failures have anything to do with this?

[Ericson2314]

@tstellar Thank you! That is an error I do understand, and yes your example is exactly right.

Sorry, I thought I had checked every rebase that no new usages cropped up, but I guess I missed one.

[Ericson2314]

Will make patch for it.

*edit* it's https://reviews.llvm.org/D130362

[stella.stamenova]

This change broke the LLVMConfig generation and now when including llvm through LLVM_DIR in another project such as onnx-mlir, various tools no longer have the correct paths. For example, before this change:

set(LLVM_TOOLS_BINARY_DIR "${LLVM_INSTALL_PREFIX}/bin")
set(LLVM_DEFAULT_EXTERNAL_LIT "${LLVM_INSTALL_PREFIX}/bin/llvm-lit")

After this change:

set(LLVM_DEFAULT_EXTERNAL_LIT "/__w/1/b/llvm/Release/./bin/llvm-lit")
set(LLVM_TOOLS_BINARY_DIR "/__w/1/b/llvm/Release/./bin")

Note that the new paths are both _absolute_ paths (which is not great for an install scenario) as well as _wrong_ because they point to the build directory even in an install scenario.

The offending line is actually one that was removed from here: /llvm-project/llvm/cmake/modules/CMakeLists.txt:

extend_path(LLVM_CONFIG_TOOLS_BINARY_DIR "\${LLVM_INSTALL_PREFIX}" "${LLVM_TOOLS_INSTALL_DIR}")

Previously (before this line was removed), LLVM_CONFIG_TOOLS_BINARY_DIR was set to the join of LLVM_TOOLS_INSTALL_DIR and LLVM_INSTALL_PREFIX, but now that this is gone, it is simply set to:

set(LLVM_CONFIG_TOOLS_BINARY_DIR "${LLVM_TOOLS_BINARY_DIR}")

where LLVM_TOOLS_BINARY_DIR is an absolute path to the binary directory (which is fine for LLVMConfig in the binary tree) and LLVM_CONFIG_TOOLS_BINARY_DIR is never updated to point to an install location for the install tree.

[stella.stamenova]

In D117977#3680655, @stella.stamenova wrote:

This change broke the LLVMConfig generation and now when including llvm through LLVM_DIR in another project such as onnx-mlir, various tools no longer have the correct paths. For example, before this change:

set(LLVM_TOOLS_BINARY_DIR "${LLVM_INSTALL_PREFIX}/bin")
set(LLVM_DEFAULT_EXTERNAL_LIT "${LLVM_INSTALL_PREFIX}/bin/llvm-lit")

After this change:

set(LLVM_DEFAULT_EXTERNAL_LIT "/__w/1/b/llvm/Release/./bin/llvm-lit")
set(LLVM_TOOLS_BINARY_DIR "/__w/1/b/llvm/Release/./bin")

Note that the new paths are both _absolute_ paths (which is not great for an install scenario) as well as _wrong_ because they point to the build directory even in an install scenario.

The offending line is actually one that was removed from here: /llvm-project/llvm/cmake/modules/CMakeLists.txt:

extend_path(LLVM_CONFIG_TOOLS_BINARY_DIR "\${LLVM_INSTALL_PREFIX}" "${LLVM_TOOLS_INSTALL_DIR}")

Previously (before this line was removed), LLVM_CONFIG_TOOLS_BINARY_DIR was set to the join of LLVM_TOOLS_INSTALL_DIR and LLVM_INSTALL_PREFIX, but now that this is gone, it is simply set to:

set(LLVM_CONFIG_TOOLS_BINARY_DIR "${LLVM_TOOLS_BINARY_DIR}")

where LLVM_TOOLS_BINARY_DIR is an absolute path to the binary directory (which is fine for LLVMConfig in the binary tree) and LLVM_CONFIG_TOOLS_BINARY_DIR is never updated to point to an install location for the install tree.

I am going to try https://reviews.llvm.org/D130545 which was committed today to see if it has resolved the issue. Linking here for reference.

[Ericson2314]

Thanks @stella.stamenova for looking into this. I agree the extend_path should go back so it properly becomes the install dir. I can't think why I removed it in the first place! The point was to not export the other var, and indeed having that one properly alternate between the build dir vs install dir is why we can get rid of exporting the other one.

bolt/tools/CMakeLists.txt

+set(BOLT_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
+    "Path for binary subdirectory (defaults to '${CMAKE_INSTALL_BINDIR}')")
+mark_as_advanced(BOLT_TOOLS_INSTALL_DIR)
+
+# Move these macros to AddBolt if such a CMake module is ever created.
+
+macro(add_bolt_tool name)
+  llvm_add_tool(BOLT ${ARGV})
+endmacro()
+
+macro(add_bolt_tool_symlink name)
+  llvm_add_tool_symlink(BOLT ${ARGV})
+endmacro()
+
 add_subdirectory(driver)
 add_subdirectory(llvm-bolt-fuzzer)
 add_subdirectory(merge-fdata)
 add_subdirectory(heatmap)

bolt/tools/driver/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   MC
   Object
   Support
   )
 
 if (BOLT_ENABLE_RUNTIME)
   set(BOLT_DRIVER_DEPS "bolt_rt")
 else()
   set(BOLT_DRIVER_DEPS "")
 endif()
 
-add_llvm_tool(llvm-bolt
+add_bolt_tool(llvm-bolt
   llvm-bolt.cpp
 
   DEPENDS
   ${BOLT_DRIVER_DEPS}
   )
 
 target_link_libraries(llvm-bolt
   PRIVATE
   LLVMBOLTProfile
   LLVMBOLTRewrite
   LLVMBOLTUtils
   )
 
-add_llvm_tool_symlink(perf2bolt llvm-bolt)
-add_llvm_tool_symlink(llvm-boltdiff llvm-bolt)
+add_bolt_tool_symlink(perf2bolt llvm-bolt)
+add_bolt_tool_symlink(llvm-boltdiff llvm-bolt)
 
 set(BOLT_DEPENDS
   llvm-bolt
   perf2bolt
   llvm-boltdiff
   )
 
 add_custom_target(bolt DEPENDS ${BOLT_DEPENDS})

bolt/tools/heatmap/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   MC
   Object
   Support
   )
 
-add_llvm_tool(llvm-bolt-heatmap
+add_bolt_tool(llvm-bolt-heatmap
   heatmap.cpp
   )
 
 target_link_libraries(llvm-bolt-heatmap
   PRIVATE
   LLVMBOLTProfile
   LLVMBOLTRewrite
   LLVMBOLTUtils
   )
 
 set_target_properties(llvm-bolt-heatmap PROPERTIES FOLDER "BOLT")

bolt/tools/merge-fdata/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS Support)
 
-add_llvm_tool(merge-fdata
+add_bolt_tool(merge-fdata
   merge-fdata.cpp
 
   DEPENDS
   intrinsics_gen
 )
 set_target_properties(merge-fdata PROPERTIES FOLDER "BOLT")
 
 # Emit relocations for BOLT meta test (bolt/test/runtime/meta-merge-fdata.test)
 if (BOLT_INCLUDE_TESTS AND UNIX AND NOT APPLE)
   target_link_options(merge-fdata PRIVATE LINKER:--emit-relocs)
 endif()

clang/CMakeLists.txt

 if (NOT LLVM_LINK_LLVM_DYLIB AND CLANG_LINK_CLANG_DYLIB)
   message(FATAL_ERROR "Cannot set CLANG_LINK_CLANG_DYLIB=ON when "
                       "LLVM_LINK_LLVM_DYLIB=OFF")
 endif()
 
 # The libdir suffix must exactly match whatever LLVM's configuration used.
 set(CLANG_LIBDIR_SUFFIX "${LLVM_LIBDIR_SUFFIX}")
 
+set(CLANG_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
+    "Path for binary subdirectory (defaults to '${CMAKE_INSTALL_BINDIR}')")
+mark_as_advanced(CLANG_TOOLS_INSTALL_DIR)
+
 set(CLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(CLANG_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 if( CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE )
   message(FATAL_ERROR "In-source builds are not allowed. "
 "Please create a directory and run cmake "
 "from there, passing the path to this source directory as the last argument. "
 "This process created the file `CMakeCache.txt' and the directory "

clang/cmake/modules/AddClang.cmake

if (CLANG_BUILD_TOOLS)
                                  COMPONENT ${name})
       endif()
       set_property(GLOBAL APPEND PROPERTY CLANG_EXPORTS ${name})
     endif()
   endif()
 endmacro()
 
 macro(add_clang_symlink name dest)
   get_property(LLVM_DRIVER_TOOLS GLOBAL PROPERTY LLVM_DRIVER_TOOLS)
   if(LLVM_TOOL_LLVM_DRIVER_BUILD AND ${dest} IN_LIST LLVM_DRIVER_TOOLS)
     set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_TOOL_SYMLINKS ${name})
   else()
-    add_llvm_tool_symlink(${name} ${dest} ALWAYS_GENERATE)
+    llvm_add_tool_symlink(CLANG ${name} ${dest} ALWAYS_GENERATE)
     # Always generate install targets
-    llvm_install_symlink(${name} ${dest} ALWAYS_GENERATE)
+    llvm_install_symlink(CLANG ${name} ${dest} ALWAYS_GENERATE)
   endif()
 endmacro()
 
 function(clang_target_link_libraries target type)
   if (TARGET obj.${target})
     target_link_libraries(obj.${target} ${ARGN})
   endif()
 
   get_property(LLVM_DRIVER_TOOLS GLOBAL PROPERTY LLVM_DRIVER_TOOLS)

flang/CMakeLists.txt

else()
   set(BACKEND_PACKAGE_STRING "${PACKAGE_STRING}")
   set(MLIR_MAIN_SRC_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --src-root
   set(MLIR_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --includedir
   set(MLIR_TABLEGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/tools/mlir/include)
   set(MLIR_TABLEGEN_EXE $<TARGET_FILE:mlir-tblgen>)
   include_directories(SYSTEM ${MLIR_INCLUDE_DIR})
   include_directories(SYSTEM ${MLIR_TABLEGEN_OUTPUT_DIR})
 endif()
+
+set(FLANG_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
+    "Path for binary subdirectory (defaults to '${CMAKE_INSTALL_BINDIR}')")
+mark_as_advanced(FLANG_TOOLS_INSTALL_DIR)
+
 set(FLANG_INTRINSIC_MODULES_DIR ${CMAKE_BINARY_DIR}/include/flang)
 set(FLANG_INCLUDE_DIR ${FLANG_BINARY_DIR}/include)
 
 # TODO: Remove when libclangDriver is lifted out of Clang
 if(FLANG_STANDALONE_BUILD)
   set(CLANG_INCLUDE_DIR ${CLANG_INCLUDE_DIRS} )
   # No need to specify TableGen output dir as that's embedded in CLANG_DIR
 else()

flang/cmake/modules/AddFlang.cmake

if(NOT LLVM_ENABLE_IDE)
                                DEPENDS ${name}
                                COMPONENT ${name})
     endif()
     set_property(GLOBAL APPEND PROPERTY FLANG_EXPORTS ${name})
   endif()
 endmacro()
 
 macro(add_flang_symlink name dest)
-  add_llvm_tool_symlink(${name} ${dest} ALWAYS_GENERATE)
+  llvm_add_tool_symlink(FLANG ${name} ${dest} ALWAYS_GENERATE)
   # Always generate install targets
-  llvm_install_symlink(${name} ${dest} ALWAYS_GENERATE)
+  llvm_install_symlink(FLANG ${name} ${dest} ALWAYS_GENERATE)
 endmacro()
 

lld/CMakeLists.txt

if(LLVM_INCLUDE_TESTS)
     endif()
   endif()
 
   if(LLVM_HAVE_LIBXAR)
     set(XAR_LIB xar)
   endif()
 endif() # standalone
 
+set(LLD_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
+    "Path for binary subdirectory (defaults to '${CMAKE_INSTALL_BINDIR}')")
+mark_as_advanced(LLD_TOOLS_INSTALL_DIR)
+
 set(LLD_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(LLD_INCLUDE_DIR ${LLD_SOURCE_DIR}/include )
 set(LLD_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 set(LLD_VENDOR ${PACKAGE_VENDOR} CACHE STRING
   "Vendor-specific text for showing with version information.")
 
 if(LLD_VENDOR)

lld/cmake/modules/AddLLD.cmake

if(NOT CMAKE_CONFIGURATION_TYPES)
         DEPENDS ${name}
         COMPONENT ${name})
     endif()
     set_property(GLOBAL APPEND PROPERTY LLD_EXPORTS ${name})
   endif()
 endmacro()
 
 macro(add_lld_symlink name dest)
-  add_llvm_tool_symlink(${name} ${dest} ALWAYS_GENERATE)
+  llvm_add_tool_symlink(LLD ${name} ${dest} ALWAYS_GENERATE)
   # Always generate install targets
-  llvm_install_symlink(${name} ${dest} ALWAYS_GENERATE)
+  llvm_install_symlink(LLD ${name} ${dest} ALWAYS_GENERATE)
 endmacro()

llvm/cmake/modules/AddLLVM.cmake

set (LLVM_TOOLCHAIN_TOOLS
     objdump
     readelf
     size
     strings
     strip
     )
 endif()
 
-macro(add_llvm_tool name)
+macro(llvm_add_tool project name)
   cmake_parse_arguments(ARG "DEPENDS;GENERATE_DRIVER" "" "" ${ARGN})
   if( NOT LLVM_BUILD_TOOLS )
     set(EXCLUDE_FROM_ALL ON)
   endif()
   if(ARG_GENERATE_DRIVER AND LLVM_TOOL_LLVM_DRIVER_BUILD)
     generate_llvm_objects(${name} ${ARGN})
     add_custom_target(${name} DEPENDS llvm-driver)
   else()
     add_llvm_executable(${name} ${ARGN})
 
     if ( ${name} IN_LIST LLVM_TOOLCHAIN_TOOLS OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
       if( LLVM_BUILD_TOOLS )
         get_target_export_arg(${name} LLVM export_to_llvmexports)
         install(TARGETS ${name}
                 ${export_to_llvmexports}
-                RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR}
+                RUNTIME DESTINATION ${${project}_TOOLS_INSTALL_DIR}
                 COMPONENT ${name})
 
         if (NOT LLVM_ENABLE_IDE)
           add_llvm_install_targets(install-${name}
                                   DEPENDS ${name}
                                   COMPONENT ${name})
         endif()
       endif()
     endif()
     if( LLVM_BUILD_TOOLS )
       set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
     endif()
     set_target_properties(${name} PROPERTIES FOLDER "Tools")
   endif()
-endmacro(add_llvm_tool name)
+endmacro(llvm_add_tool project name)
+
+macro(add_llvm_tool name)
+  llvm_add_tool(LLVM ${ARGV})
+endmacro()
 
 
 macro(add_llvm_example name)
   if( NOT LLVM_BUILD_EXAMPLES )
     set(EXCLUDE_FROM_ALL ON)
   endif()
   add_llvm_executable(${name} ${ARGN})
   if( LLVM_BUILD_EXAMPLES )
function(llvm_install_library_symlink name dest type)
   endif()
 
   install(SCRIPT ${INSTALL_SYMLINK}
           CODE "install_symlink(${full_name} ${full_dest} ${output_dir})"
           COMPONENT ${component})
 
 endfunction()
 
-function(llvm_install_symlink name dest)
+function(llvm_install_symlink project name dest)
   get_property(LLVM_DRIVER_TOOLS GLOBAL PROPERTY LLVM_DRIVER_TOOLS)
   if(LLVM_TOOL_LLVM_DRIVER_BUILD AND ${dest} IN_LIST LLVM_DRIVER_TOOLS)
     set_property(GLOBAL APPEND PROPERTY LLVM_DRIVER_TOOL_SYMLINKS ${name})
     return()
   endif()
   cmake_parse_arguments(ARG "ALWAYS_GENERATE" "COMPONENT" "" ${ARGN})
   foreach(path ${CMAKE_MODULE_PATH})
     if(EXISTS ${path}/LLVMInstallSymlink.cmake)
function(llvm_install_symlink project name dest)
 
   set(full_name ${name}${CMAKE_EXECUTABLE_SUFFIX})
   set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
   if (${dest} STREQUAL "llvm-driver")
     set(full_dest llvm${CMAKE_EXECUTABLE_SUFFIX})
   endif()
 
   install(SCRIPT ${INSTALL_SYMLINK}
-          CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"
+          CODE "install_symlink(${full_name} ${full_dest} ${${project}_TOOLS_INSTALL_DIR})"
           COMPONENT ${component})
 
   if (NOT LLVM_ENABLE_IDE AND NOT ARG_ALWAYS_GENERATE)
     add_llvm_install_targets(install-${name}
                              DEPENDS ${name} ${dest}
                              COMPONENT ${name}
                              SYMLINK ${dest})
   endif()
 endfunction()
 
-function(add_llvm_tool_symlink link_name target)
+function(llvm_add_tool_symlink project link_name target)
   cmake_parse_arguments(ARG "ALWAYS_GENERATE" "OUTPUT_DIR" "" ${ARGN})
 
   get_property(LLVM_DRIVER_TOOLS GLOBAL PROPERTY LLVM_DRIVER_TOOLS)
 
   if (${target} IN_LIST LLVM_DRIVER_TOOLS)
     string(REPLACE "-" "_" tool_entry ${target})
     string(REPLACE "-" "_" key ${link_name})
     string(REPLACE "llvm-" "" tool_name ${link_name})
else()
     set_target_properties(${target_name} PROPERTIES FOLDER Tools)
 
     # Make sure both the link and target are toolchain tools
     if (${link_name} IN_LIST LLVM_TOOLCHAIN_TOOLS AND ${target} IN_LIST LLVM_TOOLCHAIN_TOOLS)
       set(TOOL_IS_TOOLCHAIN ON)
     endif()
 
     if ((TOOL_IS_TOOLCHAIN OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY) AND LLVM_BUILD_TOOLS)
-      llvm_install_symlink(${link_name} ${target})
+      llvm_install_symlink("${project}" ${link_name} ${target})
     endif()
   endif()
 endfunction()
 
+function(add_llvm_tool_symlink link_name target)
+  llvm_add_tool_symlink(LLVM ${ARGV})
+endfunction()
+
 function(llvm_externalize_debuginfo name)
   if(NOT LLVM_EXTERNALIZE_DEBUGINFO)
     return()
   endif()
 
   if(NOT LLVM_EXTERNALIZE_DEBUGINFO_SKIP_STRIP)
     if(APPLE)
       if(NOT CMAKE_STRIP)

llvm/cmake/modules/CMakeLists.txt

 set(LLVM_CONFIG_LIBRARY_DIRS
   "${LLVM_CONFIG_LIBRARY_DIR}"
   # FIXME: Should there be other entries here?
   )
 list(REMOVE_DUPLICATES LLVM_CONFIG_LIBRARY_DIRS)
 
 set(LLVM_CONFIG_BINARY_DIR "\${LLVM_INSTALL_PREFIX}")
 extend_path(LLVM_CONFIG_CMAKE_DIR "\${LLVM_INSTALL_PREFIX}" "${LLVM_INSTALL_PACKAGE_DIR}")
-extend_path(LLVM_CONFIG_TOOLS_BINARY_DIR "\${LLVM_INSTALL_PREFIX}" "${LLVM_TOOLS_INSTALL_DIR}")
 
 # Generate a default location for lit
 if (LLVM_INSTALL_UTILS AND LLVM_BUILD_UTILS)
   if (CMAKE_HOST_WIN32 AND NOT CYGWIN)
     set(LLVM_CONFIG_DEFAULT_EXTERNAL_LIT "${LLVM_CONFIG_TOOLS_BINARY_DIR}/llvm-lit.py")
   else()
     set(LLVM_CONFIG_DEFAULT_EXTERNAL_LIT "${LLVM_CONFIG_TOOLS_BINARY_DIR}/llvm-lit")
   endif()

llvm/cmake/modules/LLVMConfig.cmake.in

 
 # This is a secondary one for generated files
 set(LLVM_INCLUDE_DIR "@LLVM_CONFIG_INCLUDE_DIR@")
 
 set(LLVM_DEFINITIONS "@LLVM_DEFINITIONS@")
 set(LLVM_BINARY_DIR "@LLVM_CONFIG_BINARY_DIR@")
 set(LLVM_CMAKE_DIR "@LLVM_CONFIG_CMAKE_DIR@")
 set(LLVM_TOOLS_BINARY_DIR "@LLVM_CONFIG_TOOLS_BINARY_DIR@")
-set(LLVM_TOOLS_INSTALL_DIR "@LLVM_TOOLS_INSTALL_DIR@")
 set(LLVM_HAVE_OPT_VIEWER_MODULES @LLVM_HAVE_OPT_VIEWER_MODULES@)
 set(LLVM_CONFIGURATION_TYPES @CMAKE_CONFIGURATION_TYPES@)
 set(LLVM_ENABLE_SHARED_LIBS @BUILD_SHARED_LIBS@)
 
 set(LLVM_DEFAULT_EXTERNAL_LIT "@LLVM_CONFIG_DEFAULT_EXTERNAL_LIT@")
 set(LLVM_LIT_ARGS "@LLVM_LIT_ARGS@")
 
 set(LLVM_HAVE_LIBXAR "@LLVM_HAVE_LIBXAR@")

llvm/cmake/modules/TableGen.cmake

if ((${project} STREQUAL LLVM OR ${project} STREQUAL MLIR) AND NOT LLVM_INSTALL_TOOLCHAIN_ONLY AND LLVM_BUILD_UTILS)
     if(${target} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
         NOT LLVM_DISTRIBUTION_COMPONENTS)
       set(export_to_llvmexports EXPORT LLVMExports)
     endif()
 
     install(TARGETS ${target}
             ${export_to_llvmexports}
             COMPONENT ${target}
-            RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR})
+            RUNTIME DESTINATION "${${project}_TOOLS_INSTALL_DIR}")
     if(NOT LLVM_ENABLE_IDE)
       add_llvm_install_targets("install-${target}"
                                DEPENDS ${target}
                                COMPONENT ${target})
     endif()
   endif()
   set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${target})
 endmacro()

mlir/CMakeLists.txt

if(EXISTS ${UNITTEST_DIR}/googletest/include/gtest/gtest.h)
     add_subdirectory(${UNITTEST_DIR} utils/unittest)
   endif()
 
   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
     "${CMAKE_CURRENT_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}")
   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
 endif()
 
+set(MLIR_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
+    "Path for binary subdirectory (defaults to '${CMAKE_INSTALL_BINDIR}')")
+mark_as_advanced(MLIR_TOOLS_INSTALL_DIR)
+
 set(MLIR_MAIN_SRC_DIR     ${CMAKE_CURRENT_SOURCE_DIR}  )
 set(MLIR_MAIN_INCLUDE_DIR ${MLIR_MAIN_SRC_DIR}/include )
 
 set(MLIR_SOURCE_DIR  ${CMAKE_CURRENT_SOURCE_DIR})
 set(MLIR_BINARY_DIR  ${CMAKE_CURRENT_BINARY_DIR})
 set(MLIR_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/include)
 set(MLIR_TOOLS_DIR   ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 

mlir/cmake/modules/AddMLIR.cmake

if(ARG_ENABLE_AGGREGATION)
     # In order for out-of-tree projects to build aggregates of this library,
     # we need to install the OBJECT library.
     if(MLIR_INSTALL_AGGREGATE_OBJECTS AND NOT ARG_DISABLE_INSTALL)
       add_mlir_library_install(obj.${name})
     endif()
   endif()
 endfunction(add_mlir_library)
 
+macro(add_mlir_tool name)
+  llvm_add_tool(MLIR ${ARGV})
+endmacro()
+
 # Sets a variable with a transformed list of link libraries such individual
 # libraries will be dynamically excluded when evaluated on a final library
 # which defines an MLIR_AGGREGATE_EXCLUDE_LIBS which contains any of the
 # libraries. Each link library can be a generator expression but must not
 # resolve to an arity > 1 (i.e. it can be optional).
 function(get_mlir_filtered_link_libraries output)
   set(_results)
   foreach(linklib ${ARGN})

mlir/tools/mlir-cpu-runner/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Core
   Support
   nativecodegen
   native
   )
 
-add_llvm_tool(mlir-cpu-runner
+add_mlir_tool(mlir-cpu-runner
   mlir-cpu-runner.cpp
   )
 llvm_update_compile_flags(mlir-cpu-runner)
 target_link_libraries(mlir-cpu-runner PRIVATE
   MLIRAnalysis
   MLIRExecutionEngine
   MLIRIR
   MLIRJitRunner
   MLIRLLVMDialect
   MLIRLLVMToLLVMIRTranslation
   MLIRToLLVMIRTranslationRegistration
   MLIRParser
   MLIRTargetLLVMIRExport
   MLIRSupport
   )

mlir/tools/mlir-linalg-ods-gen/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Core
   Support
   )
 
 # New mlir-linalg-ods-yaml-gen.
-add_llvm_tool(mlir-linalg-ods-yaml-gen
+add_mlir_tool(mlir-linalg-ods-yaml-gen
   mlir-linalg-ods-yaml-gen.cpp
 )
 llvm_update_compile_flags(mlir-linalg-ods-yaml-gen)
 target_link_libraries(mlir-linalg-ods-yaml-gen PRIVATE
   MLIRIR
   MLIRSupport
   MLIRParser
   )

mlir/tools/mlir-lsp-server/CMakeLists.txt

set(LIBS
   MLIRParser
   MLIRPass
   MLIRTransforms
   MLIRTransformUtils
   MLIRSupport
   MLIRIR
   )
 
-add_llvm_tool(mlir-lsp-server
+add_mlir_tool(mlir-lsp-server
   mlir-lsp-server.cpp
 
   DEPENDS
   ${LIBS}
   )
 target_link_libraries(mlir-lsp-server PRIVATE ${LIBS})
 llvm_update_compile_flags(mlir-lsp-server)
 
 mlir_check_all_link_libraries(mlir-lsp-server)

mlir/tools/mlir-opt/CMakeLists.txt

add_mlir_library(MLIRMlirOptMain
   mlir-opt.cpp
 
   EXCLUDE_FROM_LIBMLIR
 
   LINK_LIBS PUBLIC
   ${LIBS}
   )
 
-add_llvm_tool(mlir-opt
+add_mlir_tool(mlir-opt
   mlir-opt.cpp
 
   DEPENDS
   ${LIBS}
   )
 target_link_libraries(mlir-opt PRIVATE ${LIBS})
 llvm_update_compile_flags(mlir-opt)
 
 mlir_check_all_link_libraries(mlir-opt)

mlir/tools/mlir-pdll-lsp-server/CMakeLists.txt

 set(LIBS
   MLIRPdllLspServerLib
   )
 
-add_llvm_tool(mlir-pdll-lsp-server
+add_mlir_tool(mlir-pdll-lsp-server
   mlir-pdll-lsp-server.cpp
 
   DEPENDS
   ${LIBS}
   )
 
 target_link_libraries(mlir-pdll-lsp-server PRIVATE ${LIBS})
 llvm_update_compile_flags(mlir-pdll-lsp-server)
 
 mlir_check_all_link_libraries(mlir-pdll-lsp-server)

mlir/tools/mlir-reduce/CMakeLists.txt

set(LIBS
   ${dialect_libs}
   ${test_libs}
   MLIRDialect
   MLIRIR
   MLIRPass
   MLIRReduceLib
   )
 
-add_llvm_tool(mlir-reduce
+add_mlir_tool(mlir-reduce
   mlir-reduce.cpp
 
   DEPENDS
   ${LIBS}
   )
 
 target_link_libraries(mlir-reduce PRIVATE ${LIBS})
 llvm_update_compile_flags(mlir-reduce)
 
 mlir_check_all_link_libraries(mlir-reduce)

mlir/tools/mlir-spirv-cpu-runner/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Linker
 )
 
 if (MLIR_ENABLE_SPIRV_CPU_RUNNER)
   message(STATUS "Building SPIR-V CPU runner")
 
-  add_llvm_tool(mlir-spirv-cpu-runner
+  add_mlir_tool(mlir-spirv-cpu-runner
     mlir-spirv-cpu-runner.cpp
   )
 
   llvm_update_compile_flags(mlir-spirv-cpu-runner)
 
   get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
 
   target_link_libraries(mlir-spirv-cpu-runner PRIVATE

mlir/tools/mlir-translate/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(translation_libs GLOBAL PROPERTY MLIR_TRANSLATION_LIBS)
 
-add_llvm_tool(mlir-translate
+add_mlir_tool(mlir-translate
   mlir-translate.cpp
   )
 llvm_update_compile_flags(mlir-translate)
 target_link_libraries(mlir-translate
   PRIVATE
   ${dialect_libs}
   ${translation_libs}
   ${test_libs}

mlir/tools/mlir-vulkan-runner/CMakeLists.txt

if (MLIR_ENABLE_VULKAN_RUNNER)
   llvm_expand_pseudo_components(TARGET_LIBS AllTargetsCodeGens)
   # Prepend LLVM in front of every target, this is how the library
   # are named with CMake
   SET(targets_to_link)
   FOREACH(t ${TARGET_LIBS})
     LIST(APPEND targets_to_link "LLVM${t}")
   ENDFOREACH(t)
 
-  add_llvm_tool(mlir-vulkan-runner
+  add_mlir_tool(mlir-vulkan-runner
     mlir-vulkan-runner.cpp
 
     DEPENDS
     vulkan-runtime-wrappers
   )
   llvm_update_compile_flags(mlir-vulkan-runner)
   target_link_libraries(mlir-vulkan-runner PRIVATE ${LIBS})
 
 endif()

mlir/tools/tblgen-lsp-server/CMakeLists.txt

 set(LIBS
   TableGenLspServerLib
   )
 
-add_llvm_tool(tblgen-lsp-server
+add_mlir_tool(tblgen-lsp-server
   tblgen-lsp-server.cpp
 
   DEPENDS
   ${LIBS}
   )
 
 target_link_libraries(tblgen-lsp-server PRIVATE ${LIBS})
 llvm_update_compile_flags(tblgen-lsp-server)
 
 mlir_check_all_link_libraries(tblgen-lsp-server)

openmp/libomptarget/tools/CMakeLists.txt

 ##===----------------------------------------------------------------------===##
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 ##===----------------------------------------------------------------------===##
 #
 # Adding omptarget tools
 #
 ##===----------------------------------------------------------------------===##
 
+set(OPENMP_TOOLS_INSTALL_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
+    "Path for binary subdirectory (defaults to '${CMAKE_INSTALL_BINDIR}')")
+mark_as_advanced(OPENMP_TOOLS_INSTALL_DIR)
+
+# Move these macros to AddOpenMP if such a CMake module is ever created.
+
+macro(add_openmp_tool name)
+  llvm_add_tool(OPENMP ${ARGV})
+endmacro()
+
+macro(add_openmp_tool_symlink name)
+  llvm_add_tool_symlink(OPENMP ${ARGV})
+endmacro()
+
 add_subdirectory(deviceinfo)

openmp/libomptarget/tools/deviceinfo/CMakeLists.txt

 ##===----------------------------------------------------------------------===##
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 ##===----------------------------------------------------------------------===##
 #
 # Build llvm-omp-device-info tool
 #
 ##===----------------------------------------------------------------------===##
 
 libomptarget_say("Building the llvm-omp-device-info tool")
 
-add_llvm_tool(llvm-omp-device-info llvm-omp-device-info.cpp)
+add_openmp_tool(llvm-omp-device-info llvm-omp-device-info.cpp)
 
 llvm_update_compile_flags(llvm-omp-device-info)
 
 target_include_directories(llvm-omp-device-info PRIVATE
   ${LIBOMPTARGET_INCLUDE_DIR}
 )
 target_link_libraries(llvm-omp-device-info PRIVATE
   omp
   omptarget
 )