Support for custom install dirs in CMake build

[nalimilan]

Summary

This restores support for custom install directories, which was lost when moving from autotools to CMake. This is needed in particular by distributions to build versioned LLVM packages which are parallel-installable with the latest version.

This introduces new CMAKE_INSTALL_* variables, following the naming convention used by the GNUInstallDirs CMake module: for BINDIR, LIBDIR, INCLUDEDIR, DOCDIR and MANDIR. Existing variables are preserved, and take their defaults from or determine the new ones' defaults as appropriate.

[beanz]

I think this patch is mostly going in the right direction, and I'm actually very happy to see this functionality coming in.

I have a bunch of inline comments below.

CMakeLists.txt

299 ↗

(On Diff #82885)

In keeping with our conventions these variables probably should start with LLVM instead of CMAKE.

301 ↗

(On Diff #82885)

Generally speaking having a CMake cache variable that is derived from the value of another cache variable is really bad. If you update LLVM_LIBDIR_SUFFIX in this case CMAKE_INSTALL_LIBDIR will not be updated.

305 ↗

(On Diff #82885)

This is also bad for similar reasons as above.

310 ↗

(On Diff #82885)

Again, don't set cached variables off other cached variables.

312 ↗

(On Diff #82885)

Here too.

tools/llvm-config/BuildVariables.inc.in

26 ↗

(On Diff #82885)

Maybe rather than LLVM_BINARY_DIR here you keep the INSTALL_BINDIR name. LLVM_BINARY_DIR has a very specific meaning elsewhere in our build system.

The same is true for LLVM_LIBRARY_DIR and LLVM_INCLUDE_DIR, so it is probably best to use the INSTALL_* names there too.

[beanz]

Adding LLVM-commits since it was left off.

[mgorny]

CMakeLists.txt

299 ↗

(On Diff #82885)

And anyway, why were you reinventing GNUInstallDirs? If we want the CMAKE* vars, I don't see a reason not to use the module completely.

[nalimilan]

Thanks for the review!

CMakeLists.txt

299 ↗

(On Diff #82885)

I'm not that familiar with CMake, so I don't really know how modules work.I thought I would propose the less invasive patch for a start. But I can use GNUInstallDirs if you think that's the best approach.

301 ↗

(On Diff #82885)

I see, but what should I do here? Drop LLVM_LIBDIR_SUFFIX? Stop caching it? Same for the other uses, I'm not sure what's the best approach.

305 ↗

(On Diff #82885)

Is there a reason to use ${project} here instead of just llvm?

[mgorny]

CMakeLists.txt

305 ↗

(On Diff #82885)

Yes. Those paths were used in e.g. clang, and there project evaluated to clang. At least for stand-alone builds, that is.

[beanz]

CMakeLists.txt

299 ↗

(On Diff #82885)

If you use the GNUInstallDirs module, then it makes sense to keep the CMAKE_* prefixes, however GNUInstallDirs may not play well with LLVM_LIBDIR_SUFFIX.

301 ↗

(On Diff #82885)

I would not include LLVM_LIBDIR_SUFFIX in the cached variable and instead include it at the use sites. CMake has no strategy for cache invalidation, so once a variable is cached it is very difficult to make it not cached.

305 ↗

(On Diff #82885)

I would drop ${project} from the cached variable and have the docs directory add project at the end in each sub-project.

[nalimilan]

Sorry for the delay. I think this new revision takes into account all remarks. Though the naming of the variables is still open for discussion.

[nalimilan]

CMakeLists.txt

299 ↗

(On Diff #82885)

Yeah, so we cannot use GNUInstallDirs without breaking backward compatibility WRT LLVM_LIBDIR_SUFFIX. So I won't use it unless you're OK with dropping that variable.

Yet I suggest using the same names instead of adding an LLVM suffix: that's more discoverable for users; it doesn't really make sense to change the same of these standard variables for each project. In particular, Linux distributions offer convenience macros to build packages, which cannot work if variables don't follow a standard scheme.

Though e.g. Fedora currently uses a different convention, with LIB_INSTALL_DIR, INCLUDE_INSTALL_DIR and SHARE_INSTALL_PREFIX. I guess we could use that instead.

[beanz]

A few comments inline. Since these variables are used by the LLVM CMake modules, they also need to be added to LLVMConfig.cmake.in. Otherwise they will break out-of-tree builds.

CMakeLists.txt

310 ↗

(On Diff #86946)

Since this isn't cached, you also shouldn't put a type or comment.

312 ↗

(On Diff #86946)

This one too.

[nalimilan]

Done.

[nalimilan]

Bump. I have rebased against current master.

[nalimilan]

Re-bump. ;-)

[nalimilan]

Re-re-bump!

[mgorny]

Hmm, what about using GNUInstallDirs, and adding some extra initial logic to handle LLVM_LIBDIR_SUFFIX? I'm wondering how ugly would it be e.g. to detect when ${CMAKE_INSTALL_LIBDIR} ends with ${LLVM_LIBDIR_SUFFIX}, and unset the latter in that case (maybe with an informatory message).

[nalimilan]

Given that the PR works as-is and doesn't add too much code, I don't really see the advantage of moving to an "ugly" solution just to use GNUInstallDirs. Is there a strong advantage to that?

[mgorny]

Are you seriously asking me if there's an advantage to reusing existing, standard, built-in solution that lets users apply the same solutions across different CMake projects over reinventing the wheel, poorly in an unpredictably incompatible way that's going to surprise everyone who knows GNUInstallDirs and sees CMAKE_INSTALL_LIBDIR that behaves differently than the one he knows?

[krytarowski]

In D28234#1337321, @nalimilan wrote:

Given that the PR works as-is and doesn't add too much code, I don't really see the advantage of moving to an "ugly" solution just to use GNUInstallDirs. Is there a strong advantage to that?

Please do use GNUInstallDirs. This way it will be compatible with all cmake users beyond few tested targets and it will be easy to tweak using standard cmake options.

[nalimilan]

Well, I'm all for using standard solutions in general. But I'm afraid GNUInstallDirs won't play very well with LLVM_LIBDIR_SUFFIX. Let me investigate that again (last time you asked me this was almost two years ago...).

[krytarowski]

In D28234#1337338, @nalimilan wrote:

Well, I'm all for using standard solutions in general. But I'm afraid GNUInstallDirs won't play very well with LLVM_LIBDIR_SUFFIX. Let me investigate that again (last time you asked me this was almost two years ago...).

libdir suffix is mostly linux thing and should be handled through GNUInstallDirs.

[Ericson2314]

I am interested in this. Were it to be revived and, say, made to use GNUInstallDirs as others suggest, would this be something that might land?

[lebedev.ri]

In D28234#2532970, @Ericson2314 wrote:

I am interested in this. Were it to be revived and, say, made to use GNUInstallDirs as others suggest, would this be something that might land?

In general - i think so

[Ericson2314]

Rebase to latest main

[Ericson2314]

OK so anyone have any opinions on how GNUInstallDirs ought out to interact with the llvm prefix suffix, and build-mode?

Also, while I did the plain rebase reusing this diff, I suppose I should open a new one for the more creatively-different GNUInstallDirs-using version.

[Ericson2314]

I made a new version of this D99484. I figured a separate revision was in order as I substantially revised it and it now supports many more LLVM projects than just llvm/ proper.

llvm/CMakeLists.txt

 
 string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 
 if (CMAKE_BUILD_TYPE AND
     NOT uppercase_CMAKE_BUILD_TYPE MATCHES "^(DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL)$")
   message(FATAL_ERROR "Invalid value for CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
 endif()
 
-set(LLVM_LIBDIR_SUFFIX "" CACHE STRING "Define suffix of library directory name (32/64)" )
+set(LLVM_LIBDIR_SUFFIX ""
+    CACHE STRING "Define suffix of library directory name (32/64)" )
+set(CMAKE_INSTALL_BINDIR bin
+    CACHE STRING "Path for binary directory relative to CMAKE_INSTALL_PREFIX (defaults to 'bin')" )
+set(CMAKE_INSTALL_LIBDIR lib
+    CACHE STRING "Path for library directory relative to CMAKE_INSTALL_PREFIX (defaults to 'lib'" )
+set(CMAKE_INSTALL_INCLUDEDIR include
+    CACHE STRING "Path for include directory relative to CMAKE_INSTALL_PREFIX (defaults to 'include'" )
+set(CMAKE_INSTALL_DOCDIR share/doc
+    CACHE STRING "Path for documentation directory relative to CMAKE_INSTALL_PREFIX (defaults to 'share/doc')" )
+set(CMAKE_INSTALL_MANDIR share/man
+    CACHE STRING "Path for manpages directory relative to CMAKE_INSTALL_PREFIX (defaults to 'share/man')" )
 
-set(LLVM_TOOLS_INSTALL_DIR "bin" CACHE STRING "Path for binary subdirectory (defaults to 'bin')")
-mark_as_advanced(LLVM_TOOLS_INSTALL_DIR)
+set(LLVM_INSTALL_DOXYGEN_HTML_DIR "${CMAKE_INSTALL_DOCDIR}/${project}/doxygen-html")
+set(LLVM_INSTALL_OCAMLDOC_HTML_DIR "${CMAKE_INSTALL_DOCDIR}/${project}/ocaml-html")
 
 set(LLVM_UTILS_INSTALL_DIR "${LLVM_TOOLS_INSTALL_DIR}" CACHE STRING
     "Path to install LLVM utilities (enabled by LLVM_INSTALL_UTILS=ON) (defaults to LLVM_TOOLS_INSTALL_DIR)")
 mark_as_advanced(LLVM_UTILS_INSTALL_DIR)
 
 # They are used as destination of target generators.
-set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
-set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
+set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${CMAKE_INSTALL_BINDIR})
+set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX})
 if(WIN32 OR CYGWIN)
   # DLL platform -- put DLLs into bin.
   set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
 else()
   set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
 endif()
 
 # Each of them corresponds to llvm-config's.

 
 option (LLVM_BUILD_DOCS "Build the llvm documentation." OFF)
 option (LLVM_INCLUDE_DOCS "Generate build targets for llvm documentation." ON)
 option (LLVM_ENABLE_DOXYGEN "Use doxygen to generate llvm API documentation." OFF)
 option (LLVM_ENABLE_SPHINX "Use Sphinx to generate llvm documentation." OFF)
 option (LLVM_ENABLE_OCAMLDOC "Build OCaml bindings documentation." ON)
 option (LLVM_ENABLE_BINDINGS "Build bindings." ON)
 
-set(LLVM_INSTALL_DOXYGEN_HTML_DIR "share/doc/llvm/doxygen-html"
-    CACHE STRING "Doxygen-generated HTML documentation install directory")
-set(LLVM_INSTALL_OCAMLDOC_HTML_DIR "share/doc/llvm/ocaml-html"
-    CACHE STRING "OCamldoc-generated HTML documentation install directory")
-
 option (LLVM_BUILD_EXTERNAL_COMPILER_RT
   "Build compiler-rt as an external project." OFF)
 
 option (LLVM_VERSION_PRINTER_SHOW_HOST_TARGET_INFO
   "Show target and host info when tools are invoked with --version." ON)
 
 # You can configure which libraries from LLVM you want to include in the
 # shared library by setting LLVM_DYLIB_COMPONENTS to a semi-colon delimited
configure_file(
   ${LLVM_INCLUDE_DIR}/llvm/Config/Disassemblers.def
   )
 configure_file(
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/Targets.def.in
   ${LLVM_INCLUDE_DIR}/llvm/Config/Targets.def
   )
 
 # They are not referenced. See set_output_directory().
-set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/bin )
-set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
-set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX} )
+set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/${CMAKE_INSTALL_BINDIR} )
+set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX} )
+set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LLVM_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX} )
 
 # For up-to-date instructions for installing the Tensorflow dependency, refer to
 # the bot setup script: https://github.com/google/ml-compiler-opt/blob/master/buildbot/buildbot_init.sh
 # In this case, the latest C API library is available for download from
 # https://www.tensorflow.org/install/lang_c.
 # We will expose the conditional compilation variable,
 # LLVM_HAVE_TF_API, through llvm-config.h, so that a user of the LLVM library may
 # also leverage the dependency.

 
 # Do this last so that all lit targets have already been created.
 if (LLVM_INCLUDE_UTILS)
   add_subdirectory(utils/llvm-lit)
 endif()
 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   install(DIRECTORY include/llvm include/llvm-c
-    DESTINATION include
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
     COMPONENT llvm-headers
     FILES_MATCHING
     PATTERN "*.def"
     PATTERN "*.h"
     PATTERN "*.td"
     PATTERN "*.inc"
     PATTERN "LICENSE.TXT"
     )
 
   install(DIRECTORY ${LLVM_INCLUDE_DIR}/llvm ${LLVM_INCLUDE_DIR}/llvm-c
-    DESTINATION include
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
     COMPONENT llvm-headers
     FILES_MATCHING
     PATTERN "*.def"
     PATTERN "*.h"
     PATTERN "*.gen"
     PATTERN "*.inc"
     # Exclude include/llvm/CMakeFiles/intrinsics_gen.dir, matched by "*.def"
     PATTERN "CMakeFiles" EXCLUDE

llvm/cmake/modules/AddLLVM.cmake

if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ARG_INSTALL_WITH_TOOLCHAIN)
           (in_llvm_libs AND "llvm-libraries" IN_LIST LLVM_DISTRIBUTION_COMPONENTS) OR
           NOT LLVM_DISTRIBUTION_COMPONENTS)
         set(export_to_llvmexports EXPORT LLVMExports)
         set_property(GLOBAL PROPERTY LLVM_HAS_EXPORTS True)
       endif()
 
       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}${LLVM_LIBDIR_SUFFIX} COMPONENT ${name}
+              ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX} COMPONENT ${name}
               RUNTIME DESTINATION bin COMPONENT ${name})
 
       if (NOT LLVM_ENABLE_IDE)
         add_llvm_install_targets(install-${name}
                                  DEPENDS ${name}
                                  COMPONENT ${name})
       endif()
     endif()
function(process_llvm_pass_plugins)
   endforeach()
 
   # Eventually generate the extension headers, and store config to a cmake file
   # for usage in third-party configuration.
   if(ARG_GEN_CONFIG)
 
       ## Part 1: Extension header to be included whenever we need extension
       #  processing.
-      set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
+      set(LLVM_INSTALL_PACKAGE_DIR ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
       set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")
       file(WRITE
           "${llvm_cmake_builddir}/LLVMConfigExtensions.cmake"
           "set(LLVM_STATIC_EXTENSIONS ${LLVM_STATIC_EXTENSIONS})")
       install(FILES
           ${llvm_cmake_builddir}/LLVMConfigExtensions.cmake
           DESTINATION ${LLVM_INSTALL_PACKAGE_DIR}
           COMPONENT cmake-exports)
 
-      set(ExtensionDef "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def")
+      set(ExtensionDef "${LLVM_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}/llvm/Support/Extension.def")
       file(WRITE "${ExtensionDef}.tmp" "//extension handlers\n")
       foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS})
           file(APPEND "${ExtensionDef}.tmp" "HANDLE_EXTENSION(${llvm_extension})\n")
       endforeach()
       file(APPEND "${ExtensionDef}.tmp" "#undef HANDLE_EXTENSION\n")
 
       # only replace if there's an actual change
       execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different
if( LLVM_BUILD_TOOLS )
       if(${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
           NOT LLVM_DISTRIBUTION_COMPONENTS)
         set(export_to_llvmexports EXPORT LLVMExports)
         set_property(GLOBAL PROPERTY LLVM_HAS_EXPORTS True)
       endif()
 
       install(TARGETS ${name}
               ${export_to_llvmexports}
-              RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR}
+              RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
               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")
 endmacro(add_llvm_tool name)
 
 
 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 )
-    install(TARGETS ${name} RUNTIME DESTINATION examples)
+    install(TARGETS ${name} RUNTIME DESTINATION ${CMAKE_INSTALL_DOCDIR}/examples)
   endif()
   set_target_properties(${name} PROPERTIES FOLDER "Examples")
 endmacro(add_llvm_example name)
 
 macro(add_llvm_example_library name)
   if( NOT LLVM_BUILD_EXAMPLES )
     set(EXCLUDE_FROM_ALL ON)
     add_llvm_library(${name} BUILDTREE_ONLY ${ARGN})
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_LIBDIR}${LLVM_LIBDIR_SUFFIX})
   if(WIN32 AND "${type}" STREQUAL "SHARED")
     set(output_dir bin)
   endif()
 
   install(SCRIPT ${INSTALL_SYMLINK}
           CODE "install_symlink(${full_name} ${full_dest} ${output_dir})"
           COMPONENT ${component})
 
