[cmake] Use `CMAKE_INSTALL_LIBDIR` too

[Ericson2314]

Summary

LLVM_LIBDIR_SUFFIX is kept as a deprecated way to set
CMAKE_INSTALL_LIBDIR. The other *_LIBDIR_SUFFIX are just removed
entirely.

[Ericson2314]

Forgot to define CLANG_INSTALL_LIBDIR_BASENAME

[sebastian-ne]

clang/CMakeLists.txt

52–53

Just to check if your intention aligns with my understanding, removing the suffix here is fine because the destination is in the binary dir and not the final install destination?

clang/runtime/CMakeLists.txt

90–92

nit: The indentation is wrong

compiler-rt/cmake/Modules/CompilerRTAIXUtils.cmake

65

This is an install directory, so should this be something like

extend_path(install_dir "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_LIBDIR}")

instead?

compiler-rt/cmake/base-config-ix.cmake

48

This is an install path, so should it use ${CMAKE_INSTALL_LIBDIR}/clang/${CLANG_VERSION} instead?

103–104

What is the result we expect here?
In case that CMAKE_INSTALL_LIBDIR is defined as lib64, this path will change.

In some cases it would have been lib64/clang/14.0.0/lib,
but with this patch it would be lib/clang/14.0.0/lib64 if I understand correctly.

lldb/source/API/CMakeLists.txt

119–120

It looks to me like this path is used for installation, so should it have the (potential) suffix?
In AddLLVM.cmake, _install_rpath uses ${CMAKE_INSTALL_LIBDIR}.

mlir/cmake/modules/AddMLIRPython.cmake

411–416

Same here as above, the rpath should probably use ${CMAKE_INSTALL_LIBDIR}?

[Ericson2314]

Thanks so much @sebastian-ne for the thorough review!

Unlike the other patches rather than being cleaned up code that needs more testing, this is closer to the original patch we've been using for a while (tested but not cleaned up); sorry there were so many things to catch!

clang/CMakeLists.txt

52–53

Yes exactly.

I really should write up the "rules" that I've (a) discovered from reading (b) invented somewhere. Any idea where?

clang/runtime/CMakeLists.txt

90–92

Oops, thanks.

compiler-rt/cmake/Modules/CompilerRTAIXUtils.cmake

65

Indeed, thanks for catching!

${CMAKE_INSTALL_FULL_LIBDIR} also does this.

compiler-rt/cmake/base-config-ix.cmake

48

Yes. Thanks!

103–104

Oh good point, yeah this double lib is very tricky I will fix and add comment.

lldb/source/API/CMakeLists.txt

119–120

Yes. I'll do an extend_path to handle the absolute path case too.

mlir/cmake/modules/AddMLIRPython.cmake

411–416

Agreed, and same extra comment on the fix as above too,

[Ericson2314]

Fix review comments. Thanks again!

[Ericson2314]

Add deprecation notice

[Ericson2314]

compiler-rt/cmake/Modules/CompilerRTAIXUtils.cmake

65

Actually, it will do the CMAKE_INSTALL_PREFIX part by default (and the other branch is already a potentially relative path) so just ${CMAKE_INSTALL_LIBDIR} will suffice.

[compnerd]

clang/include/clang/Config/config.h.cmake

57 ↗

(On Diff #448058)

Does this not potentially break downstreams?

[sebastian-ne]

clang/CMakeLists.txt

52–53

I think the commit message is a good place.

llvm/CMakeLists.txt

66–67

There’s also message(DEPRECATION …) :)

[Ericson2314]

clang/include/clang/Config/config.h.cmake

57 ↗

(On Diff #448058)

At the top of this file it says

/* This generated file is for internal use. Do not include it from headers. */

[ldionne]

I'm happy with this from the libc++/libc++abi side of things. You can ignore the failing CI job, it's been addressed.

[Ericson2314]

WARNING -> DEPRECATION in message call

[Ericson2314]

Rebase so libcxx and friends are hopefully fixed

[Ericson2314]

clang/CMakeLists.txt

52–53

Mmm, my philosophy is that commit messages should document relationships between the code, but the code in isolation should be documented in-tree.

I wouldn't want one to have to git log to find this information which should be a "living reference" of the current CMake idioms as currently practiced, make sense?

llvm/CMakeLists.txt

66–67

Oh nice!

[sebastian-ne]

Looks good to me, thanks!

utils/bazel/llvm-project-overlay/clang/include/clang/Config/config.h

70 ↗

(On Diff #448459)

This comment is outdated

[Ericson2314]

Rebase, fix outdated comment

[Ericson2314]

Anyone have any idea what this Debian test failure is about?

[sebastian-ne]

In D130586#3731021, @Ericson2314 wrote:

Anyone have any idea what this Debian test failure is about?

I haven’t seen a passing debian pre-merge check for months now, so I usually ignore it (the failures seems to be related to debuginfod currently).
The bazel failure seems to be a bug or flake in the build system as well.

[Ericson2314]

OK I was worried the debuginfod one was unique to this PR; glad to hear it isn't. I'll give it a shot then, thanks!

[nathanchance]

I can no longer do a two stage build on Fedora after this change.

$ cmake \
-B build/stage1 \
-DCMAKE_BUILD_TYPE=Release \
-DCMAKE_C_COMPILER=$(command -v clang) \
-DCMAKE_CXX_COMPILER=$(command -v clang++) \
-DLLVM_ENABLE_PROJECTS="clang;lld" \
-DLLVM_ENABLE_TERMINFO=OFF \
-DLLVM_TARGETS_TO_BUILD=host \
-DLLVM_USE_LINKER=$(command -v ld.lld) \
-G Ninja \
-S llvm
...

$ ninja -C build/stage1
...

$ cmake \
-B build/stage2 \
-DCLANG_TABLEGEN=$PWD/build/stage1/bin/clang-tblgen \
-DCMAKE_AR=$PWD/build/stage1/bin/llvm-ar \
-DCMAKE_BUILD_TYPE=Release \
-DCMAKE_C_COMPILER=$PWD/build/stage1/bin/clang \
-DCMAKE_CXX_COMPILER=$PWD/build/stage1/bin/clang++ \
-DCMAKE_RANLIB=$PWD/build/stage1/bin/llvm-ranlib \
-DLLVM_ENABLE_PROJECTS="clang;lld" \
-DLLVM_ENABLE_TERMINFO=OFF \
-DLLVM_TABLEGEN=$PWD/build/stage1/bin/llvm-tblgen \
-DLLVM_TARGETS_TO_BUILD=host \
-DLLVM_USE_LINKER=$PWD/build/stage1/bin/ld.lld \
-G Ninja \
-S llvm
...
-- Performing Test LLVM_LIBSTDCXX_MIN
-- Performing Test LLVM_LIBSTDCXX_MIN - Failed
CMake Error at cmake/modules/CheckCompilerVersion.cmake:88 (message):
  libstdc++ version must be at least 7.1.
Call Stack (most recent call first):
  cmake/config-ix.cmake:15 (include)
  CMakeLists.txt:810 (include)
...

$ cat build/stage2/CMakeFiles/CMakeError.log
Checking whether the ASM compiler is GNU using "--version" did not match "(GNU assembler)|(GCC)|(Free Software Foundation)":
clang version 16.0.0 (https://github.com/llvm/llvm-project f7a33090a91015836497c75f173775392ab0304d)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /home/nathan/cbl/src/llvm-project/build/stage1/bin
Performing C++ SOURCE FILE Test LLVM_LIBSTDCXX_MIN failed with the following output:
Change Dir: /home/nathan/cbl/src/llvm-project/build/stage2/CMakeFiles/CMakeTmp

Run Build Command(s):/usr/bin/ninja-build cmTC_caa1d && [1/2] Building CXX object CMakeFiles/cmTC_caa1d.dir/src.cxx.o
FAILED: CMakeFiles/cmTC_caa1d.dir/src.cxx.o
/home/nathan/cbl/src/llvm-project/build/stage1/bin/clang++ -DLLVM_LIBSTDCXX_MIN  -std=c++0x -std=c++17 -MD -MT CMakeFiles/cmTC_caa1d.dir/src.cxx.o -MF CMakeFiles/cmTC_caa1d.dir/src.cxx.o.d -o CMakeFiles/cmTC_caa1d.dir/src.cxx.o -c /home/nathan/cbl/src/llvm-project/build/stage2/CMakeFiles/CMakeTmp/src.cxx
In file included from /home/nathan/cbl/src/llvm-project/build/stage2/CMakeFiles/CMakeTmp/src.cxx:2:
In file included from /usr/lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/iosfwd:40:
In file included from /usr/lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/bits/postypes.h:40:
In file included from /usr/lib/gcc/x86_64-redhat-linux/12/../../../../include/c++/12/cwchar:44:
/usr/include/wchar.h:35:10: fatal error: 'stddef.h' file not found
#include <stddef.h>
         ^~~~~~~~~~
1 error generated.
ninja: build stopped: subcommand failed.


Source file was:

#include <iosfwd>
#if defined(__GLIBCXX__)
#if !defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE < 7
#error Unsupported libstdc++ version
#endif
#endif
int main() { return 0; }

$ fd stddef.h build/stage1
build/stage1/lib/clang/16.0.0/include/stddef.h

The parent commit is fine. If there is any further information I can provide or patches I can test, please let me know!

[craig.topper]

I seem to be unable to pass check-clang after this. A lot of tests fail because they can't find headers they need.

[smeenai]

This is breaking our build setup. It causes e.g. the Clang resource headers to be installed to lib64/clang instead of lib/clang. Given this and the other breakages, can we revert for now?

[Ericson2314]

Sorry. I have reverted this. I see why the lib and lib64 mixup could be caused by this, but I am baffled how the missing headers could be. Headers search paths should be unaffected?

[thakis]

When this relands and it's not too much trouble, it'd be nice if you could reland d3a1dbc4907b59690f9013cdb6221573ca4233f1 in the commit that relands this.

[tstellar]

In D130586#3734012, @Ericson2314 wrote:

Sorry. I have reverted this. I see why the lib and lib64 mixup could be caused by this, but I am baffled how the missing headers could be. Headers search paths should be unaffected?

I think there may be code somewhere that computes header paths as relative to the lib paths.

[Ericson2314]

Rebase; Include d3a1dbc4907b59690f9013cdb6221573ca4233f1 as requested

Thanks @thakis for letting me know.

[Ericson2314]

Rebase, fix some issues (by the looks of it)

[MaskRay]

We held off on this before as LLVM_LIBDIR_SUFFIX conflicted with it. Now we return this.

I imagine this is too potentially-breaking to make LLVM 15. That's fine. ...

These sentences are no longer relevant and should be removed.

[lebedev.ri]

What's the status here? Should this be abandoned?

clang/CMakeLists.txt

if(CLANG_BUILT_STANDALONE)
   set(LLVM_INCLUDE_DIRS ${LLVM_INCLUDE_DIRS} CACHE PATH "Path to llvm/include and any other header dirs needed")
   set(LLVM_BINARY_DIR "${LLVM_BINARY_DIR}" CACHE PATH "Path to LLVM build tree")
   set(LLVM_MAIN_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../llvm" CACHE PATH "Path to LLVM source tree")
   set(LLVM_TOOLS_BINARY_DIR "${LLVM_TOOLS_BINARY_DIR}" CACHE PATH "Path to llvm/bin")
   set(LLVM_LIBRARY_DIR "${LLVM_LIBRARY_DIR}" CACHE PATH "Path to llvm/lib")
 
   find_program(LLVM_TABLEGEN_EXE "llvm-tblgen" ${LLVM_TOOLS_BINARY_DIR}
     NO_DEFAULT_PATH)
 
   include(LLVMSetIntDirs)
 
   option(LLVM_INSTALL_TOOLCHAIN_ONLY
     "Only include toolchain files in the 'install' target." OFF)
 
   option(LLVM_FORCE_USE_OLD_HOST_TOOLCHAIN
     "Set to ON to force using an old, unsupported host toolchain." OFF)
   option(CLANG_ENABLE_BOOTSTRAP "Generate the clang bootstrap target" OFF)
   option(LLVM_ENABLE_LIBXML2 "Use libxml2 if available." ON)

 set(CLANG_LINK_CLANG_DYLIB ${LLVM_LINK_LLVM_DYLIB} CACHE BOOL
     "Link tools against libclang-cpp.so")
 
 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)
 
 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. "

 endif()
 add_subdirectory(utils/hmaptool)
 
 if(CLANG_BUILT_STANDALONE)
   llvm_distribution_add_targets()
   process_llvm_pass_plugins()
 endif()
 
-set(CLANG_INSTALL_LIBDIR_BASENAME "lib${CLANG_LIBDIR_SUFFIX}")
+set(CLANG_INSTALL_LIBDIR_BASENAME "${CMAKE_LIBDIR_BASENAME}")
 
 configure_file(
   ${CLANG_SOURCE_DIR}/include/clang/Config/config.h.cmake
   ${CLANG_BINARY_DIR}/include/clang/Config/config.h)

clang/cmake/caches/Android-stage2.cmake

 set(LLVM_TARGETS_TO_BUILD X86;ARM;AArch64 CACHE STRING "")
 
 set(CLANG_VENDOR Android CACHE STRING "")
 set(CMAKE_BUILD_TYPE Release CACHE STRING "")
 set(LLVM_ENABLE_THREADS OFF CACHE BOOL "")
 set(LLVM_ENABLE_ASSERTIONS ON CACHE BOOL "")
-set(LLVM_LIBDIR_SUFFIX 64 CACHE STRING "")
+set(CMAKE_INSTALL_LIBDIR "lib64" CACHE STRING "")
 set(LLVM_ENABLE_LIBCXX ON CACHE BOOL "")
 
 set(ANDROID_RUNTIMES_ENABLE_ASSERTIONS ON CACHE BOOL "")
 set(ANDROID_RUNTIMES_BUILD_TYPE Release CACHE STRING "")
 set(ANDROID_BUILTINS_BUILD_TYPE Release CACHE STRING "")
 
 set(LLVM_BUILTIN_TARGETS "i686-linux-android;x86_64-linux-android;aarch64-linux-android;armv7-linux-android" CACHE STRING "")
 foreach(target i686;x86_64;aarch64;armv7)

clang/cmake/caches/Android.cmake

 # This file sets up a CMakeCache for an Android toolchain build.
 
 set(LLVM_TARGETS_TO_BUILD X86 CACHE STRING "")
 
 set(CLANG_ENABLE_ARCMT OFF CACHE BOOL "")
 set(CLANG_ENABLE_STATIC_ANALYZER OFF CACHE BOOL "")
 set(CLANG_TIDY_ENABLE_STATIC_ANALYZER OFF CACHE BOOL "")
 set(CLANG_VENDOR Android CACHE STRING "")
 
 set(CMAKE_BUILD_TYPE RELEASE CACHE STRING "")
 
 set(HAVE_LIBCXXABI ON CACHE BOOL "")
 set(LLVM_BUILD_TOOLS OFF CACHE BOOL "")
 set(LLVM_ENABLE_ASSERTIONS ON CACHE BOOL "")
 set(LLVM_ENABLE_THREADS OFF CACHE BOOL "")
-set(LLVM_LIBDIR_SUFFIX 64 CACHE STRING "")
+set(CMAKE_INSTALL_LIBDIR "lib64" CACHE STRING "")
 set(LLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD OFF CACHE BOOL "")
 set(LLVM_TOOL_OPENMP_BUILD OFF CACHE BOOL "")
 set(LLVM_ENABLE_LIBCXX ON CACHE BOOL "")
 
 if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
   list(APPEND EXTRA_ARGS -DLIBCXX_ENABLE_ABI_LINKER_SCRIPT=${LIBCXX_ENABLE_ABI_LINKER_SCRIPT})
 endif()
 

clang/cmake/modules/AddClang.cmake

foreach(lib ${libs})
     if(TARGET ${lib})
       target_link_libraries(${lib} INTERFACE ${LLVM_COMMON_LIBS})
 
       if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ARG_INSTALL_WITH_TOOLCHAIN)
         get_target_export_arg(${name} Clang export_to_clangtargets UMBRELLA clang-libraries)
         install(TARGETS ${lib}
           COMPONENT ${lib}
           ${export_to_clangtargets}
-          LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
-          ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
+          LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+          ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
           RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
 
         if (NOT LLVM_ENABLE_IDE)
           add_llvm_install_targets(install-${lib}
                                    DEPENDS ${lib}
                                    COMPONENT ${lib})
         endif()
 

clang/lib/Headers/CMakeLists.txt

 
 # Other header groupings
 add_header_target("hlsl-resource-headers" ${hlsl_files})
 add_header_target("opencl-resource-headers" ${opencl_files})
 add_header_target("openmp-resource-headers" ${openmp_wrapper_files})
 add_header_target("windows-resource-headers" ${windows_only_files})
 add_header_target("utility-resource-headers" ${utility_files})
 
-set(header_install_dir lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}/include)
+set(header_install_dir ${CMAKE_INSTALL_LIBDIR}/clang/${CLANG_VERSION}/include)
 
 #############################################################
 # Install rules for the catch-all clang-resource-headers target
 install(
   FILES ${files} ${generated_files}
   DESTINATION ${header_install_dir}
   COMPONENT clang-resource-headers)
 

clang/runtime/CMakeLists.txt

CMAKE_ARGS ${CLANG_COMPILER_RT_CMAKE_ARGS}
                -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
                -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
                -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
                -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
                -DLLVM_CONFIG_PATH=${LLVM_RUNTIME_OUTPUT_INTDIR}/llvm-config
                -DLLVM_LIT_ARGS=${LLVM_LIT_ARGS}
                -DCOMPILER_RT_OUTPUT_DIR=${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION}
                -DCOMPILER_RT_EXEC_OUTPUT_DIR=${LLVM_RUNTIME_OUTPUT_INTDIR}
-               -DCOMPILER_RT_INSTALL_PATH:PATH=lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION}
+               -DCOMPILER_RT_INSTALL_PATH:PATH="${CMAKE_LIBDIR_BASENAME}/clang/${CLANG_VERSION}"
                -DCOMPILER_RT_INCLUDE_TESTS=${LLVM_INCLUDE_TESTS}
-               -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
-               -DLLVM_LIBDIR_SUFFIX=${LLVM_LIBDIR_SUFFIX}
+               -DCMAKE_INSTALL_PREFIX="${CMAKE_INSTALL_PREFIX}"
+               -DCMAKE_INSTALL_BINDIR="${CMAKE_INSTALL_BINDIR}"
+               -DCMAKE_INSTALL_LIBDIR="${CMAKE_INSTALL_LIBDIR}"
+               -DCMAKE_INSTALL_INCLUDEDIR="${CMAKE_INSTALL_INCLUDEDIR}"
                -DLLVM_RUNTIME_OUTPUT_INTDIR=${LLVM_RUNTIME_OUTPUT_INTDIR}
                -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}
                -DCMAKE_OSX_SYSROOT:PATH=${CMAKE_OSX_SYSROOT}
                ${COMPILER_RT_PASSTHROUGH_VARIABLES}
     INSTALL_COMMAND ""
     STEP_TARGETS configure build
     USES_TERMINAL_CONFIGURE 1
     USES_TERMINAL_BUILD 1