else()
       set(component ${name})
     endif()
   endif()
 
   set(full_name ${name}${CMAKE_EXECUTABLE_SUFFIX})
   set(full_dest ${dest}${CMAKE_EXECUTABLE_SUFFIX})
 
   install(SCRIPT ${INSTALL_SYMLINK}
-          CODE "install_symlink(${full_name} ${full_dest} ${LLVM_TOOLS_INSTALL_DIR})"
+          CODE "install_symlink(${full_name} ${full_dest} ${CMAKE_INSTALL_BINDIR})"
           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()
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}${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
   elseif(UNIX)
-    set(_install_rpath "\$ORIGIN/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
+    set(_install_rpath "\$ORIGIN/../${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}" ${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} ")
function(setup_dependency_debugging name)
   if(NOT LLVM_DEPENDENCY_DEBUGGING)
     return()
   endif()
 
   if("intrinsics_gen" IN_LIST ARGN)
     return()
   endif()
 
-  set(deny_attributes_inc "(deny file* (literal \"${LLVM_BINARY_DIR}/include/llvm/IR/Attributes.inc\"))")
-  set(deny_intrinsics_inc "(deny file* (literal \"${LLVM_BINARY_DIR}/include/llvm/IR/Intrinsics.inc\"))")
+  set(deny_attributes_inc "(deny file* (literal \"${LLVM_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}/llvm/IR/Attributes.inc\"))")
+  set(deny_intrinsics_inc "(deny file* (literal \"${LLVM_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}/llvm/IR/Intrinsics.inc\"))")
 
   set(sandbox_command "sandbox-exec -p '(version 1) (allow default) ${deny_attributes_inc} ${deny_intrinsics_inc}'")
   set_target_properties(${name} PROPERTIES RULE_LAUNCH_COMPILE ${sandbox_command})
 endfunction()
 
 # If the sources at the given `path` are under version control, set `out_var`
 # to the the path of a file which will be modified when the VCS revision
 # changes, attempting to create that file if it does not exist; if no such

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}${LLVM_LIBDIR_SUFFIX}")
   elseif( UNIX )
-    set(ocaml_rpath "\\$ORIGIN/../../../lib${LLVM_LIBDIR_SUFFIX}")
+    set(ocaml_rpath "\\$ORIGIN/../../../${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}")
   endif()
   list(APPEND ocaml_flags "-ldopt" "-Wl,-rpath,${ocaml_rpath}")
 
   add_custom_command(
     OUTPUT ${ocaml_outputs}
     COMMAND "${OCAMLFIND}" "ocamlmklib" "-o" "${name}" ${ocaml_flags} ${ocaml_params}
     DEPENDS ${ocaml_inputs} ${c_outputs}
     COMMENT "Building OCaml library ${name}"

llvm/cmake/modules/AddSphinxTarget.cmake

if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
 
         if(NOT LLVM_ENABLE_IDE)
           add_llvm_install_targets("install-${SPHINX_TARGET_NAME}"
                                    DEPENDS ${SPHINX_TARGET_NAME}
                                    COMPONENT "${project}-sphinx-man")
         endif()
       elseif (builder STREQUAL html)
         string(TOUPPER "${project}" project_upper)
-        set(${project_upper}_INSTALL_SPHINX_HTML_DIR "share/doc/${project}/html"
+        set(${project_upper}_INSTALL_SPHINX_HTML_DIR "${CMAKE_INSTALL_DOCDIR}/${project}/html"
             CACHE STRING "HTML documentation install directory for ${project}")
 
         # '/.' indicates: copy the contents of the directory directly into
         # the specified destination, without recreating the last component
         # of ${SPHINX_BUILD_DIR} implicitly.
         install(DIRECTORY "${SPHINX_BUILD_DIR}/."
                 COMPONENT "${project}-sphinx-html"
                 DESTINATION "${${project_upper}_INSTALL_SPHINX_HTML_DIR}")

llvm/cmake/modules/CMakeLists.txt

-set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
+set(LLVM_INSTALL_PACKAGE_DIR ${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX}/cmake/llvm CACHE STRING "Path for CMake subdirectory (defaults to 'cmake/llvm')")
 set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")
 
 # First for users who use an installed LLVM, create the LLVMExports.cmake file.
 set(LLVM_EXPORTS_FILE ${llvm_cmake_builddir}/LLVMExports.cmake)
 get_property(LLVM_EXPORTS GLOBAL PROPERTY LLVM_EXPORTS)
 export(TARGETS ${LLVM_EXPORTS} FILE ${LLVM_EXPORTS_FILE})
 
 # Then for users who want to link against the LLVM build tree, provide the

 get_filename_component(LLVM_INSTALL_PREFIX \"\${CMAKE_CURRENT_LIST_FILE}\" PATH)")
 # Construct the proper number of get_filename_component(... PATH)
 # calls to compute the installation prefix.
 string(REGEX REPLACE "/" ";" _count "${LLVM_INSTALL_PACKAGE_DIR}")
 foreach(p ${_count})
   set(LLVM_CONFIG_CODE "${LLVM_CONFIG_CODE}
 get_filename_component(LLVM_INSTALL_PREFIX \"\${LLVM_INSTALL_PREFIX}\" PATH)")
 endforeach(p)
-set(LLVM_CONFIG_INCLUDE_DIRS "\${LLVM_INSTALL_PREFIX}/include")
+set(LLVM_CONFIG_INCLUDE_DIRS "\${LLVM_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}")
 set(LLVM_CONFIG_INCLUDE_DIR "${LLVM_CONFIG_INCLUDE_DIRS}")
 set(LLVM_CONFIG_MAIN_INCLUDE_DIR "${LLVM_CONFIG_INCLUDE_DIRS}")
-set(LLVM_CONFIG_LIBRARY_DIRS "\${LLVM_INSTALL_PREFIX}/lib\${LLVM_LIBDIR_SUFFIX}")
+set(LLVM_CONFIG_LIBRARY_DIRS "\${LLVM_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}\${LLVM_LIBDIR_SUFFIX}")
 set(LLVM_CONFIG_CMAKE_DIR "\${LLVM_INSTALL_PREFIX}/${LLVM_INSTALL_PACKAGE_DIR}")
 set(LLVM_CONFIG_BINARY_DIR "\${LLVM_INSTALL_PREFIX}")
-set(LLVM_CONFIG_TOOLS_BINARY_DIR "\${LLVM_INSTALL_PREFIX}/bin")
+set(LLVM_CONFIG_TOOLS_BINARY_DIR "\${LLVM_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}")
 
 # Generate a default location for lit
 if (LLVM_INSTALL_UTILS AND LLVM_BUILD_UTILS)
   set(LLVM_CONFIG_DEFAULT_EXTERNAL_LIT "${LLVM_CONFIG_TOOLS_BINARY_DIR}/llvm-lit")
 endif()
 
 set(LLVM_CONFIG_EXPORTS_FILE "\${LLVM_CMAKE_DIR}/LLVMExports.cmake")
 set(LLVM_CONFIG_EXPORTS "${LLVM_EXPORTS}")

llvm/cmake/modules/LLVMConfig.cmake.in

 set(LLVM_INCLUDE_DIR "@LLVM_CONFIG_INCLUDE_DIR@")
 set(LLVM_MAIN_INCLUDE_DIR "@LLVM_CONFIG_MAIN_INCLUDE_DIR@")
 set(LLVM_LIBRARY_DIR "@LLVM_CONFIG_LIBRARY_DIRS@")
 
 set(LLVM_DEFINITIONS "@LLVM_DEFINITIONS@")
 set(LLVM_CMAKE_DIR "@LLVM_CONFIG_CMAKE_DIR@")
 set(LLVM_BINARY_DIR "@LLVM_CONFIG_BINARY_DIR@")
 set(LLVM_TOOLS_BINARY_DIR "@LLVM_CONFIG_TOOLS_BINARY_DIR@")
-set(LLVM_TOOLS_INSTALL_DIR "@LLVM_TOOLS_INSTALL_DIR@")
+set(LLVM_TOOLS_INSTALL_DIR "@CMAKE_INSTALL_BINDIR@")
 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(CMAKE_INSTALL_BINDIR "@CMAKE_INSTALL_BINDIR@")
+set(CMAKE_INSTALL_LIBDIR "@CMAKE_INSTALL_LIBDIR@")
+set(CMAKE_INSTALL_INCLUDEDIR "@CMAKE_INSTALL_INCLUDEDIR@")
+set(CMAKE_INSTALL_DOCDIR "@CMAKE_INSTALL_DOCDIR@")
+set(CMAKE_INSTALL_MANDIR "@CMAKE_INSTALL_MANDIR@")
+
 if(NOT TARGET LLVMSupport)
   set(LLVM_EXPORTED_TARGETS "@LLVM_CONFIG_EXPORTS@")
   include("@LLVM_CONFIG_EXPORTS_FILE@")
   @llvm_config_include_buildtree_only_exports@
 endif()
 
 # By creating intrinsics_gen, omp_gen and acc_gen here, subprojects that depend
 # on LLVM's tablegen-generated headers can always depend on this target whether

llvm/docs/CMake.rst

 
 **CMAKE_INSTALL_PREFIX**:PATH
   Path where LLVM will be installed if "make install" is invoked or the
   "install" target is built.
 
 **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``.
+  to install libraries to ``/usr/lib64``. See also ``CMAKE_INSTALL_LIBDIR``.
 
 **CMAKE_C_FLAGS**:STRING
   Extra flags to use when compiling C source files.
 
 **CMAKE_CXX_FLAGS**:STRING
   Extra flags to use when compiling C++ source files.
 
 Rarely-used CMake variables
**LLVM_DOXYGEN_QHELPGENERATOR_PATH**:STRING
   effect.
 
 **LLVM_DOXYGEN_SVG**:BOOL
   Uses .svg files instead of .png files for graphs in the Doxygen output.
   Defaults to OFF.
 
 **LLVM_INSTALL_DOXYGEN_HTML_DIR**:STRING
   The path to install Doxygen-generated HTML documentation to. This path can
-  either be absolute or relative to the CMAKE_INSTALL_PREFIX. Defaults to
-  `share/doc/llvm/doxygen-html`.
+  either be absolute or relative to the ``CMAKE_INSTALL_PREFIX``. Defaults to
+  `${CMAKE_INSTALL_DOCDIR}/${project}/doxygen-html`.
 
 **LLVM_ENABLE_SPHINX**:BOOL
   If specified, CMake will search for the ``sphinx-build`` executable and will make
   the ``SPHINX_OUTPUT_HTML`` and ``SPHINX_OUTPUT_MAN`` CMake options available.
   Defaults to OFF.
 
 **SPHINX_EXECUTABLE**:STRING
   The path to the ``sphinx-build`` executable detected by CMake.
**SPHINX_OUTPUT_MAN**:BOOL
   to ON.
 
 **SPHINX_WARNINGS_AS_ERRORS**:BOOL
   If enabled then sphinx documentation warnings will be treated as
   errors. Defaults to ON.
 
 **LLVM_INSTALL_SPHINX_HTML_DIR**:STRING
   The path to install Sphinx-generated HTML documentation to. This path can
-  either be absolute or relative to the CMAKE_INSTALL_PREFIX. Defaults to
-  `share/doc/llvm/html`.
+  either be absolute or relative to the ``CMAKE_INSTALL_PREFIX``. Defaults to
+  `${CMAKE_INSTALL_DOCDIR}/${project}/html`.
 
 **LLVM_INSTALL_OCAMLDOC_HTML_DIR**:STRING
   The path to install OCamldoc-generated HTML documentation to. This path can
-  either be absolute or relative to the CMAKE_INSTALL_PREFIX. Defaults to
-  `share/doc/llvm/ocaml-html`.
+  either be absolute or relative to the ``CMAKE_INSTALL_PREFIX``. Defaults to
+  `${CMAKE_INSTALL_DOCDIR}/${project}/ocaml-html`.
+
+**CMAKE_INSTALL_BINDIR**:STRING
+  The path to install binary tools, relative to the ``CMAKE_INSTALL_PREFIX``.
+  Defaults to `bin`.
+
+**CMAKE_INSTALL_LIBDIR**:STRING
+  The path to install libraries, relative to the ``CMAKE_INSTALL_PREFIX``.
+  Defaults to `lib`.
+
+**CMAKE_INSTALL_INCLUDEDIR**:STRING
+  The path to install header files, relative to the ``CMAKE_INSTALL_PREFIX``.
+  Defaults to `include`.
+
+**CMAKE_INSTALL_DOCDIR**:STRING
+  The path to install documentation, relative to the ``CMAKE_INSTALL_PREFIX``.
+  Defaults to `share/doc`.
+
+**CMAKE_INSTALL_MANDIR**:STRING
+  The path to install manpage files, relative to the ``CMAKE_INSTALL_PREFIX``.
+  Defaults to `share/man`.
 
 **LLVM_CREATE_XCODE_TOOLCHAIN**:BOOL
   macOS Only: If enabled CMake will generate a target named
   'install-xcode-toolchain'. This target will create a directory at
   $CMAKE_INSTALL_PREFIX/Toolchains containing an xctoolchain directory which can
   be used to override the default system tools.
 
 **LLVM_BUILD_LLVM_DYLIB**:BOOL

llvm/include/llvm/CMakeLists.txt

 add_subdirectory(IR)
 add_subdirectory(Support)
 add_subdirectory(Frontend)
 
 # If we're doing an out-of-tree build, copy a module map for generated
 # header files into the build area.
 if (NOT "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
-  configure_file(module.modulemap.build module.modulemap COPYONLY)
+  configure_file(module.modulemap.build ${LLVM_INCLUDE_DIR}/module.modulemap COPYONLY)
 endif (NOT "${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")

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_INSTALL_BINDIR "@CMAKE_INSTALL_BINDIR@"
+#define LLVM_INSTALL_LIBDIR "@CMAKE_INSTALL_LIBDIR@"
+#define LLVM_INSTALL_INCLUDEDIR "@CMAKE_INSTALL_INCLUDEDIR@"
 #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

 //===-- llvm-config.cpp - LLVM project configuration utility --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
#endif
   }
 
   // Compute various directory locations based on the derived location
   // information.
   std::string ActivePrefix, ActiveBinDir, ActiveIncludeDir, ActiveLibDir,
               ActiveCMakeDir;
   std::string ActiveIncludeOption;
   if (IsInDevelopmentTree) {
-    ActiveIncludeDir = std::string(LLVM_SRC_ROOT) + "/include";
+    ActiveIncludeDir = std::string(LLVM_SRC_ROOT) + "/" + LLVM_INSTALL_INCLUDEDIR;
     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;
+      ActiveBinDir = ActiveObjRoot + "/" + LLVM_INSTALL_BINDIR;
+      ActiveLibDir = ActiveObjRoot + LLVM_INSTALL_LIBDIR + LLVM_LIBDIR_SUFFIX;
       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";
+      ActiveBinDir = ActiveObjRoot + "/" + build_mode + "/" + LLVM_INSTALL_BINDIR;
       ActiveLibDir =
-          ActiveObjRoot + "/" + build_mode + "/lib" + LLVM_LIBDIR_SUFFIX;
+          ActiveObjRoot + "/" + build_mode + "/" + LLVM_INSTALL_LIBDIR + LLVM_LIBDIR_SUFFIX;
       // The CMake directory isn't separated by build mode.
       ActiveCMakeDir =
-          ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX + "/cmake/llvm";
+          ActivePrefix + "/" + LLVM_INSTALL_LIBDIR + LLVM_LIBDIR_SUFFIX + "/cmake/llvm";
       break;
     }
 
     // We need to include files from both the source and object trees.
     ActiveIncludeOption =
-        ("-I" + ActiveIncludeDir + " " + "-I" + ActiveObjRoot + "/include");
+        ("-I" + ActiveIncludeDir + " " + "-I" + ActiveObjRoot + "/" + LLVM_INSTALL_INCLUDEDIR);
   } else {
     ActivePrefix = CurrentExecPrefix;
-    ActiveIncludeDir = ActivePrefix + "/include";
-    SmallString<256> path(StringRef(LLVM_TOOLS_INSTALL_DIR));
+    ActiveIncludeDir = ActivePrefix + "/" + LLVM_INSTALL_INCLUDEDIR;
+    SmallString<256> path(StringRef(LLVM_INSTALL_BINDIR));
     sys::fs::make_absolute(ActivePrefix, path);
     ActiveBinDir = std::string(path.str());
-    ActiveLibDir = ActivePrefix + "/lib" + LLVM_LIBDIR_SUFFIX;
+    ActiveLibDir = ActivePrefix + "/" + LLVM_INSTALL_LIBDIR + LLVM_LIBDIR_SUFFIX;
     ActiveCMakeDir = ActiveLibDir + "/cmake/llvm";
     ActiveIncludeOption = "-I" + ActiveIncludeDir;
   }
 
   /// We only use `shared library` mode in cases where the static library form
   /// of the components provided are not available; note however that this is
   /// skipped if we're run from within the build dir. However, once installed,
   /// we still need to provide correct output when the static archives are

llvm/tools/llvm-shlib/CMakeLists.txt

if(NOT LLVM_BUILD_LLVM_DYLIB)
     message(FATAL_ERROR "Generating libLLVM-c requires LLVM_BUILD_LLVM_C_DYLIB on Darwin")
   endif()
 
   # To get the export list for a single llvm library:
   # nm ${LIB_PATH} | awk "/T _LLVM/ { print $3 }" | sort -u | sed -e "s/^_//g" > ${LIB_PATH}.exports
 
   set(LLVM_EXPORTED_SYMBOL_FILE ${CMAKE_BINARY_DIR}/libllvm-c.exports)
 
-  set(LIB_DIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
+  set(LIB_DIR ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${CMAKE_INSTALL_LIBDIR}${LLVM_LIBDIR_SUFFIX})
   set(LIB_NAME ${LIB_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}LLVM)
   set(LIB_PATH ${LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX})
   set(LIB_EXPORTS_PATH ${LIB_NAME}.exports)
   list(APPEND LLVM_DYLIB_REQUIRED_EXPORTS ${LIB_EXPORTS_PATH})
 
   add_custom_command(OUTPUT ${LLVM_EXPORTED_SYMBOL_FILE}
     COMMAND nm ${LIB_PATH} | awk "/T _LLVM/ || /T LLVM/ { print $3 }" | sort -u | sed -e "s/^_//g" > ${LLVM_EXPORTED_SYMBOL_FILE}
     WORKING_DIRECTORY ${LIB_DIR}

llvm/tools/lto/CMakeLists.txt

set(SOURCES
   )
 
 set(LLVM_EXPORTED_SYMBOL_FILE ${CMAKE_CURRENT_SOURCE_DIR}/lto.exports)
 
 add_llvm_library(LTO SHARED INSTALL_WITH_TOOLCHAIN ${SOURCES} DEPENDS
     intrinsics_gen)
 
 install(FILES ${LLVM_MAIN_INCLUDE_DIR}/llvm-c/lto.h
-  DESTINATION include/llvm-c
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/llvm-c
   COMPONENT LTO)
 
 if (APPLE)
   set(LTO_VERSION ${LLVM_VERSION_MAJOR})
   if(LLVM_LTO_VERSION_OFFSET)
     math(EXPR LTO_VERSION "${LLVM_VERSION_MAJOR} + ${LLVM_LTO_VERSION_OFFSET}")
   endif()
   set_property(TARGET LTO APPEND_STRING PROPERTY
               LINK_FLAGS
               " -compatibility_version 1 -current_version ${LTO_VERSION}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}")
 endif()