clang/tools/libclang/CMakeLists.txt

 # distribute.  Since the bindings are over libclang, which is installed
 # unbundled to the clang version, follow suit.
 foreach(PythonVersion ${CLANG_PYTHON_BINDINGS_VERSIONS})
   install(DIRECTORY
             ${CMAKE_CURRENT_SOURCE_DIR}/../../bindings/python/clang
           COMPONENT
             libclang-python-bindings
           DESTINATION
-            "lib${LLVM_LIBDIR_SUFFIX}/python${PythonVersion}/site-packages")
+            "${CMAKE_INSTALL_LIBDIR}/python${PythonVersion}/site-packages")
 endforeach()
 if(NOT LLVM_ENABLE_IDE)
   add_custom_target(libclang-python-bindings)
   add_llvm_install_targets(install-libclang-python-bindings
                            COMPONENT
                              libclang-python-bindings)
 endif()
 

clang/tools/scan-build-py/CMakeLists.txt

add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/lib/libscanbuild/${lib}
                      COMMAND ${CMAKE_COMMAND} -E make_directory
                        ${CMAKE_BINARY_DIR}/lib/libscanbuild
                      COMMAND ${CMAKE_COMMAND} -E copy
                        ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/${lib}
                        ${CMAKE_BINARY_DIR}/lib/libscanbuild/
                      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/${lib})
   list(APPEND Depends ${CMAKE_BINARY_DIR}/lib/libscanbuild/${lib})
   install(FILES lib/libscanbuild/${lib}
-          DESTINATION lib${CLANG_LIBDIR_SUFFIX}/libscanbuild
+          DESTINATION "${CMAKE_INSTALL_LIBDIR}/libscanbuild"
           COMPONENT scan-build-py)
 endforeach()
 
 foreach(resource ${LibScanbuildResources})
   add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/lib/libscanbuild/resources/${resource}
                      COMMAND ${CMAKE_COMMAND} -E make_directory
                        ${CMAKE_BINARY_DIR}/lib
                      COMMAND ${CMAKE_COMMAND} -E make_directory
                        ${CMAKE_BINARY_DIR}/lib/libscanbuild
                      COMMAND ${CMAKE_COMMAND} -E make_directory
                        ${CMAKE_BINARY_DIR}/lib/libscanbuild/resources
                      COMMAND ${CMAKE_COMMAND} -E copy
                        ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/resources/${resource}
                        ${CMAKE_BINARY_DIR}/lib/libscanbuild/resources
                      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/libscanbuild/resources/${resource})
   list(APPEND Depends ${CMAKE_BINARY_DIR}/lib/libscanbuild/resources/${resource})
   install(FILES lib/libscanbuild/resources/${resource}
-          DESTINATION lib${CLANG_LIBDIR_SUFFIX}/libscanbuild/resources
+          DESTINATION "${CMAKE_INSTALL_LIBDIR}/libscanbuild/resources"
           COMPONENT scan-build-py)
 endforeach()
 
 foreach(lib ${LibEar})
   add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/lib/libear/${lib}
                      COMMAND ${CMAKE_COMMAND} -E make_directory
                        ${CMAKE_BINARY_DIR}/lib
                      COMMAND ${CMAKE_COMMAND} -E make_directory
                        ${CMAKE_BINARY_DIR}/lib/libear
                      COMMAND ${CMAKE_COMMAND} -E copy
                        ${CMAKE_CURRENT_SOURCE_DIR}/lib/libear/${lib}
                        ${CMAKE_BINARY_DIR}/lib/libear/
                      DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/lib/libear/${lib})
   list(APPEND Depends ${CMAKE_BINARY_DIR}/lib/libear/${lib})
   install(FILES lib/libear/${lib}
-          DESTINATION lib${CLANG_LIBDIR_SUFFIX}/libear
+          DESTINATION "${CMAKE_INSTALL_LIBDIR}/libear"
           COMPONENT scan-build-py)
 endforeach()
 
 add_custom_target(scan-build-py ALL DEPENDS ${Depends})
 add_llvm_install_targets("install-scan-build-py"
                          DEPENDS scan-build-py
                          COMPONENT scan-build-py)

cmake/Modules/GNUInstallPackageDir.cmake

 # Create a cache variable with default for a path.
 macro(_GNUInstallPackageDir_cache_path var default description)
   if(NOT DEFINED ${var})
     set(${var} "${default}" CACHE PATH "${description}")
   endif()
   _GNUInstallPackageDir_cache_convert_to_path("${var}" "${description}")
 endmacro()
 
-_GNUInstallPackageDir_cache_path(CMAKE_INSTALL_PACKAGEDIR "lib${LLVM_LIBDIR_SUFFIX}/cmake"
+_GNUInstallPackageDir_cache_path(CMAKE_INSTALL_PACKAGEDIR "${CMAKE_INSTALL_LIBDIR}/cmake"
   "Directories containing installed CMake modules (lib/cmake)")

cmake/Modules/LLVMLibdirSuffix.cmake

 # Must go before the first `include(GNUInstallDirs)`.
 
 if (NOT DEFINED CMAKE_INSTALL_LIBDIR AND DEFINED LLVM_LIBDIR_SUFFIX)
+  message(DEPRECATION
+    "\"LLVM_LIBDIR_SUFFIX\" is deprecated. "
+    "Please set \"CMAKE_INSTALL_LIBDIR\" directly instead.")
   set(CMAKE_INSTALL_LIBDIR "lib${LLVM_LIBDIR_SUFFIX}")
 endif()

compiler-rt/cmake/Modules/CompilerRTAIXUtils.cmake

macro(archive_aix_libatomic name libname)
   if(objects_to_archive)
     set(output_dir "")
     set(install_dir "")
     # If LLVM defines top level library directory, we want to deliver
     # libatomic.a at top level. See `llvm/cmake/modules/AddLLVM.cmake'
     # setting _install_rpath on AIX for reference.
     if(LLVM_LIBRARY_OUTPUT_INTDIR AND CMAKE_INSTALL_PREFIX)
       set(output_dir "${LLVM_LIBRARY_OUTPUT_INTDIR}")
-      set(install_dir "${CMAKE_INSTALL_PREFIX}/lib${LLVM_LIBDIR_SUFFIX}")
+      set(install_dir "${CMAKE_INSTALL_LIBDIR}")
     else()
       get_compiler_rt_output_dir(${COMPILER_RT_DEFAULT_TARGET_ARCH} output_dir)
       get_compiler_rt_install_dir(${COMPILER_RT_DEFAULT_TARGET_ARCH} install_dir)
     endif()
     add_custom_command(OUTPUT "${output_dir}/${libname}.a"
                        COMMAND ${CMAKE_AR} -X32_64 r "${output_dir}/${libname}.a"
                        ${objects_to_archive}
                        DEPENDS ${objects_to_archive})
     install(FILES "${output_dir}/${libname}.a"
             DESTINATION ${install_dir})
     add_custom_target(aix-${libname}
                       DEPENDS "${output_dir}/${libname}.a")
     add_dependencies(${LIB_PARENT_TARGET} aix-${libname})
   endif()
 endmacro()

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

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")
+      set(LLVM_CMAKE_DIR "${LLVM_BINARY_DIR_CMAKE_STYLE}/${CMAKE_LIBDIR_BASENAME}/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})
+      "${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${CMAKE_LIBDIR_BASENAME}")
   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

compiler-rt/cmake/base-config-ix.cmake

if (LLVM_TREE_AVAILABLE)
   # Compute the Clang version from the LLVM version.
   # FIXME: We should be able to reuse CLANG_VERSION variable calculated
   #        in Clang cmake files, instead of copying the rules here.
   string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" CLANG_VERSION
          ${PACKAGE_VERSION})
   # Setup the paths where compiler-rt runtimes and headers should be stored.
   set(COMPILER_RT_OUTPUT_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}/clang/${CLANG_VERSION})
   set(COMPILER_RT_EXEC_OUTPUT_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
-  set(COMPILER_RT_INSTALL_PATH lib${LLVM_LIBDIR_SUFFIX}/clang/${CLANG_VERSION})
+  set(COMPILER_RT_INSTALL_PATH "${CMAKE_INSTALL_LIBDIR}/clang/${CLANG_VERSION}")
   option(COMPILER_RT_INCLUDE_TESTS "Generate and build compiler-rt unit tests."
          ${LLVM_INCLUDE_TESTS})
   option(COMPILER_RT_ENABLE_WERROR "Fail and stop if warning is triggered"
          ${LLVM_ENABLE_WERROR})
 
   # Use just-built Clang to compile/link tests on all platforms.
   if (CMAKE_CROSSCOMPILING)
     if (CMAKE_HOST_WIN32)
if(ANDROID)
     set(COMPILER_RT_OS_DIR linux)
   else()
     string(TOLOWER ${CMAKE_SYSTEM_NAME} COMPILER_RT_OS_DIR)
   endif()
 endif()
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
   set(COMPILER_RT_OUTPUT_LIBRARY_DIR
     ${COMPILER_RT_OUTPUT_DIR}/lib)
-  extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" lib)
-else(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
+  # Don't use "${CMAKE_INSTALL_LIBDIR}", because the intended use-case is that
+  # "${COMPILER_RT_INSTALL_PATH}" is already non-trival and probably includes
+  # "${CMAKE_INSTALL_LIBDIR}".
+  extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" "lib")
+else()
   set(COMPILER_RT_OUTPUT_LIBRARY_DIR
     ${COMPILER_RT_OUTPUT_DIR}/lib/${COMPILER_RT_OS_DIR})
-  extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" "lib/${COMPILER_RT_OS_DIR}")
+  extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" "${CMAKE_INSTALL_LIBDIR}/${COMPILER_RT_OS_DIR}")
 endif()
 set(COMPILER_RT_INSTALL_LIBRARY_DIR "${default_install_path}" CACHE PATH
   "Path where built compiler-rt libraries should be installed.")
 unset(default_install_path)
 
 extend_path(default_install_path "${COMPILER_RT_INSTALL_PATH}" "${CMAKE_INSTALL_BINDIR}")
 set(COMPILER_RT_INSTALL_BINARY_DIR "${default_install_path}" CACHE PATH
   "Path where built compiler-rt executables should be installed.")

compiler-rt/docs/BuildingCompilerRT.rst

.. option:: COMPILER_RT_INSTALL_INCLUDE_DIR:PATH
   path, relative to ``COMPILER_RT_INSTALL_PATH``.
 
 .. option:: COMPILER_RT_INSTALL_DATA_DIR:PATH
 
   **Default**: ``share``
 
   Path where Compiler-RT data should be installed. If a relative
   path, relative to ``COMPILER_RT_INSTALL_PATH``.
-
-.. _LLVM-specific variables:
-
-LLVM-specific options
----------------------
-
-.. option:: LLVM_LIBDIR_SUFFIX:STRING
-
-  Extra suffix to append to the directory where libraries are to be
-  installed. On a 64-bit architecture, one could use ``-DLLVM_LIBDIR_SUFFIX=64``
-  to install libraries to ``/usr/lib64``.

flang/cmake/modules/AddFlang.cmake

macro(add_flang_library name)
   if (TARGET ${name})
 
     if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "libflang"
         OR ARG_INSTALL_WITH_TOOLCHAIN)
       get_target_export_arg(${name} Flang export_to_flangtargets UMBRELLA flang-libraries)
       install(TARGETS ${name}
         COMPONENT ${name}
         ${export_to_flangtargets}
-        LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
-        ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
+        LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+        ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
         RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
 
       if (NOT LLVM_ENABLE_IDE)
         add_llvm_install_targets(install-${name}
                                  DEPENDS ${name}
                                  COMPONENT ${name})
       endif()
 

libc/CMakeLists.txt

 cmake_minimum_required(VERSION 3.13.4)
 
+include(GNUInstallDirs)
+
 # Default to C++17
 set(CMAKE_CXX_STANDARD 17)
 
 # Must go before the first `include(GNUInstallDirs)`.
 include(LLVMLibdirSuffix)
 
 include(GNUInstallDirs)
 include(GNUBinaryDirs)

libc/lib/CMakeLists.txt

 add_entrypoint_library(
   ${LIBC_TARGET}
   DEPENDS
   ${TARGET_LLVMLIBC_ENTRYPOINTS}
 )
 set_target_properties(
   ${LIBC_TARGET}
   PROPERTIES
     ARCHIVE_OUTPUT_NAME ${LIBC_ARCHIVE_NAME}
 )
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR)
-  set(LIBC_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE})
+  set(LIBC_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR}/${LLVM_DEFAULT_TARGET_TRIPLE})
 else()
-  set(LIBC_INSTALL_LIBRARY_DIR lib${LLVM_LIBDIR_SUFFIX})
+  set(LIBC_INSTALL_LIBRARY_DIR ${CMAKE_INSTALL_LIBDIR})
 endif()
 
 install(
   TARGETS ${LIBC_TARGET}
   ARCHIVE DESTINATION "${LIBC_INSTALL_LIBRARY_DIR}"
   COMPONENT ${LIBC_COMPONENT}
 )

libcxx/CMakeLists.txt

 else()
   set(default_install_path "${LIBCXX_INSTALL_INCLUDE_DIR}")
 endif()
 set(LIBCXX_INSTALL_INCLUDE_TARGET_DIR "${default_install_path}" CACHE PATH
     "Path where target-specific libc++ headers should be installed.")
 unset(default_install_path)
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
-  set(default_install_path "lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE}")
+  set(default_install_path "${CMAKE_INSTALL_LIBDIR}/${LLVM_DEFAULT_TARGET_TRIPLE}")
 else()
-  set(default_install_path "lib${LLVM_LIBDIR_SUFFIX}")
+  set(default_install_path "${CMAKE_INSTALL_LIBDIR}")
 endif()
 set(LIBCXX_INSTALL_LIBRARY_DIR "${default_install_path}" CACHE PATH
     "Path where built libc++ libraries should be installed.")
 unset(default_install_path)
 
 get_filename_component(LIBCXX_LIBDIR_BASENAME "${LIBCXX_INSTALL_LIBRARY_DIR}" NAME)
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)

libcxx/docs/BuildingLibcxx.rst

.. option:: LIBCXX_ENABLE_WIDE_CHARACTERS:BOOL
 
    This option can be used to disable support for ``wchar_t`` in the library. It also
    allows the library to work on top of a C Standard Library that does not provide
    support for ``wchar_t``. This is especially useful in embedded settings where
    C Standard Libraries don't always provide all the usual bells and whistles.
 
 .. option:: LIBCXX_INSTALL_LIBRARY_DIR:PATH
 
-  **Default**: ``lib${LLVM_LIBDIR_SUFFIX}``
+  **Default**: ``${CMAKE_INSTALL_LIBDIR}``
 
   Path where built libc++ libraries should be installed. If a relative path,
   relative to ``CMAKE_INSTALL_PREFIX``.
 
 .. option:: LIBCXX_INSTALL_INCLUDE_DIR:PATH
 
   **Default**: ``include/c++/v1``
 
.. option:: LIBCXX_ABI_DEFINES:STRING
   See ``include/__config`` for the list of ABI macros.
 
 
 .. _LLVM-specific variables:
 
 LLVM-specific options
 ---------------------
 
-.. option:: LLVM_LIBDIR_SUFFIX:STRING
-
-  Extra suffix to append to the directory where libraries are to be
-  installed. On a 64-bit architecture, one could use ``-DLLVM_LIBDIR_SUFFIX=64``
-  to install libraries to ``/usr/lib64``.
-
 .. option:: LLVM_BUILD_32_BITS:BOOL
 
   Build 32-bits executables and libraries on 64-bits systems. This option is
   available only on some 64-bits Unix systems. Defaults to OFF.
 
 .. option:: LLVM_LIT_ARGS:STRING
 
   Arguments given to lit.  ``make check`` and ``make clang-test`` are affected.

libcxxabi/CMakeLists.txt

set(CMAKE_MODULE_PATH
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
   ${CMAKE_MODULE_PATH}
   )
 
 set(LIBCXXABI_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
     "Path where built libc++abi runtime libraries should be installed.")
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
-  set(default_install_path "lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE}")
+  set(default_install_path "${CMAKE_INSTALL_LIBDIR}/${LLVM_DEFAULT_TARGET_TRIPLE}")
 else()
-  set(default_install_path "lib${LLVM_LIBDIR_SUFFIX}")
+  set(default_install_path "${CMAKE_INSTALL_LIBDIR}")
 endif()
 set(LIBCXXABI_INSTALL_LIBRARY_DIR "${default_install_path}" CACHE PATH
     "Path where built libc++abi libraries should be installed.")
 unset(default_install_path)
 
 get_filename_component(LIBCXXABI_LIBDIR_BASENAME "${LIBCXXABI_INSTALL_LIBRARY_DIR}" NAME)
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)

libunwind/CMakeLists.txt

set(CMAKE_MODULE_PATH
     ${CMAKE_MODULE_PATH})
 
 set(LIBUNWIND_INSTALL_INCLUDE_DIR "${CMAKE_INSTALL_INCLUDEDIR}" CACHE PATH
     "Path where built libunwind headers should be installed.")
 set(LIBUNWIND_INSTALL_RUNTIME_DIR "${CMAKE_INSTALL_BINDIR}" CACHE PATH
     "Path where built libunwind runtime libraries should be installed.")
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)
-  set(default_install_path "lib${LLVM_LIBDIR_SUFFIX}/${LLVM_DEFAULT_TARGET_TRIPLE}")
+  set(default_install_path "${CMAKE_INSTALL_LIBDIR}/${LLVM_DEFAULT_TARGET_TRIPLE}")
 else()
-  set(default_install_path "lib${LLVM_LIBDIR_SUFFIX}")
+  set(default_install_path "${CMAKE_INSTALL_LIBDIR}")
 endif()
 set(LIBUNWIND_INSTALL_LIBRARY_DIR "${default_install_path}" CACHE PATH
     "Path where built libunwind libraries should be installed.")
 unset(default_install_path)
 
 get_filename_component(LIBUNWIND_LIBDIR_BASENAME "${LIBUNWIND_INSTALL_LIBRARY_DIR}" NAME)
 
 if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE)

libunwind/docs/BuildingLibunwind.rst

 .. option:: LIBUNWIND_ENABLE_THREADS:BOOL
 
   **Default**: ``ON``
 
   Build libunwind with threading support.
 
 .. option:: LIBUNWIND_INSTALL_LIBRARY_DIR:PATH
 
-  **Default**: ``lib${LLVM_LIBDIR_SUFFIX}``
+  **Default**: ``${CMAKE_INSTALL_LIBDIR}``
 
   Path where built libunwind libraries should be installed. If a relative path,
   relative to ``CMAKE_INSTALL_PREFIX``.

lld/cmake/modules/AddLLD.cmake

macro(add_lld_library name)
   llvm_add_library(${name} ${ARG_ENABLE_SHARED} ${ARG_UNPARSED_ARGUMENTS})
   set_target_properties(${name} PROPERTIES FOLDER "lld libraries")
 
   if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
     get_target_export_arg(${name} LLD export_to_lldtargets)
     install(TARGETS ${name}
       COMPONENT ${name}
       ${export_to_lldtargets}
-      LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
-      ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
+      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
       RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
 
     if (${ARG_SHARED} AND NOT CMAKE_CONFIGURATION_TYPES)
       add_llvm_install_targets(install-${name}
         DEPENDS ${name}
         COMPONENT ${name})
     endif()
     set_property(GLOBAL APPEND PROPERTY LLD_EXPORTS ${name})

lldb/cmake/modules/AddLLDB.cmake

)
   # A target cannot be changed to a FRAMEWORK after calling install() because
   # this may result in the wrong install DESTINATION. The FRAMEWORK property
   # must be set earlier.
   if(PARAM_FRAMEWORK)
     set_target_properties(liblldb PROPERTIES FRAMEWORK ON)
   endif()
 
   if(PARAM_SHARED)
-    set(install_dest lib${LLVM_LIBDIR_SUFFIX})
+    set(install_dest "${CMAKE_INSTALL_LIBDIR}")
     if(PARAM_INSTALL_PREFIX)
       set(install_dest ${PARAM_INSTALL_PREFIX})
     endif()
     # RUNTIME is relevant for DLL platforms, FRAMEWORK for macOS
     install(TARGETS ${name} COMPONENT ${name}
       RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
       LIBRARY DESTINATION ${install_dest}
       ARCHIVE DESTINATION ${install_dest}

lldb/cmake/modules/LLDBGenerateConfig.cmake

 check_include_file(termios.h HAVE_TERMIOS_H)
 check_include_files("sys/types.h;sys/event.h" HAVE_SYS_EVENT_H)
 
 check_cxx_symbol_exists(process_vm_readv "sys/uio.h" HAVE_PROCESS_VM_READV)
 check_cxx_symbol_exists(__NR_process_vm_readv "sys/syscall.h" HAVE_NR_PROCESS_VM_READV)
 
 check_library_exists(compression compression_encode_buffer "" HAVE_LIBCOMPRESSION)
 
-set(LLDB_INSTALL_LIBDIR_BASENAME "lib${LLDB_LIBDIR_SUFFIX}")
+get_filename_component(LLDB_INSTALL_LIBDIR_BASENAME "${CMAKE_INSTALL_LIBDIR}" NAME)
 
 # These checks exist in LLVM's configuration, so I want to match the LLVM names
 # so that the check isn't duplicated, but we translate them into the LLDB names
 # so that I don't have to change all the uses at the moment.
 set(LLDB_ENABLE_TERMIOS ${HAVE_TERMIOS_H})
 if (UNIX)
   set(LLDB_ENABLE_POSIX ON)
 else()

lldb/source/API/CMakeLists.txt

+include(ExtendPath)
+
 get_property(LLDB_ALL_PLUGINS GLOBAL PROPERTY LLDB_PLUGINS)
 
 if(LLDB_BUILD_FRAMEWORK)
   set(option_install_prefix INSTALL_PREFIX ${LLDB_FRAMEWORK_INSTALL_DIR})
   set(option_framework FRAMEWORK)
 endif()
 
 if(LLDB_ENABLE_PYTHON)
add_lldb_library(liblldb SHARED ${option_framework}
   ${option_install_prefix}
 )
 
 # lib/pythonX.Y/dist-packages/lldb/_lldb.so is a symlink to lib/liblldb.so,
 # which depends on lib/libLLVM*.so (BUILD_SHARED_LIBS) or lib/libLLVM-10git.so
 # (LLVM_LINK_LLVM_DYLIB). Add an additional rpath $ORIGIN/../../../../lib so
 # that _lldb.so can be loaded from Python.
 if(LLDB_ENABLE_PYTHON AND (BUILD_SHARED_LIBS OR LLVM_LINK_LLVM_DYLIB) AND UNIX AND NOT APPLE)
-  set_property(TARGET liblldb APPEND PROPERTY INSTALL_RPATH "\$ORIGIN/../../../../lib${LLVM_LIBDIR_SUFFIX}")
+  extend_path(install_rpath "\$ORIGIN/../../../../" "${CMAKE_INSTALL_LIBDIR}")
+  set_property(TARGET liblldb APPEND PROPERTY INSTALL_RPATH "${install_rpath}")
 endif()
 
 if(Python3_RPATH)
   set_property(TARGET liblldb APPEND PROPERTY INSTALL_RPATH "${Python3_RPATH}")
   set_property(TARGET liblldb APPEND PROPERTY BUILD_RPATH   "${Python3_RPATH}")
 endif()
 
 

lldb/tools/intel-features/CMakeLists.txt

 add_lldb_library(lldbIntelFeatures SHARED
   cli-wrapper.cpp
 
   LINK_LIBS
     ${FEATURE_LIBS}
   )
 
 install(TARGETS lldbIntelFeatures
-  LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX})
+  LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")

llvm/CMakeLists.txt

list(INSERT CMAKE_MODULE_PATH 0
   "${LLVM_COMMON_CMAKE_UTILS}/Modules"
   )
 
 project(LLVM
   VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}
   LANGUAGES C CXX ASM)
 
 # Must go before the first `include(GNUInstallDirs)`.
 include(LLVMLibdirSuffix)
 
-# Must go after `include(LLVMLibdirSuffix)`.
-set(LLVM_LIBDIR_SUFFIX "" CACHE STRING "Define suffix of library directory name (32/64)" )
-
 # Must go after `project(..)`.
 include(GNUInstallDirs)
 include(GNUBinaryDirs)
 
 # This C++ standard is required to build LLVM.
 set(LLVM_REQUIRED_CXX_STANDARD 17)
 
 # If we find that the cache contains CMAKE_CXX_STANDARD it means that it's a old CMakeCache.txt
if (NOT TENSORFLOW_AOT_PATH STREQUAL "")
   file(COPY ${TENSORFLOW_AOT_PATH}/include DESTINATION ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/tensorflow
     NO_SOURCE_PERMISSIONS
     PATTERN "google/*" EXCLUDE
     PATTERN "*.pb.h" EXCLUDE) 
   include_directories(${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/tensorflow/include)
   add_subdirectory(${TENSORFLOW_AOT_PATH}/xla_aot_runtime_src
     ${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}/tf_runtime)
   install(TARGETS tf_xla_runtime EXPORT LLVMExports
-    ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT tf_xla_runtime)
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT tf_xla_runtime)
   set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS tf_xla_runtime)
   # Once we add more modules, we should handle this more automatically.
   if (DEFINED LLVM_OVERRIDE_MODEL_HEADER_INLINERSIZEMODEL)
     set(LLVM_INLINER_MODEL_PATH "none")
   elseif(NOT DEFINED LLVM_INLINER_MODEL_PATH
       OR "${LLVM_INLINER_MODEL_PATH}" STREQUAL ""
       OR "${LLVM_INLINER_MODEL_PATH}" STREQUAL "autogenerate")
     set(LLVM_INLINER_MODEL_PATH "autogenerate")

llvm/cmake/modules/AddLLVM.cmake

if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ARG_INSTALL_WITH_TOOLCHAIN)
         set(umbrella UMBRELLA llvm-libraries)
       else()
         set(umbrella)
       endif()
 
       get_target_export_arg(${name} LLVM export_to_llvmexports ${umbrella})
       install(TARGETS ${name}
               ${export_to_llvmexports}
-              LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT ${name}
-              ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX} COMPONENT ${name}
+              LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT ${name}
+              ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT ${name}
               RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT ${name})
 
       if (NOT LLVM_ENABLE_IDE)
         add_llvm_install_targets(install-${name}
                                  DEPENDS ${name}
                                  COMPONENT ${name})
       endif()
     endif()
function(llvm_install_library_symlink name dest type)
   set(component ${ARG_COMPONENT})
   if(NOT component)
     set(component ${name})
   endif()
 
   set(full_name ${CMAKE_${type}_LIBRARY_PREFIX}${name}${CMAKE_${type}_LIBRARY_SUFFIX})
   set(full_dest ${CMAKE_${type}_LIBRARY_PREFIX}${dest}${CMAKE_${type}_LIBRARY_SUFFIX})
 
-  set(output_dir lib${LLVM_LIBDIR_SUFFIX})
+  set(output_dir "${CMAKE_INSTALL_FULL_LIBDIR}")
   if(WIN32 AND "${type}" STREQUAL "SHARED")
     set(output_dir "${CMAKE_INSTALL_BINDIR}")
   endif()
 
   install(SCRIPT ${INSTALL_SYMLINK}
           CODE "install_symlink(\"${full_name}\" \"${full_dest}\" \"${output_dir}\")"
           COMPONENT ${component})
 
function(llvm_setup_rpath name)
   if(LLVM_INSTALL_PREFIX AND NOT (LLVM_INSTALL_PREFIX STREQUAL CMAKE_INSTALL_PREFIX))
     set(extra_libdir ${LLVM_LIBRARY_DIR})
   elseif(LLVM_BUILD_LIBRARY_DIR)
     set(extra_libdir ${LLVM_LIBRARY_DIR})
   endif()
 
   if (APPLE)
     set(_install_name_dir INSTALL_NAME_DIR "@rpath")
-    set(_install_rpath "@loader_path/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
+    set(_install_rpath "@loader_path/../${CMAKE_INSTALL_LIBDIR}" ${extra_libdir})
   elseif(${CMAKE_SYSTEM_NAME} MATCHES "AIX" AND BUILD_SHARED_LIBS)
     # $ORIGIN is not interpreted at link time by aix ld.
     # Since BUILD_SHARED_LIBS is only recommended for use by developers,
     # hardcode the rpath to build/install lib dir first in this mode.
     # FIXME: update this when there is better solution.
-    set(_install_rpath "${LLVM_LIBRARY_OUTPUT_INTDIR}" "${CMAKE_INSTALL_PREFIX}/lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
+    set(_install_rpath "${LLVM_LIBRARY_OUTPUT_INTDIR}" "${CMAKE_INSTALL_FULL_LIBDIR}" ${extra_libdir})
   elseif(UNIX)
-    set(_install_rpath "\$ORIGIN/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
+    set(_install_rpath "\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}" ${extra_libdir})
     if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)")
       set_property(TARGET ${name} APPEND_STRING PROPERTY
                    LINK_FLAGS " -Wl,-z,origin ")
     endif()
     if(LLVM_LINKER_IS_GNULD)
       # $ORIGIN is not interpreted at link time by ld.bfd
       set_property(TARGET ${name} APPEND_STRING PROPERTY
                    LINK_FLAGS " -Wl,-rpath-link,${LLVM_LIBRARY_OUTPUT_INTDIR} ")

llvm/cmake/modules/AddOCaml.cmake

function(add_ocaml_library name)
 
   set(ocaml_params)
   foreach( ocaml_input ${ocaml_inputs} ${c_outputs})
     get_filename_component(filename "${ocaml_input}" NAME)
     list(APPEND ocaml_params "${filename}")
   endforeach()
 
   if( APPLE )
-    set(ocaml_rpath "@executable_path/../../../lib${LLVM_LIBDIR_SUFFIX}")
+    set(ocaml_rpath "@executable_path/../../../${CMAKE_INSTALL_LIBDIR}")
   elseif( UNIX )
-    set(ocaml_rpath "\\$ORIGIN/../../../lib${LLVM_LIBDIR_SUFFIX}")
+    set(ocaml_rpath "\\$ORIGIN/../../../${CMAKE_INSTALL_LIBDIR}")
   endif()
   list(APPEND ocaml_flags "-ldopt" "-Wl,-rpath,${ocaml_rpath}")
 
   add_custom_command(
     OUTPUT ${ocaml_outputs}
     COMMAND "${OCAMLFIND}" "ocamlmklib" "-ocamlcflags" "-bin-annot"
       "-o" "${name}" ${ocaml_flags} ${ocaml_params}
     DEPENDS ${ocaml_inputs} ${c_outputs}

llvm/cmake/modules/CMakeLists.txt

 # are combined in one directory at install time.
 set(LLVM_CONFIG_INCLUDE_DIR "${LLVM_CONFIG_MAIN_INCLUDE_DIR}")
 set(LLVM_CONFIG_INCLUDE_DIRS
   "${LLVM_CONFIG_MAIN_INCLUDE_DIR}"
   "${LLVM_CONFIG_INCLUDE_DIR}"
   )
 list(REMOVE_DUPLICATES LLVM_CONFIG_INCLUDE_DIRS)
 
-extend_path(LLVM_CONFIG_LIBRARY_DIR "\${LLVM_INSTALL_PREFIX}" "lib\${LLVM_LIBDIR_SUFFIX}")
+extend_path(LLVM_CONFIG_LIBRARY_DIR "\${LLVM_INSTALL_PREFIX}" "${CMAKE_INSTALL_LIBDIR}")
 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}")

llvm/cmake/modules/LLVMConfig.cmake.in

 endif()
 
 set(LLVM_ENABLE_PLUGINS @LLVM_ENABLE_PLUGINS@)
 set(LLVM_EXPORT_SYMBOLS_FOR_PLUGINS @LLVM_EXPORT_SYMBOLS_FOR_PLUGINS@)
 set(LLVM_PLUGIN_EXT @LLVM_PLUGIN_EXT@)
 
 set(LLVM_ON_UNIX @LLVM_ON_UNIX@)
 
-set(LLVM_LIBDIR_SUFFIX @LLVM_LIBDIR_SUFFIX@)
-
 set(LLVM_INCLUDE_DIRS "@LLVM_CONFIG_INCLUDE_DIRS@")
 set(LLVM_LIBRARY_DIRS "@LLVM_CONFIG_LIBRARY_DIRS@")
 
 set(LLVM_APPEND_VC_REV "@LLVM_APPEND_VC_REV@")
 
 # These variables are duplicated for install tree but they have different
 # values for build tree.  LLVM_INCLUDE_DIRS contains both source
 # and generated include directories while the following variables have
 # them split.
 
 # These are the "main" dirs
 set(LLVM_MAIN_INCLUDE_DIR "@LLVM_CONFIG_MAIN_INCLUDE_DIR@")
 set(LLVM_LIBRARY_DIR "@LLVM_CONFIG_LIBRARY_DIR@")
 
+# Backwards compatibility for anything using the deprecated `LLVM_LIBDIR_SUFFIX`
+# downstream.
+if("${LLVM_LIBRARY_DIR}" MATCHES "lib([^/]*)$")
+  set(LLVM_LIBDIR_SUFFIX "${CMAKE_MATCH_0}")
+else()
+  set(LLVM_LIBDIR_SUFFIX "")
+endif()
+
 # 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_HAVE_OPT_VIEWER_MODULES @LLVM_HAVE_OPT_VIEWER_MODULES@)

llvm/docs/CMake.rst

 **LLVM_ENABLE_PROJECTS**:STRING
   Control which projects are enabled. For example you may want to work on clang
   or lldb by specifying ``-DLLVM_ENABLE_PROJECTS="clang;lldb"``.
 
 **LLVM_ENABLE_RUNTIMES**:STRING
   Control which runtimes are enabled. For example you may want to work on
   libc++ or libc++abi by specifying ``-DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi"``.
 
-**LLVM_LIBDIR_SUFFIX**:STRING
-  Extra suffix to append to the directory where libraries are to be
-  installed. On a 64-bit architecture, one could use ``-DLLVM_LIBDIR_SUFFIX=64``
-  to install libraries to ``/usr/lib64``.
-
 **LLVM_PARALLEL_{COMPILE,LINK}_JOBS**:STRING
   Building the llvm toolchain can use a lot of resources, particularly
   linking. These options, when you use the Ninja generator, allow you
   to restrict the parallelism. For example, to avoid OOMs or going
   into swap, permit only one link job per 15GB of RAM available on a
   32GB machine, specify ``-G Ninja -DLLVM_PARALLEL_LINK_JOBS=2``.
 
 **LLVM_TARGETS_TO_BUILD**:STRING

 **CMAKE_CXX_STANDARD**:STRING
   Sets the C++ standard to conform to when building LLVM.  Possible values are
   17 and 20.  LLVM Requires C++ 17 or higher.  This defaults to 17.
 
 **CMAKE_INSTALL_BINDIR**:PATH
   The path to install executables, relative to the *CMAKE_INSTALL_PREFIX*.
   Defaults to "bin".
 
+**CMAKE_INSTALL_LIBDIR**:PATH
+  The path to install libraries, relative to the *CMAKE_INSTALL_PREFIX*.
+  Defaults to "lib".
+
 **CMAKE_INSTALL_INCLUDEDIR**:PATH
   The path to install header files, relative to the *CMAKE_INSTALL_PREFIX*.
   Defaults to "include".
 
 **CMAKE_INSTALL_DOCDIR**:PATH
   The path to install documentation, relative to the *CMAKE_INSTALL_PREFIX*.
   Defaults to "share/doc".
 
**LLVM_UTILS_INSTALL_DIR**:STRING
   Only matters if *LLVM_INSTALL_UTILS* is enabled.
   Defaults to *LLVM_TOOLS_INSTALL_DIR*.
 
 **LLVM_EXAMPLES_INSTALL_DIR**:STRING
   The path for examples of using LLVM, relative to the *CMAKE_INSTALL_PREFIX*.
   Only matters if *LLVM_BUILD_EXAMPLES* is enabled.
   Defaults to "examples".
 
+Deprecated variables
+~~~~~~~~~~~~~~~~~~~~
+
+These will go away soon. Please try to avoid using them.
+
+**LLVM_LIBDIR_SUFFIX**:STRING
+
+  **Deprecated**: Use ``LLVM_LIBRARY_DIR`` or ``CMAKE_INSTALL_LIBDIR`` instead.
+  Only defined downstream for legacy consumers, not during the build of LLVM
+  itself.
+
+  Extra suffix to append to the directory where libraries are to be
+  installed. On a 64-bit architecture, one could use ``-DLLVM_LIBDIR_SUFFIX=64``
+  to install libraries to ``/usr/lib64``. See also ``CMAKE_INSTALL_LIBDIR``.
+
 CMake Caches
 ============
 
 Recently LLVM and Clang have been adding some more complicated build system
 features. Utilizing these new features often involves a complicated chain of
 CMake variables passed on the command line. Clang provides a collection of CMake
 cache scripts to make these features more approachable.
 

llvm/tools/llvm-config/BuildVariables.inc.in

 
 #define LLVM_SRC_ROOT "@LLVM_SRC_ROOT@"
 #define LLVM_OBJ_ROOT "@LLVM_OBJ_ROOT@"
 #define LLVM_CPPFLAGS "@LLVM_CPPFLAGS@"
 #define LLVM_CFLAGS "@LLVM_CFLAGS@"
 #define LLVM_LDFLAGS "@LLVM_LDFLAGS@"
 #define LLVM_CXXFLAGS "@LLVM_CXXFLAGS@"
 #define LLVM_BUILDMODE "@LLVM_BUILDMODE@"
-#define LLVM_LIBDIR_SUFFIX "@LLVM_LIBDIR_SUFFIX@"
+#define LLVM_LIBDIR_BASENAME "@CMAKE_LIBDIR_BASENAME@"
+#define LLVM_INSTALL_LIBDIR "@CMAKE_INSTALL_LIBDIR@"
 #define LLVM_INSTALL_INCLUDEDIR "@CMAKE_INSTALL_INCLUDEDIR@"
 #define LLVM_INSTALL_PACKAGE_DIR "@LLVM_INSTALL_PACKAGE_DIR@"
 #define LLVM_TARGETS_BUILT "@LLVM_TARGETS_BUILT@"
 #define LLVM_SYSTEM_LIBS "@LLVM_SYSTEM_LIBS@"
 #define LLVM_BUILD_SYSTEM "@LLVM_BUILD_SYSTEM@"
 #define LLVM_HAS_RTTI @LLVM_HAS_RTTI@
 #define LLVM_ENABLE_DYLIB @LLVM_BUILD_LLVM_DYLIB@
 #define LLVM_LINK_DYLIB @LLVM_LINK_LLVM_DYLIB@
 #define LLVM_ENABLE_SHARED @BUILD_SHARED_LIBS@
 #define LLVM_DYLIB_COMPONENTS "@LLVM_DYLIB_COMPONENTS_expanded@"
 #define LLVM_DYLIB_VERSION "@LLVM_DYLIB_VERSION@"
 #define LLVM_TOOLS_INSTALL_DIR "@LLVM_TOOLS_INSTALL_DIR@"

llvm/tools/llvm-config/llvm-config.cpp

if (IsInDevelopmentTree) {
     ActiveIncludeDir = std::string(LLVM_SRC_ROOT) + "/include";
     ActivePrefix = CurrentExecPrefix;
 
     // CMake organizes the products differently than a normal prefix style
     // layout.
     switch (DevelopmentTreeLayout) {
     case CMakeStyle:
       ActiveBinDir = ActiveObjRoot + "/bin";
-      ActiveLibDir = ActiveObjRoot + "/lib" + LLVM_LIBDIR_SUFFIX;
+      ActiveLibDir = ActiveObjRoot + "/" + LLVM_LIBDIR_BASENAME;
       ActiveCMakeDir = ActiveLibDir + "/cmake/llvm";
       break;
     case CMakeBuildModeStyle:
       // FIXME: Should we consider the build-mode-specific path as the prefix?
       ActivePrefix = ActiveObjRoot;
       ActiveBinDir = ActiveObjRoot + "/" + build_mode + "/bin";
       ActiveLibDir =
-          ActiveObjRoot + "/" + build_mode + "/lib" + LLVM_LIBDIR_SUFFIX;
+          ActiveObjRoot + "/" + build_mode + "/" + LLVM_LIBDIR_BASENAME;
       // The CMake directory isn't separated by build mode.
       ActiveCMakeDir =
-          ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX + "/cmake/llvm";
+          ActivePrefix + "/" + LLVM_LIBDIR_BASENAME + "/cmake/llvm";
       break;
     }
 
     // We need to include files from both the source and object trees.
     ActiveIncludeOption =
         ("-I" + ActiveIncludeDir + " " + "-I" + ActiveObjRoot + "/include");
   } else {
     ActivePrefix = CurrentExecPrefix;
     {
       SmallString<256> Path(LLVM_INSTALL_INCLUDEDIR);
       sys::fs::make_absolute(ActivePrefix, Path);
       ActiveIncludeDir = std::string(Path.str());
     }
     {
       SmallString<256> Path(LLVM_TOOLS_INSTALL_DIR);
       sys::fs::make_absolute(ActivePrefix, Path);
       ActiveBinDir = std::string(Path.str());
     }
-    ActiveLibDir = ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX;
+    {
+      SmallString<256> Path(LLVM_INSTALL_LIBDIR);
+      sys::fs::make_absolute(ActivePrefix, Path);
+      ActiveLibDir = std::string(Path.str());
+    }
     {
       SmallString<256> Path(LLVM_INSTALL_PACKAGE_DIR);
       sys::fs::make_absolute(ActivePrefix, Path);
       ActiveCMakeDir = std::string(Path.str());
     }
     ActiveIncludeOption = "-I" + ActiveIncludeDir;
   }
 

llvm/utils/gn/secondary/llvm/tools/llvm-config/BUILD.gn

write_cmake_config("BuildVariables.inc") {
   if (llvm_enable_terminfo) {
     system_libs += " ${l}ncurses${lib}"
   }
   if (llvm_enable_zlib) {
     system_libs += " ${l}z${lib}"
   }
 
   values = [
+    "CMAKE_INSTALL_LIBDIR=lib",
     "CMAKE_INSTALL_INCLUDEDIR=include",
     "LLVM_SRC_ROOT=" + rebase_path("//llvm"),
     "LLVM_OBJ_ROOT=" + rebase_path(root_out_dir),
 
     # FIXME: Only the bits needed to run LLVM's test are implemented.
     "LLVM_CPPFLAGS=.",  # FIXME
     "LLVM_CFLAGS=.",  # FIXME
     "LLVM_LDFLAGS=.",  # FIXME

mlir/CMakeLists.txt

if(MLIR_STANDALONE_BUILD)
   set(LLVM_MAIN_SRC_DIR ${CMAKE_SOURCE_DIR}/../llvm CACHE PATH
       "Path to LLVM source tree")
   set(UNITTEST_DIR ${LLVM_MAIN_SRC_DIR}/utils/unittest)
   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}")
+    "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_LIBDIR_BASENAME}")
   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     ${MLIR_SOURCE_DIR}           )

mlir/cmake/modules/AddMLIR.cmake

 # This is usually done as part of add_mlir_library but is broken out for cases
 # where non-standard library builds can be installed.
 function(add_mlir_library_install name)
   if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   get_target_export_arg(${name} MLIR export_to_mlirtargets UMBRELLA mlir-libraries)
   install(TARGETS ${name}
     COMPONENT ${name}
     ${export_to_mlirtargets}
-    LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
-    ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
     RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
     # Note that CMake will create a directory like:
     #   objects-${CMAKE_BUILD_TYPE}/obj.LibName
     # and put object files there.
-    OBJECTS DESTINATION lib${LLVM_LIBDIR_SUFFIX}
+    OBJECTS DESTINATION "${CMAKE_INSTALL_LIBDIR}"
   )
 
   if (NOT LLVM_ENABLE_IDE)
     add_llvm_install_targets(install-${name}
                             DEPENDS ${name}
                             COMPONENT ${name})
   endif()
   set_property(GLOBAL APPEND PROPERTY MLIR_ALL_LIBS ${name})

mlir/cmake/modules/AddMLIRPython.cmake

function(mlir_python_setup_extension_rpath target)
   # the one directory. For shared builds, then we also need to add the global
   # lib directory. This will be absolute for the build tree and relative for
   # install.
   # When we have access to CMake >= 3.20, there is a helper to calculate this.
   if(BUILD_SHARED_LIBS AND ARG_RELATIVE_INSTALL_ROOT)
     get_filename_component(_real_lib_dir "${LLVM_LIBRARY_OUTPUT_INTDIR}" REALPATH)
     set_property(TARGET ${target} APPEND PROPERTY
       BUILD_RPATH "${_real_lib_dir}")
-    set_property(TARGET ${target} APPEND PROPERTY
-      INSTALL_RPATH "${_origin_prefix}/${ARG_RELATIVE_INSTALL_ROOT}/lib${LLVM_LIBDIR_SUFFIX}")
+    if(NOT IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
+      set(install_rpath "${_origin_prefix}/${ARG_RELATIVE_INSTALL_ROOT}/${CMAKE_INSTALL_LIBDIR}")
+  else()
+    set(install_rpath "${CMAKE_INSTALL_LIBDIR}")
+  endif()
+    set_property(TARGET ${target} APPEND PROPERTY INSTALL_RPATH "${install_rpath}")
   endif()
 endfunction()
 
 # Function: add_mlir_python_common_capi_library
 # Adds a shared library which embeds dependent CAPI libraries needed to link
 # all extensions.
 # Arguments:
 #   INSTALL_COMPONENT: Name of the install component. Typically same as the

openmp/CMakeLists.txt

list(INSERT CMAKE_MODULE_PATH 0
   )
 
 # Must go before the first `include(GNUInstallDirs)`.
 include(LLVMLibdirSuffix)
 
 # Must go below project(..)
 include(GNUInstallDirs)
 
+set(OPENMP_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}" CACHE STRING
+  "lib installation directory, e.g. lib or lib64")
+
 if (OPENMP_STANDALONE_BUILD)
   # CMAKE_BUILD_TYPE was not set, default to Release.
   if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
   endif()
 
   # Group common settings.
   set(OPENMP_ENABLE_WERROR FALSE CACHE BOOL
     "Enable -Werror flags to turn warnings into errors for supporting compilers.")
-  set(OPENMP_LIBDIR_SUFFIX "" CACHE STRING
-    "Suffix of lib installation directory, e.g. 64 => lib64")
-  # Do not use OPENMP_LIBDIR_SUFFIX directly, use OPENMP_INSTALL_LIBDIR.
-  set(OPENMP_INSTALL_LIBDIR "lib${OPENMP_LIBDIR_SUFFIX}")
 
   # Group test settings.
   set(OPENMP_TEST_C_COMPILER ${CMAKE_C_COMPILER} CACHE STRING
     "C compiler to use for testing OpenMP runtime libraries.")
   set(OPENMP_TEST_CXX_COMPILER ${CMAKE_CXX_COMPILER} CACHE STRING
     "C++ compiler to use for testing OpenMP runtime libraries.")
   set(OPENMP_LLVM_TOOLS_DIR "" CACHE PATH "Path to LLVM tools for testing.")
 else()
   set(OPENMP_ENABLE_WERROR ${LLVM_ENABLE_WERROR})
-  # If building in tree, we honor the same install suffix LLVM uses.
-  set(OPENMP_INSTALL_LIBDIR "lib${LLVM_LIBDIR_SUFFIX}")
 
   if (NOT MSVC)
     set(OPENMP_TEST_C_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang)
     set(OPENMP_TEST_CXX_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++)
   else()
     set(OPENMP_TEST_C_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang.exe)
     set(OPENMP_TEST_CXX_COMPILER ${LLVM_RUNTIME_OUTPUT_INTDIR}/clang++.exe)
   endif()

openmp/README.rst

**CMAKE_ASM_MASM_COMPILER** = ``ml|ml64``
   This option is only relevant for Windows*.
 
 Options for all Libraries
 -------------------------
 
 **OPENMP_ENABLE_WERROR** = ``OFF|ON``
   Treat warnings as errors and fail, if a compiler warning is triggered.
 
-**OPENMP_LIBDIR_SUFFIX** = ``""``
-  Extra suffix to append to the directory where libraries are to be installed.
+**OPENMP_INSTALL_LIBDIR** = ``lib``
+  Name or path of the directory where libraries are to be installed.
 
 **OPENMP_TEST_C_COMPILER** = ``${CMAKE_C_COMPILER}``
   Compiler to use for testing. Defaults to the compiler that was also used for
   building.
 
 **OPENMP_TEST_CXX_COMPILER** = ``${CMAKE_CXX_COMPILER}``
   Compiler to use for testing. Defaults to the compiler that was also used for
   building.

polly/CMakeLists.txt

 
 # Must go before the first `include(GNUInstallDirs)`.
 include(LLVMLibdirSuffix)
 
 # Must go below project(..)
 include(GNUInstallDirs)
 include(GNUBinaryDirs)
 
+set(POLLY_BINARY_BINDIR "${POLLY_BINARY_DIR}/bin")
+set(POLLY_BINARY_LIBDIR "${POLLY_BINARY_DIR}/${CMAKE_LIBDIR_BASENAME}")
+set(POLLY_BINARY_INCLUDEDIR "${POLLY_BINARY_DIR}/include")
+
 if(POLLY_STANDALONE_BUILD)
   # Where is LLVM installed?
   find_package(LLVM CONFIG REQUIRED)
   set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${LLVM_CMAKE_DIR})
   include(HandleLLVMOptions)
   include(AddLLVM)
 
   # Add the llvm header path.

 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   install(DIRECTORY include/
     DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
     FILES_MATCHING
     PATTERN "*.h"
     )
 
-  install(DIRECTORY ${POLLY_BINARY_DIR}/include/
+  install(DIRECTORY "${POLLY_BINARY_INCLUDEDIR}"
     DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
     FILES_MATCHING
     PATTERN "*.h"
     PATTERN "CMakeFiles" EXCLUDE
     )
 endif()
 
 add_definitions( -D_GNU_SOURCE )
 
 add_subdirectory(docs)
 add_subdirectory(lib)
 add_subdirectory(test)
 if (POLLY_GTEST_AVAIL)
   add_subdirectory(unittests)
 endif ()
 add_subdirectory(tools)
 add_subdirectory(cmake)
 # TODO: docs.
 
 
 configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/include/polly/Config/config.h.cmake
-                ${POLLY_BINARY_DIR}/include/polly/Config/config.h )
+                ${POLLY_BINARY_INCLUDEDIR}/polly/Config/config.h )
 
 # Add target to check formatting of polly files
 file( GLOB_RECURSE files *.h lib/*.cpp lib/*.c tools/*.cpp tools/*.c tools/*.h unittests/*.cpp)
 file( GLOB_RECURSE external lib/External/*.h lib/External/*.c lib/External/*.cpp isl_config.h)
 list( REMOVE_ITEM files ${external})
 
 set(check_format_depends)
 set(update_format_depends)

polly/cmake/CMakeLists.txt

 # Keep this in sync with llvm/cmake/CMakeLists.txt!
 
 include(GNUInstallPackageDir)
 include(ExtendPath)
 include(FindPrefixFromConfig)
 
 set(POLLY_INSTALL_PACKAGE_DIR "${CMAKE_INSTALL_PACKAGEDIR}/polly" CACHE STRING
   "Path for CMake subdirectory for Polly (defaults to '${CMAKE_INSTALL_PACKAGEDIR}/polly')")
 # CMAKE_INSTALL_PACKAGEDIR might be absolute, so don't reuse below.
-set(polly_cmake_builddir "${POLLY_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}/cmake/polly")
+set(polly_cmake_builddir "${POLLY_BINARY_LIBDIR}/cmake/polly")
 
 set(LLVM_INSTALL_PACKAGE_DIR "${CMAKE_INSTALL_PACKAGEDIR}/llvm" CACHE STRING
   "Path for CMake subdirectory for LLVM (defaults to '${CMAKE_INSTALL_PACKAGEDIR}/llvm')")
 # CMAKE_INSTALL_PACKAGEDIR might be absolute, so don't reuse below.
 set(llvm_cmake_builddir "${LLVM_LIBRARY_DIR}/cmake/llvm")
 
 if (CMAKE_CONFIGURATION_TYPES)
   set(POLLY_EXPORTS_FILE_NAME "PollyExports-$<LOWER_CASE:$<CONFIG>>.cmake")

 
 # Generate PollyConfig.cmake for the build tree.
 set(POLLY_CONFIG_CODE "")
 set(POLLY_CONFIG_LLVM_CMAKE_DIR "${llvm_cmake_builddir}")
 set(POLLY_CONFIG_CMAKE_DIR "${polly_cmake_builddir}")
 set(POLLY_CONFIG_INCLUDE_DIRS
   ${POLLY_SOURCE_DIR}/include
   ${ISL_INCLUDE_DIRS}
-  ${POLLY_BINARY_DIR}/include
+  "${POLLY_BINARY_INCLUDEDIR}"
   )
 set(POLLY_CONFIG_LIBRARY_DIRS "${POLLY_BINARY_DIR}/lib")
 
 # set locations for imported targets
 foreach(tgt IN LISTS POLLY_CONFIG_EXPORTED_TARGETS)
   get_target_property(tgt_type ${tgt} TYPE)
   if (NOT tgt_type STREQUAL "INTERFACE_LIBRARY")
     set(POLLY_EXPORTS
file(GENERATE
   CONTENT "${POLLY_EXPORTS}")
 
 
 # Generate PollyConfig.cmake for the install tree.
 unset(POLLY_EXPORTS)
 find_prefix_from_config(POLLY_CONFIG_CODE POLLY_INSTALL_PREFIX "${POLLY_INSTALL_PACKAGE_DIR}")
 extend_path(POLLY_CONFIG_LLVM_CMAKE_DIR "\${POLLY_INSTALL_PREFIX}" "${LLVM_INSTALL_PACKAGE_DIR}")
 extend_path(POLLY_CONFIG_CMAKE_DIR "\${POLLY_INSTALL_PREFIX}" "${POLLY_INSTALL_PACKAGE_DIR}")
-extend_path(POLLY_CONFIG_LIBRARY_DIRS "\${POLLY_INSTALL_PREFIX}" "lib${LLVM_LIBDIR_SUFFIX}")
+extend_path(POLLY_CONFIG_LIBRARY_DIRS "\${POLLY_INSTALL_PREFIX}" "${CMAKE_INSTALL_LIBDIR}")
 extend_path(base_includedir "\${POLLY_INSTALL_PREFIX}" "${CMAKE_INSTALL_INCLUDEDIR}")
 if (POLLY_BUNDLED_ISL)
   set(POLLY_CONFIG_INCLUDE_DIRS
     "${base_includedir}"
     "${base_includedir}/polly"
     )
 else()
   set(POLLY_CONFIG_INCLUDE_DIRS

polly/cmake/polly_macros.cmake

macro(add_polly_library name)
   endif(POLLY_LINK_LIBS)
 
   if( LLVM_LINK_COMPONENTS )
     llvm_config(${name} ${LLVM_LINK_COMPONENTS})
   endif( LLVM_LINK_COMPONENTS )
   if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "LLVMPolly")
     install(TARGETS ${name}
       EXPORT LLVMExports
-      LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
-      ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX})
+      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
   endif()
   set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
 endmacro(add_polly_library)
 
 macro(add_polly_loadable_module name)
   set(srcs ${ARGN})
   # klduge: pass different values for MODULE with multiple targets in same dir
   # this allows building shared-lib and module in same dir

pstl/CMakeLists.txt

configure_file(cmake/ParallelSTLConfig.cmake.in
                "${CMAKE_CURRENT_BINARY_DIR}/ParallelSTLConfig.cmake"
                @ONLY)
 
 install(TARGETS ParallelSTL
         EXPORT ParallelSTLTargets)
 install(EXPORT ParallelSTLTargets
         FILE ParallelSTLTargets.cmake
         NAMESPACE pstl::
-        DESTINATION lib/cmake/ParallelSTL)
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/ParallelSTL")
 install(FILES "${CMAKE_CURRENT_BINARY_DIR}/ParallelSTLConfig.cmake"
               "${CMAKE_CURRENT_BINARY_DIR}/ParallelSTLConfigVersion.cmake"
-        DESTINATION lib/cmake/ParallelSTL)
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/ParallelSTL")
 install(DIRECTORY include/
         DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
         PATTERN "*.in" EXCLUDE)
 install(FILES "${PSTL_CONFIG_SITE_PATH}"
         DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
 
 add_custom_target(install-pstl
                   COMMAND "${CMAKE_COMMAND}" -P "${PROJECT_BINARY_DIR}/cmake_install.cmake" -DCOMPONENT=ParallelSTL)

third-party/benchmark/src/CMakeLists.txt

 
 set(namespace "${PROJECT_NAME}::")
 
 include(CMakePackageConfigHelpers)
 
 configure_package_config_file (
   ${PROJECT_SOURCE_DIR}/cmake/Config.cmake.in
   ${project_config}
-  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+  INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
   NO_SET_AND_CHECK_MACRO
   NO_CHECK_REQUIRED_COMPONENTS_MACRO
 )
 write_basic_package_version_file(
   "${version_config}" VERSION ${GENERIC_LIB_VERSION} COMPATIBILITY SameMajorVersion
 )
 
 configure_file("${PROJECT_SOURCE_DIR}/cmake/benchmark.pc.in" "${pkg_config}" @ONLY)
 
 export (
   TARGETS ${targets_to_export}
   NAMESPACE "${namespace}"
   FILE ${generated_dir}/${targets_export_name}.cmake
 )
 
 if (BENCHMARK_ENABLE_INSTALL)
   # Install target (will install the library to specified CMAKE_INSTALL_PREFIX variable)
   install(
     TARGETS ${targets_to_export}
     EXPORT ${targets_export_name}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
     INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
   install(
     DIRECTORY "${PROJECT_SOURCE_DIR}/include/benchmark"
     DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
     FILES_MATCHING PATTERN "*.*h")