[cmake] Add support for multiple distributions

[smeenai]

Summary

LLVM's build system contains support for configuring a distribution, but
it can often be useful to be able to configure multiple distributions
(e.g. if you want separate distributions for the tools and the
libraries). Add this support to the build system, along with
documentation and usage examples.

[compnerd]

I've not taken a thorough look at the changes, but I am definitely in favour of this change (conceptually).

[phosek]

We've already considered introducing a similar mechanism so thank you for working on this! There's one issue that I haven't figured out how to resolve and I'd be interested in your thoughts: building executables and libraries in the most optimal may require incompatible flags. For example, when building a shared library you have to use -fPIC but for executables that's suboptimal; similarly, when building executables you may want to use LTO but if you also want to create a distribution that contains static libraries, that's a problem because those will contain bitcode. So far our solution has been to simply do multiple builds with different flags (in GN this can be done in a single build by leveraging the "toolchain" concept that also allows sharing as much work as possible, but I haven't figured out how to do anything like that in CMake).

llvm/cmake/modules/LLVMDistributionSupport.cmake

39

Can we use EMPTY or something along those lines to make it more obvious?

186

Can we use EMPTY or something along those lines to make it more obvious?

[smeenai]

In D89177#2325566, @phosek wrote:

We've already considered introducing a similar mechanism so thank you for working on this! There's one issue that I haven't figured out how to resolve and I'd be interested in your thoughts: building executables and libraries in the most optimal may require incompatible flags. For example, when building a shared library you have to use -fPIC but for executables that's suboptimal; similarly, when building executables you may want to use LTO but if you also want to create a distribution that contains static libraries, that's a problem because those will contain bitcode. So far our solution has been to simply do multiple builds with different flags (in GN this can be done in a single build by leveraging the "toolchain" concept that also allows sharing as much work as possible, but I haven't figured out how to do anything like that in CMake).

Good question. We need something similar as well, where some clients of the libraries want them built with RTTI (because their programs rely on RTTI and you can get link errors when linking them against non-RTTI LLVM libraries), but we don't wanna build the executables with RTTI because of the size increases.

I don't know of any way to do this in CMake other than just configuring multiple times with the different flags, like you said. Maybe we could implement some logic for that in the build system, but I'm not sure if it's worth it. (I'm wondering if the Ninja multi-config generator added in CMake 3.17 could be useful for this, although I haven't played around with that at all yet.) I do recognize it limits the usefulness of this approach quite a bit (since if you're doing separate configurations you can just do different LLVM_DISTRIBUTION_COMPONENT settings), but I'm hoping it can still be valuable for simpler scenarios.

Out of curiosity, with GN, how would you specify that you want binaries to be built with one toolchain (e.g. LTO and non-PIC) and libraries with another (e.g. non-LTO and PIC)?

llvm/cmake/modules/LLVMDistributionSupport.cmake

39

Sure, I'll change it.

[smeenai]

Reading up on the Ninja multi-config generator a bit, you can define your own build types, so you should be able to create e.g. one build type for LTO and another for PIC. You'd still need some external logic to define that you use the LTO mode for executables and the PIC mode for libraries, but the multiple distribution support should work nicely in conjunction with that.

Unfortunately, I don't think that'll work for my RTTI case, since LLVM's flag additions for enabling or disabling (based on LLVM_ENABLE_RTTI) will override any flags you specify for your build type. (Maybe there's a reasonable way to tweak the build system to support that case though.)

[phosek]

In D89177#2326832, @smeenai wrote:

In D89177#2325566, @phosek wrote:

We've already considered introducing a similar mechanism so thank you for working on this! There's one issue that I haven't figured out how to resolve and I'd be interested in your thoughts: building executables and libraries in the most optimal may require incompatible flags. For example, when building a shared library you have to use -fPIC but for executables that's suboptimal; similarly, when building executables you may want to use LTO but if you also want to create a distribution that contains static libraries, that's a problem because those will contain bitcode. So far our solution has been to simply do multiple builds with different flags (in GN this can be done in a single build by leveraging the "toolchain" concept that also allows sharing as much work as possible, but I haven't figured out how to do anything like that in CMake).

Good question. We need something similar as well, where some clients of the libraries want them built with RTTI (because their programs rely on RTTI and you can get link errors when linking them against non-RTTI LLVM libraries), but we don't wanna build the executables with RTTI because of the size increases.

We recently ran into this as well where we need RTTI for LLVM libraries but don't want to enable it for the toolchain.

I don't know of any way to do this in CMake other than just configuring multiple times with the different flags, like you said. Maybe we could implement some logic for that in the build system, but I'm not sure if it's worth it. (I'm wondering if the Ninja multi-config generator added in CMake 3.17 could be useful for this, although I haven't played around with that at all yet.) I do recognize it limits the usefulness of this approach quite a bit (since if you're doing separate configurations you can just do different LLVM_DISTRIBUTION_COMPONENT settings), but I'm hoping it can still be valuable for simpler scenarios.

One idea I had would be to eliminate the use of global variables like CMAKE_C_FLAGS and CMAKE_CXX_FLAGS and always set these via target_compile_options (which is something we should do in any case to move towards more modern CMake); since we always use functions like add_llvm_component_library to create targets in LLVM, we could then have these create multiple targets that would differ in flags like -fPIC or -frtti and set up dependencies among these appropriately. It means you'd have to build files multiple times (I don't think there's any way around that) but you'd save time on things like tablegen.

Out of curiosity, with GN, how would you specify that you want binaries to be built with one toolchain (e.g. LTO and non-PIC) and libraries with another (e.g. non-LTO and PIC)?

In GN there's no global concept of tools like CC or LD, instead these are scoped inside a toolchain which in GN is a first class concept, and dependencies can be parametrized by toolchains (for example you can have deps = [ "//path/to/dependency(//path/to/toolchain)" ]. These toolchains can be also parametrized and templated. A common use case is to have a variety of toolchains that have the same tools but differ in flags like -fPIC. In Ninja this is represented as subninjas where each child Ninja file defines its own set of rules.

You can see an example of this even in LLVM GN build where we define a set of toolchains in https://github.com/llvm/llvm-project/blob/1687a8d83b702332c4aae4f2a95d27c16688418d/llvm/utils/gn/build/toolchain/BUILD.gn#L179 and then use them to built runtimes in https://github.com/llvm/llvm-project/blob/1687a8d83b702332c4aae4f2a95d27c16688418d/llvm/utils/gn/secondary/compiler-rt/BUILD.gn which is an (more efficient) equivalent of the runtimes build.

[smeenai]

Address review comments

[smeenai]

In D89177#2326875, @phosek wrote:

In D89177#2326832, @smeenai wrote:

In D89177#2325566, @phosek wrote:

We've already considered introducing a similar mechanism so thank you for working on this! There's one issue that I haven't figured out how to resolve and I'd be interested in your thoughts: building executables and libraries in the most optimal may require incompatible flags. For example, when building a shared library you have to use -fPIC but for executables that's suboptimal; similarly, when building executables you may want to use LTO but if you also want to create a distribution that contains static libraries, that's a problem because those will contain bitcode. So far our solution has been to simply do multiple builds with different flags (in GN this can be done in a single build by leveraging the "toolchain" concept that also allows sharing as much work as possible, but I haven't figured out how to do anything like that in CMake).

Good question. We need something similar as well, where some clients of the libraries want them built with RTTI (because their programs rely on RTTI and you can get link errors when linking them against non-RTTI LLVM libraries), but we don't wanna build the executables with RTTI because of the size increases.

We recently ran into this as well where we need RTTI for LLVM libraries but don't want to enable it for the toolchain.

I don't know of any way to do this in CMake other than just configuring multiple times with the different flags, like you said. Maybe we could implement some logic for that in the build system, but I'm not sure if it's worth it. (I'm wondering if the Ninja multi-config generator added in CMake 3.17 could be useful for this, although I haven't played around with that at all yet.) I do recognize it limits the usefulness of this approach quite a bit (since if you're doing separate configurations you can just do different LLVM_DISTRIBUTION_COMPONENT settings), but I'm hoping it can still be valuable for simpler scenarios.

One idea I had would be to eliminate the use of global variables like CMAKE_C_FLAGS and CMAKE_CXX_FLAGS and always set these via target_compile_options (which is something we should do in any case to move towards more modern CMake); since we always use functions like add_llvm_component_library to create targets in LLVM, we could then have these create multiple targets that would differ in flags like -fPIC or -frtti and set up dependencies among these appropriately. It means you'd have to build files multiple times (I don't think there's any way around that) but you'd save time on things like tablegen.

Yeah, we should definitely be moving away from global flag manipulation (and I know @ldionne has been doing a bunch of cleanups for that in libc++). Being able to have as much commonality as possible would be nice, although CMake seems to be more in the "different configurations/build types for different build settings" camp.

Reading up on the Ninja multi-config generator more, it seems pretty well suited to handling things like PIC vs. non-PIC and LTO vs. non-LTO (although I haven't thought a lot about how those configs would interact with the multi-stage bootstrapping setups). RTTI vs. non-RTTI is more complicated (see my previous comment), but should be achievable by tweaking how LLVM's build system manipulates those flags. (Strawman proposal: have LLVM_ENABLE_RTTI accept a default argument in addition to the regular booleans to denote that you want LLVM to respect your config's flag settings for RTTI instead of trying to enforce its own.)

Out of curiosity, with GN, how would you specify that you want binaries to be built with one toolchain (e.g. LTO and non-PIC) and libraries with another (e.g. non-LTO and PIC)?

In GN there's no global concept of tools like CC or LD, instead these are scoped inside a toolchain which in GN is a first class concept, and dependencies can be parametrized by toolchains (for example you can have deps = [ "//path/to/dependency(//path/to/toolchain)" ]. These toolchains can be also parametrized and templated. A common use case is to have a variety of toolchains that have the same tools but differ in flags like -fPIC. In Ninja this is represented as subninjas where each child Ninja file defines its own set of rules.

You can see an example of this even in LLVM GN build where we define a set of toolchains in https://github.com/llvm/llvm-project/blob/1687a8d83b702332c4aae4f2a95d27c16688418d/llvm/utils/gn/build/toolchain/BUILD.gn#L179 and then use them to built runtimes in https://github.com/llvm/llvm-project/blob/1687a8d83b702332c4aae4f2a95d27c16688418d/llvm/utils/gn/secondary/compiler-rt/BUILD.gn which is an (more efficient) equivalent of the runtimes build.

GN's toolchain system is really cool :) I was wondering how you'd tell GN that you want all your binaries to be built with one toolchain and all your libraries to be built with another one, but I found https://github.com/llvm/llvm-project/blob/master/llvm/utils/gn/build/BUILDCONFIG.gn, which I think answers that question.

[ldionne]

Are the runtimes expected to support this multi-distribution configuration? I don't think we'd want to move libc++ towards building multiple configurations at once in a single CMake invocation -- it's already too complicated to build just one configuration.

While I'm very sympathetic to the use case, it looks like this is working against the design of CMake. So, as long as the runtimes are not impacted by this change (which seems to be the case right now), I don't mind. But as I said, I don't think it would be wise to start supporting multiple distributions in a single CMake invocation for the runtime libraries. I think it would add too much complexity.

[beanz]

In D89177#2332547, @ldionne wrote:

Are the runtimes expected to support this multi-distribution configuration? I don't think we'd want to move libc++ towards building multiple configurations at once in a single CMake invocation -- it's already too complicated to build just one configuration.

I don’t see why the runtimes wouldn’t be included in this, especially when using the runtimes build which already supports building multiple configurations of libc++ from a single LLVM CMake invocation which in turn runs CMake for the runtimes multiple times. In fact, I think runtimes is basically the only place where we can currently cleanly handle building with different options.

While I'm very sympathetic to the use case, it looks like this is working against the design of CMake.

The way Compiler-RT builds for Darwin is certainly against the design of CMake, but I don’t think the same is true for how the runtimes build works.

I think the general idea of configure LLVM once, define multiple different “distributions” to get different groups of targets that you can install into different root directories and package for separate installation makes a lot of sense and is useful even if it doesn’t handle distributions that have different configurations.

[ldionne]

In D89177#2332626, @beanz wrote:

In D89177#2332547, @ldionne wrote:

Are the runtimes expected to support this multi-distribution configuration? I don't think we'd want to move libc++ towards building multiple configurations at once in a single CMake invocation -- it's already too complicated to build just one configuration.

I don’t see why the runtimes wouldn’t be included in this, especially when using the runtimes build which already supports building multiple configurations of libc++ from a single LLVM CMake invocation which in turn runs CMake for the runtimes multiple times. In fact, I think runtimes is basically the only place where we can currently cleanly handle building with different options.

While I'm very sympathetic to the use case, it looks like this is working against the design of CMake.

The way Compiler-RT builds for Darwin is certainly against the design of CMake, but I don’t think the same is true for how the runtimes build works.

I think the general idea of configure LLVM once, define multiple different “distributions” to get different groups of targets that you can install into different root directories and package for separate installation makes a lot of sense and is useful even if it doesn’t handle distributions that have different configurations.

That isn't what I meant. It's entirely okay for the runtimes to be driven via AddExternalProject like the runtimes build does, since that's akin to having a separate CMake invocation for each configuration. That's okay.

What I'm saying is that if the next logical step is to also add support for multiple distributions in libc++'s build itself (e.g. adding LIBCXX_<DISTRIBUTION>_ENABLE_SHARED & al), then I don't think that's a good idea.

[beanz]

In D89177#2332627, @ldionne wrote:

That isn't what I meant. It's entirely okay for the runtimes to be driven via AddExternalProject like the runtimes build does, since that's akin to having a separate CMake invocation for each configuration. That's okay.

What I'm saying is that if the next logical step is to also add support for multiple distributions in libc++'s build itself (e.g. adding LIBCXX_<DISTRIBUTION>_ENABLE_SHARED & al), then I don't think that's a good idea.

Totally agree. That would be the path compiler-rt’s Darwin build goes, and it is a frequent problem.

[smeenai]

In D89177#2332675, @beanz wrote:

In D89177#2332627, @ldionne wrote:

That isn't what I meant. It's entirely okay for the runtimes to be driven via AddExternalProject like the runtimes build does, since that's akin to having a separate CMake invocation for each configuration. That's okay.

What I'm saying is that if the next logical step is to also add support for multiple distributions in libc++'s build itself (e.g. adding LIBCXX_<DISTRIBUTION>_ENABLE_SHARED & al), then I don't think that's a good idea.

Totally agree. That would be the path compiler-rt’s Darwin build goes, and it is a frequent problem.

Agreed as well, and I have no plans of going down that path. The multi-configuration stuff @phosek and I were discussing is related to the support CMake already has for changing flags based on your build configuration (e.g. the CMAKE_<LANG>_FLAGS_<CONFIG> variables), but something like LIBCXX_<DISTRIBUTION>_ENABLE_SHARED would be pretty different and is not a direction I plan on going in.

[smeenai]

Ping. Assuming everyone is okay with the direction, any comments on the change itself?

[smeenai]

Ping.

[phosek]

LGTM with a few nits.

clang/cmake/modules/AddClang.cmake

121

Should we make this uppercase and join it with _ to match the existing conventions? For example, you'd have ClangToolchainTargets and CLANG_TOOLCHAIN_HAS_EXPORTS. With the change as is, we would end up with CLANGToolchain_HAS_EXPORT which is a bit unusual.

lld/cmake/modules/LLDConfig.cmake.in

13

We use upper-case variables for the *_CONFIG_CODE so using lower case here is a bit unfortunate, could we use upper case for these variables?

[smeenai]

clang/cmake/modules/AddClang.cmake

121

I'm playing a little trick with the lack of underscore. In case you're using the default unnamed distribution (as in you just specified LLVM_DISTRIBUTION_COMPONENTS), ${distribution} will be empty, so it'll expand to just CLANG_HAS_EXPORTS, which matches the existing property. If you wanted to add the underscore, you'd need to special-case the unnamed distribution, which seemed like a bunch of effort for a property name that should never be accessed directly. With that being said though, since all the Add*.cmake usages of get_llvm_distribution follow a similar pattern, I was considering just creating a higher-level function. Lemme make that change and share what it would look like and then we can decide which way we wanna go.

lld/cmake/modules/LLDConfig.cmake.in

13

I used the lowercase for consistency with the existing @llvm_config_include_buildtree_only_exports@ in the LLVM files, but I'm happy to change it.

[smeenai]

Rebase (comments not addressed yet; uploading a pure rebase for easier version comparison)

[smeenai]

Helper function to get install arg. TODO: Address other review comments

[smeenai]

Uppercase variable names

[smeenai]

llvm/cmake/modules/LLVMDistributionSupport.cmake

39

Thinking about this more, I prefer DEFAULT because it's marking the default (unnamed) distribution (and <DEFAULT> is just to make it stand out more and be less likely to clash with a user-specified distribution name). I can change it if you feel strongly though.

[smeenai]

Add release notes

clang/cmake/caches/MultiDistributionExample.cmake

+# This file sets up a CMakeCache for a simple build with multiple distributions.
+# Note that for a real distribution, you likely want to perform a boostrap
+# build; see clang/cmake/caches/DistributionExample.cmake and the
+# BuildingADistribution documentation for details. This cache file doesn't
+# demonstrate bootstrapping so it can focus on the configuration details
+# specific to multiple distributions instead.
+
+# Build an optimized toolchain for an example set of targets.
+set(CMAKE_BUILD_TYPE Release CACHE STRING "")
+set(LLVM_TARGETS_TO_BUILD
+      AArch64
+      ARM
+      X86
+    CACHE STRING "")
+
+# Enable the LLVM projects and runtimes.
+set(LLVM_ENABLE_PROJECTS
+      clang
+      lld
+    CACHE STRING "")
+set(LLVM_ENABLE_RUNTIMES
+      compiler-rt
+      libcxx
+      libcxxabi
+    CACHE STRING "")
+
+# We'll build two distributions: Toolchain, which just holds the tools
+# (intended for most end users), and Development, which has libraries (for end
+# users who wish to develop their own tooling using those libraries). This will
+# produce the install-toolchain-distribution and install-development-distribution
+# targets to install the distributions.
+set(LLVM_DISTRIBUTIONS
+      Toolchain
+      Development
+    CACHE STRING "")
+
+# We want to include the C++ headers in our distribution.
+set(LLVM_RUNTIME_DISTRIBUTION_COMPONENTS
+      cxx-headers
+    CACHE STRING "")
+
+# You likely want more tools; this is just an example :) Note that we need to
+# include cxx-headers explicitly here (in addition to it being added to
+# LLVM_RUNTIME_DISTRIBUTION_COMPONENTS above).
+set(LLVM_Toolchain_DISTRIBUTION_COMPONENTS
+      builtins
+      clang
+      clang-resource-headers
+      cxx-headers
+      lld
+      llvm-objdump
+    CACHE STRING "")
+
+# Note that we need to include the CMake exports targets for the distribution
+# (development-cmake-exports and clang-development-cmake-exports), as well as
+# the general CMake exports target for each project (cmake-exports and
+# clang-cmake-exports), in our list of targets. The distribution CMake exports
+# targets just install the CMake exports file for the distribution's targets,
+# whereas the project CMake exports targets install the rest of the project's
+# CMake exports (which are needed in order to import the project from other
+# CMake_projects via find_package, and include the distribution's CMake exports
+# file to get the exported targets).
+set(LLVM_Development_DISTRIBUTION_COMPONENTS
+      # LLVM
+      cmake-exports
+      development-cmake-exports
+      llvm-headers
+      llvm-libraries
+      # Clang
+      clang-cmake-exports
+      clang-development-cmake-exports
+      clang-headers
+      clang-libraries
+    CACHE STRING "")

clang/cmake/modules/AddClang.cmake

+include(LLVMDistributionSupport)
+
 function(clang_tablegen)
   # Syntax:
   # clang_tablegen output-file [tablegen-arg ...] SOURCE source-file
   # [[TARGET cmake-target-name] [DEPENDS extra-dependency ...]]
   #
   # Generates a custom command for invoking tblgen as
   #
   # tblgen source-file -o=output-file tablegen-arg ...
macro(add_clang_library name)
   endif()
 
   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)
         set(export_to_clangtargets)
-        if(${lib} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-            "clang-libraries" IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-            NOT LLVM_DISTRIBUTION_COMPONENTS)
-          set(export_to_clangtargets EXPORT ClangTargets)
-          set_property(GLOBAL PROPERTY CLANG_HAS_EXPORTS True)
+        get_llvm_distribution(${name} in_distribution distribution UMBRELLA clang-libraries)
+        if(in_distribution)
+          set(export_to_clangtargets EXPORT Clang${distribution}Targets)
+          set_property(GLOBAL PROPERTY CLANG${distribution}_HAS_EXPORTS True)
         endif()
 
         install(TARGETS ${lib}
           COMPONENT ${lib}
           ${export_to_clangtargets}
           LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
           ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
           RUNTIME DESTINATION bin)
if (NOT CLANG_BUILD_TOOLS)
     set(EXCLUDE_FROM_ALL ON)
   endif()
 
   add_clang_executable(${name} ${ARGN})
   add_dependencies(${name} clang-resource-headers)
 
   if (CLANG_BUILD_TOOLS)
     set(export_to_clangtargets)
-    if(${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-        NOT LLVM_DISTRIBUTION_COMPONENTS)
-      set(export_to_clangtargets EXPORT ClangTargets)
-      set_property(GLOBAL PROPERTY CLANG_HAS_EXPORTS True)
+    get_llvm_distribution(${name} in_distribution distribution)
+    if(in_distribution)
+      set(export_to_clangtargets EXPORT Clang${distribution}Targets)
+      set_property(GLOBAL PROPERTY CLANG${distribution}_HAS_EXPORTS True)
     endif()
 
     install(TARGETS ${name}
       ${export_to_clangtargets}
       RUNTIME DESTINATION bin
       COMPONENT ${name})
 
     if(NOT LLVM_ENABLE_IDE)

clang/cmake/modules/CMakeLists.txt

+include(LLVMDistributionSupport)
+
 # Generate a list of CMake library targets so that other CMake projects can
 # link against them. LLVM calls its version of this file LLVMExports.cmake, but
 # the usual CMake convention seems to be ${Project}Targets.cmake.
 set(CLANG_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/clang)
 set(clang_cmake_builddir "${CMAKE_BINARY_DIR}/${CLANG_INSTALL_PACKAGE_DIR}")
 
 # Keep this in sync with llvm/cmake/CMakeLists.txt!
 set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
 set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")
 
 get_property(CLANG_EXPORTS GLOBAL PROPERTY CLANG_EXPORTS)
 export(TARGETS ${CLANG_EXPORTS} FILE ${clang_cmake_builddir}/ClangTargets.cmake)
 
 # Generate ClangConfig.cmake for the build tree.
 set(CLANG_CONFIG_CMAKE_DIR "${clang_cmake_builddir}")
 set(CLANG_CONFIG_LLVM_CMAKE_DIR "${llvm_cmake_builddir}")
-set(CLANG_CONFIG_EXPORTS_FILE "${clang_cmake_builddir}/ClangTargets.cmake")
+set(clang_config_include_exports "include(\"${clang_cmake_builddir}/ClangTargets.cmake\")")
 set(CLANG_CONFIG_INCLUDE_DIRS
   "${CLANG_SOURCE_DIR}/include"
   "${CLANG_BINARY_DIR}/include"
   )
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/ClangConfig.cmake.in
   ${clang_cmake_builddir}/ClangConfig.cmake
   @ONLY)
 set(CLANG_CONFIG_CMAKE_DIR)
 set(CLANG_CONFIG_LLVM_CMAKE_DIR)
-set(CLANG_CONFIG_EXPORTS_FILE)
 
 # Generate ClangConfig.cmake for the install tree.
 set(CLANG_CONFIG_CODE "
 # Compute the installation prefix from this LLVMConfig.cmake file location.
 get_filename_component(CLANG_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 "${CLANG_INSTALL_PACKAGE_DIR}")
 foreach(p ${_count})
   set(CLANG_CONFIG_CODE "${CLANG_CONFIG_CODE}
 get_filename_component(CLANG_INSTALL_PREFIX \"\${CLANG_INSTALL_PREFIX}\" PATH)")
 endforeach(p)
 set(CLANG_CONFIG_CMAKE_DIR "\${CLANG_INSTALL_PREFIX}/${CLANG_INSTALL_PACKAGE_DIR}")
 set(CLANG_CONFIG_LLVM_CMAKE_DIR "\${CLANG_INSTALL_PREFIX}/${LLVM_INSTALL_PACKAGE_DIR}")
-set(CLANG_CONFIG_EXPORTS_FILE "\${CLANG_CMAKE_DIR}/ClangTargets.cmake")
+get_config_exports_includes(Clang clang_config_include_exports)
 set(CLANG_CONFIG_INCLUDE_DIRS
   "\${CLANG_INSTALL_PREFIX}/include"
   )
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/ClangConfig.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/ClangConfig.cmake
   @ONLY)
 set(CLANG_CONFIG_CODE)
 set(CLANG_CONFIG_CMAKE_DIR)
-set(CLANG_CONFIG_EXPORTS_FILE)
 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
-  get_property(clang_has_exports GLOBAL PROPERTY CLANG_HAS_EXPORTS)
-  if(clang_has_exports)
-    install(EXPORT ClangTargets DESTINATION ${CLANG_INSTALL_PACKAGE_DIR}
-            COMPONENT clang-cmake-exports)
-  endif()
+  install_distribution_exports(Clang)
 
   install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/ClangConfig.cmake
     DESTINATION ${CLANG_INSTALL_PACKAGE_DIR}
     COMPONENT clang-cmake-exports)
 
   if(NOT LLVM_ENABLE_IDE)
     # Add a dummy target so this can be used with LLVM_DISTRIBUTION_COMPONENTS
     add_custom_target(clang-cmake-exports)
     add_llvm_install_targets(install-clang-cmake-exports
                              COMPONENT clang-cmake-exports)
   endif()
 endif()

clang/cmake/modules/ClangConfig.cmake.in

 # This file allows users to call find_package(Clang) and pick up our targets.
 
 @CLANG_CONFIG_CODE@
 
 find_package(LLVM REQUIRED CONFIG
              HINTS "@CLANG_CONFIG_LLVM_CMAKE_DIR@")
 
 set(CLANG_EXPORTED_TARGETS "@CLANG_EXPORTS@")
 set(CLANG_CMAKE_DIR "@CLANG_CONFIG_CMAKE_DIR@")
 set(CLANG_INCLUDE_DIRS "@CLANG_CONFIG_INCLUDE_DIRS@")
 set(CLANG_LINK_CLANG_DYLIB "@CLANG_LINK_CLANG_DYLIB@")
 
 # Provide all our library targets to users.
-include("@CLANG_CONFIG_EXPORTS_FILE@")
+@clang_config_include_exports@
 
 # By creating clang-tablegen-targets here, subprojects that depend on Clang's
 # tablegen-generated headers can always depend on this target whether building
 # in-tree with Clang or not.
 if(NOT TARGET clang-tablegen-targets)
   add_custom_target(clang-tablegen-targets)
 endif()

flang/cmake/modules/AddFlang.cmake

+include(LLVMDistributionSupport)
+
 macro(set_flang_windows_version_resource_properties name)
   if (DEFINED windows_resource_file)
     set_windows_version_resource_properties(${name} ${windows_resource_file}
       VERSION_MAJOR ${FLANG_VERSION_MAJOR}
       VERSION_MINOR ${FLANG_VERSION_MINOR}
       VERSION_PATCHLEVEL ${FLANG_VERSION_PATCHLEVEL}
       VERSION_STRING "${FLANG_VERSION} (${BACKEND_PACKAGE_STRING})"
       PRODUCT_NAME "flang")
macro(add_flang_library name)
 
   llvm_add_library(${name} ${LIBTYPE} ${ARG_UNPARSED_ARGUMENTS} ${srcs})
 
   if (TARGET ${name})
     target_link_libraries(${name} INTERFACE ${LLVM_COMMON_LIBS})
 
     if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "libflang")
       set(export_to_flangtargets)
-      if (${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-          "flang-libraries" IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-          NOT LLVM_DISTRIBUTION_COMPONENTS)
-        set(export_to_flangtargets EXPORT FlangTargets)
-        set_property(GLOBAL PROPERTY FLANG_HAS_EXPORTS True)
+      get_llvm_distribution(${name} in_distribution distribution UMBRELLA flang-libraries)
+      if (in_distribution)
+        set(export_to_flangtargets EXPORT Flang${distribution}Targets)
+        set_property(GLOBAL PROPERTY FLANG${distribution}_HAS_EXPORTS True)
       endif()
 
       install(TARGETS ${name}
         COMPONENT ${name}
         ${export_to_flangtargets}
         LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
         ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
         RUNTIME DESTINATION bin)
macro(add_flang_tool name)
   if (NOT FLANG_BUILD_TOOLS)
     set(EXCLUDE_FROM_ALL ON)
   endif()
 
   add_flang_executable(${name} ${ARGN})
 
   if (FLANG_BUILD_TOOLS)
     set(export_to_flangtargets)
-    if (${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-        NOT LLVM_DISTRIBUTION_COMPONENTS)
-      set(export_to_flangtargets EXPORT FlangTargets)
-      set_property(GLOBAL PROPERTY FLANG_HAS_EXPORTS True)
+    get_llvm_distribution(${name} in_distribution distribution)
+    if (in_distribution)
+      set(export_to_flangtargets EXPORT Flang${distribution}Targets)
+      set_property(GLOBAL PROPERTY FLANG${distribution}_HAS_EXPORTS True)
     endif()
 
     install(TARGETS ${name}
       ${export_to_flangtargets}
       RUNTIME DESTINATION bin
       COMPONENT ${name})
 
     if(NOT LLVM_ENABLE_IDE)

flang/cmake/modules/CMakeLists.txt

 # Generate a list of CMake library targets so that other CMake projects can
 # link against them. LLVM calls its version of this file LLVMExports.cmake, but
 # the usual CMake convention seems to be ${Project}Targets.cmake.
 set(FLANG_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/flang)
 set(flang_cmake_builddir "${CMAKE_BINARY_DIR}/${FLANG_INSTALL_PACKAGE_DIR}")
 
 # Keep this in sync with llvm/cmake/CMakeLists.txt!
 set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
 set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")
 
 get_property(FLANG_EXPORTS GLOBAL PROPERTY FLANG_EXPORTS)
 export(TARGETS ${FLANG_EXPORTS} FILE ${flang_cmake_builddir}/FlangTargets.cmake)
 
 # Generate FlangConfig.cmake for the build tree.
 set(FLANG_CONFIG_CMAKE_DIR "${flang_cmake_builddir}")
 set(FLANG_CONFIG_LLVM_CMAKE_DIR "${llvm_cmake_builddir}")
-set(FLANG_CONFIG_EXPORTS_FILE "${flang_cmake_builddir}/FlangTargets.cmake")
+set(flang_config_include_exports "include(\"${flang_cmake_builddir}/FlangTargets.cmake\")")
 set(FLANG_CONFIG_INCLUDE_DIRS
   "${FLANG_SOURCE_DIR}/include"
   "${FLANG_BINARY_DIR}/include"
   )
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/FlangConfig.cmake.in
   ${flang_cmake_builddir}/FlangConfig.cmake
   @ONLY)
 set(FLANG_CONFIG_CMAKE_DIR)
 set(FLANG_CONFIG_LLVM_CMAKE_DIR)
-set(FLANG_CONFIG_EXPORTS_FILE)
 
 # Generate FlangConfig.cmake for the install tree.
 set(FLANG_CONFIG_CODE "
   # Compute the installation prefix from this LLVMConfig.cmake file location.
   get_filename_component(FLANG_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 "${FLANG_INSTALL_PACKAGE_DIR}")
 foreach(p ${_count})
   set(FLANG_CONFIG_CODE "${FLANG_CONFIG_CODE}
       get_filename_component(FLANG_INSTALL_PREFIX \"\${FLANG_INSTALL_PREFIX}\" PATH)")
 endforeach(p)
 
 set(FLANG_CONFIG_CMAKE_DIR "\${FLANG_INSTALL_PREFIX}/${FLANG_INSTALL_PACKAGE_DIR}")
 set(FLANG_CONFIG_LLVM_CMAKE_DIR "\${FLANG_INSTALL_PREFIX}/${LLVM_INSTALL_PACKAGE_DIR}")
-set(FLANG_CONFIG_EXPORTS_FILE "\${FLANG_CMAKE_DIR}/FlangTargets.cmake")
+get_config_exports_includes(Flang flang_config_include_exports)
 set(FLANG_CONFIG_INCLUDE_DIRS "\${FLANG_INSTALL_PREFIX}/include")
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/FlangConfig.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/FlangConfig.cmake
   @ONLY)
 
 set(FLANG_CONFIG_CODE)
 set(FLANG_CONFIG_CMAKE_DIR)
 set(FLANG_CONFIG_EXPORTS_FILE)
 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
-  get_property(flang_has_exports GLOBAL PROPERTY FLANG_HAS_EXPORTS)
-  if(flang_has_exports)
-    install(EXPORT FlangTargets DESTINATION ${FLANG_INSTALL_PACKAGE_DIR}
-            COMPONENT flang-cmake-exports)
-  endif()
+  install_distribution_exports(Flang)
 
   install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/FlangConfig.cmake
     DESTINATION ${FLANG_INSTALL_PACKAGE_DIR}
     COMPONENT flang-cmake-exports)
 
   if(NOT LLVM_ENABLE_IDE)
     # Add a dummy target so this can be used with LLVM_DISTRIBUTION_COMPONENTS
     add_custom_target(flang-cmake-exports)
     add_llvm_install_targets(install-flang-cmake-exports
                              COMPONENT flang-cmake-exports)
   endif()
 endif()

flang/cmake/modules/FlangConfig.cmake.in

 # This file allows users to call find_package(Flang) and pick up our targets.
 
 @FLANG_CONFIG_CODE@
 
 find_package(LLVM REQUIRED CONFIG
              HINTS "@FLANG_CONFIG_LLVM_CMAKE_DIR@")
 
 set(FLANG_EXPORTED_TARGETS "@FLANG_EXPORTS@")
 set(FLANG_CMAKE_DIR "FLANG_CONFIG_CMAKE_DIR@")
 set(FLANG_INCLUDE_DIRS "@FLANG_CONFIG_INCLUDE_DIRS@")
 
 # Provide all our library targets to users.
-include("@FLANG_CONFIG_EXPORTS_FILE@")
+@flang_config_include_exports@

lld/cmake/modules/AddLLD.cmake

+include(LLVMDistributionSupport)
+
 macro(add_lld_library name)
   cmake_parse_arguments(ARG
     "SHARED"
     ""
     ""
     ${ARGN})
   if(ARG_SHARED)
     set(ARG_ENABLE_SHARED SHARED)
   endif()
   llvm_add_library(${name} ${ARG_ENABLE_SHARED} ${ARG_UNPARSED_ARGUMENTS})
   set_target_properties(${name} PROPERTIES FOLDER "lld libraries")
 
   if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
-    if(${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-        NOT LLVM_DISTRIBUTION_COMPONENTS)
-      set(export_to_lldtargets EXPORT LLDTargets)
-      set_property(GLOBAL PROPERTY LLD_HAS_EXPORTS True)
+    get_llvm_distribution(${name} in_distribution distribution)
+    if(in_distribution)
+      set(export_to_lldtargets EXPORT LLD${distribution}Targets)
+      set_property(GLOBAL PROPERTY LLD${distribution}_HAS_EXPORTS True)
     endif()
 
     install(TARGETS ${name}
       COMPONENT ${name}
       ${export_to_lldtargets}
       LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
       ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
       RUNTIME DESTINATION bin)

 macro(add_lld_tool name)
   if (NOT LLD_BUILD_TOOLS)
     set(EXCLUDE_FROM_ALL ON)
   endif()
 
   add_lld_executable(${name} ${ARGN})
 
   if (LLD_BUILD_TOOLS)
-    if(${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-        NOT LLVM_DISTRIBUTION_COMPONENTS)
-      set(export_to_lldtargets EXPORT LLDTargets)
-      set_property(GLOBAL PROPERTY LLD_HAS_EXPORTS True)
+    get_llvm_distribution(${name} in_distribution distribution)
+    if(in_distribution)
+      set(export_to_lldtargets EXPORT LLD${distribution}Targets)
+      set_property(GLOBAL PROPERTY LLD${distribution}_HAS_EXPORTS True)
     endif()
 
     install(TARGETS ${name}
       ${export_to_lldtargets}
       RUNTIME DESTINATION bin
       COMPONENT ${name})
 
     if(NOT CMAKE_CONFIGURATION_TYPES)

lld/cmake/modules/CMakeLists.txt

 # Generate a list of CMake library targets so that other CMake projects can
 # link against them. LLVM calls its version of this file LLVMExports.cmake, but
 # the usual CMake convention seems to be ${Project}Targets.cmake.
 set(LLD_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/lld)
 set(lld_cmake_builddir "${CMAKE_BINARY_DIR}/${LLD_INSTALL_PACKAGE_DIR}")
 
 # Keep this in sync with llvm/cmake/CMakeLists.txt!
 set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
 set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")
 
 get_property(LLD_EXPORTS GLOBAL PROPERTY LLD_EXPORTS)
 export(TARGETS ${LLD_EXPORTS} FILE ${lld_cmake_builddir}/LLDTargets.cmake)
 
 # Generate LLDConfig.cmake for the build tree.
 set(LLD_CONFIG_CMAKE_DIR "${lld_cmake_builddir}")
 set(LLD_CONFIG_LLVM_CMAKE_DIR "${llvm_cmake_builddir}")
-set(LLD_CONFIG_EXPORTS_FILE "${lld_cmake_builddir}/LLDTargets.cmake")
+set(lld_config_include_exports "include(\"${lld_cmake_builddir}/LLDTargets.cmake\")")
 set(LLD_CONFIG_INCLUDE_DIRS
   "${LLD_SOURCE_DIR}/include"
   "${LLD_BINARY_DIR}/include"
   )
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/LLDConfig.cmake.in
   ${lld_cmake_builddir}/LLDConfig.cmake
   @ONLY)
 set(LLD_CONFIG_CMAKE_DIR)
 set(LLD_CONFIG_LLVM_CMAKE_DIR)
-set(LLD_CONFIG_EXPORTS_FILE)
 
 # Generate LLDConfig.cmake for the install tree.
 set(LLD_CONFIG_CODE "
 # Compute the installation prefix from this LLVMConfig.cmake file location.
 get_filename_component(LLD_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 "${LLD_INSTALL_PACKAGE_DIR}")
 foreach(p ${_count})
   set(LLD_CONFIG_CODE "${LLD_CONFIG_CODE}
 get_filename_component(LLD_INSTALL_PREFIX \"\${LLD_INSTALL_PREFIX}\" PATH)")
 endforeach(p)
 set(LLD_CONFIG_CMAKE_DIR "\${LLD_INSTALL_PREFIX}/${LLD_INSTALL_PACKAGE_DIR}")
 set(LLD_CONFIG_LLVM_CMAKE_DIR "\${LLD_INSTALL_PREFIX}/${LLVM_INSTALL_PACKAGE_DIR}")
-set(LLD_CONFIG_EXPORTS_FILE "\${LLD_CMAKE_DIR}/LLDTargets.cmake")
+get_config_exports_includes(LLD lld_config_include_exports)
 set(LLD_CONFIG_INCLUDE_DIRS "\${LLD_INSTALL_PREFIX}/include")
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/LLDConfig.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/LLDConfig.cmake
   @ONLY)
 set(LLD_CONFIG_CODE)
 set(LLD_CONFIG_CMAKE_DIR)
-set(LLD_CONFIG_EXPORTS_FILE)
 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
-  get_property(lld_has_exports GLOBAL PROPERTY LLD_HAS_EXPORTS)
-  if(lld_has_exports)
-    install(EXPORT LLDTargets DESTINATION ${LLD_INSTALL_PACKAGE_DIR}
-            COMPONENT lld-cmake-exports)
-  endif()
+  install_distribution_exports(LLD)
 
   install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/LLDConfig.cmake
     DESTINATION ${LLD_INSTALL_PACKAGE_DIR}
     COMPONENT lld-cmake-exports)
 
   if(NOT LLVM_ENABLE_IDE)
     # Add a dummy target so this can be used with LLVM_DISTRIBUTION_COMPONENTS
     add_custom_target(lld-cmake-exports)
     add_llvm_install_targets(install-lld-cmake-exports
                              COMPONENT lld-cmake-exports)
   endif()
 endif()

lld/cmake/modules/LLDConfig.cmake.in

 # This file allows users to call find_package(LLD) and pick up our targets.
 
 @LLD_CONFIG_CODE@
 
 find_package(LLVM REQUIRED CONFIG
              HINTS "@LLD_CONFIG_LLVM_CMAKE_DIR@")
 
 set(LLD_EXPORTED_TARGETS "@LLD_EXPORTS@")
 set(LLD_CMAKE_DIR "@LLD_CONFIG_CMAKE_DIR@")
 set(LLD_INCLUDE_DIRS "@LLD_CONFIG_INCLUDE_DIRS@")
 
 # Provide all our library targets to users.
-include("@LLD_CONFIG_EXPORTS_FILE@")
+@lld_config_include_exports@

llvm/cmake/modules/AddLLVM.cmake

+include(LLVMDistributionSupport)
 include(LLVMProcessSources)
 include(LLVM-Config)
 include(DetermineGCCCompatible)
 
 function(llvm_update_compile_flags name)
   get_property(sources TARGET ${name} PROPERTY SOURCES)
   if("${sources}" MATCHES "\\.c(;|$)")
     set(update_src_props ON)
if (ARG_MODULE AND NOT TARGET ${name})
     # Add empty "phony" target
     add_custom_target(${name})
   elseif( EXCLUDE_FROM_ALL )
     set_target_properties( ${name} PROPERTIES EXCLUDE_FROM_ALL ON)
   elseif(ARG_BUILDTREE_ONLY)
     set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS_BUILDTREE_ONLY ${name})
   else()
     if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ARG_INSTALL_WITH_TOOLCHAIN)
-
       set(export_to_llvmexports)
-      if(${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-          (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)
+      if(in_llvm_libs)
+        set(umbrella UMBRELLA llvm-libraries)
+      else()
+        set(umbrella)
+      endif()
+      get_llvm_distribution(${name} in_distribution distribution ${umbrella})
+      if(in_distribution)
+        set(export_to_llvmexports EXPORT LLVM${distribution}Exports)
+        set_property(GLOBAL PROPERTY LLVM${distribution}_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}
               RUNTIME DESTINATION bin COMPONENT ${name})
 
macro(add_llvm_tool name)
   if( NOT LLVM_BUILD_TOOLS )
     set(EXCLUDE_FROM_ALL ON)
   endif()
   add_llvm_executable(${name} ${ARGN})
 
   if ( ${name} IN_LIST LLVM_TOOLCHAIN_TOOLS OR NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
     if( LLVM_BUILD_TOOLS )
       set(export_to_llvmexports)
-      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)
+      get_llvm_distribution(${name} in_distribution distribution)
+      if(in_distribution)
+        set(export_to_llvmexports EXPORT LLVM${distribution}Exports)
+        set_property(GLOBAL PROPERTY LLVM${distribution}_HAS_EXPORTS True)
       endif()
 
       install(TARGETS ${name}
               ${export_to_llvmexports}
               RUNTIME DESTINATION ${LLVM_TOOLS_INSTALL_DIR}
               COMPONENT ${name})
 
       if (NOT LLVM_ENABLE_IDE)
if ( NOT LLVM_BUILD_UTILS )
     set(EXCLUDE_FROM_ALL ON)
   endif()
 
   add_llvm_executable(${name} DISABLE_LLVM_LINK_LLVM_DYLIB ${ARGN})
   set_target_properties(${name} PROPERTIES FOLDER "Utils")
   if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
     if (LLVM_INSTALL_UTILS AND LLVM_BUILD_UTILS)
       set(export_to_llvmexports)
-      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)
+      get_llvm_distribution(${name} in_distribution distribution)
+      if (in_distribution)
+        set(export_to_llvmexports EXPORT LLVM${distribution}Exports)
+        set_property(GLOBAL PROPERTY LLVM${distribution}_HAS_EXPORTS True)
       endif()
 
       install(TARGETS ${name}
               ${export_to_llvmexports}
               RUNTIME DESTINATION ${LLVM_UTILS_INSTALL_DIR}
               COMPONENT ${name})
 
       if (NOT LLVM_ENABLE_IDE)

llvm/cmake/modules/CMakeLists.txt

+include(LLVMDistributionSupport)
+
 set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/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})
 

 endif()
 
 # We need to use the full path to the LLVM Exports file to make sure we get the
 # one from the build tree. This is due to our cmake files being split between
 # this source dir and the binary dir in the build tree configuration and the
 # LLVM_CONFIG_CMAKE_DIR being the source directory. In contrast in the install
 # tree, both the generated LLVMExports.cmake file and the rest of the cmake
 # source files are put in the same cmake directory.
-set(LLVM_CONFIG_EXPORTS_FILE "${LLVM_EXPORTS_FILE}")
 set(LLVM_CONFIG_EXPORTS "${LLVM_EXPORTS};${LLVM_EXPORTS_BUILDTREE_ONLY}")
+set(llvm_config_include_exports "include(\"${LLVM_EXPORTS_FILE}\")")
 set(llvm_config_include_buildtree_only_exports
 "include(\"${LLVM_BUILDTREEONLY_EXPORTS_FILE}\")")
 configure_file(
   LLVMConfig.cmake.in
   ${llvm_cmake_builddir}/LLVMConfig.cmake
   @ONLY)
 set(llvm_config_include_buildtree_only_exports)
 

 set(LLVM_CONFIG_BINARY_DIR "\${LLVM_INSTALL_PREFIX}")
 set(LLVM_CONFIG_TOOLS_BINARY_DIR "\${LLVM_INSTALL_PREFIX}/bin")
 
 # 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")
+get_config_exports_includes(LLVM llvm_config_include_exports)
 set(LLVM_CONFIG_EXPORTS "${LLVM_EXPORTS}")
 configure_file(
   LLVMConfig.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/LLVMConfig.cmake
   @ONLY)
 
 # Generate LLVMConfigVersion.cmake for build and install tree.
 configure_file(
   LLVMConfigVersion.cmake.in
   ${llvm_cmake_builddir}/LLVMConfigVersion.cmake
   @ONLY)
 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
-  get_property(llvm_has_exports GLOBAL PROPERTY LLVM_HAS_EXPORTS)
-  if(llvm_has_exports)
-    install(EXPORT LLVMExports DESTINATION ${LLVM_INSTALL_PACKAGE_DIR}
-            COMPONENT cmake-exports)
-  endif()
+  install_distribution_exports(LLVM)
 
   install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/LLVMConfig.cmake
     ${llvm_cmake_builddir}/LLVMConfigVersion.cmake
     LLVM-Config.cmake
     DESTINATION ${LLVM_INSTALL_PACKAGE_DIR}
     COMPONENT cmake-exports)
 

llvm/cmake/modules/LLVMConfig.cmake.in

 set(LLVM_TOOLS_BINARY_DIR "@LLVM_CONFIG_TOOLS_BINARY_DIR@")
 set(LLVM_TOOLS_INSTALL_DIR "@LLVM_TOOLS_INSTALL_DIR@")
 set(LLVM_DEFAULT_EXTERNAL_LIT "@LLVM_CONFIG_DEFAULT_EXTERNAL_LIT@")
 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@)
 
 if(NOT TARGET LLVMSupport)
-  set(LLVM_EXPORTED_TARGETS "@LLVM_CONFIG_EXPORTS@")
-  include("@LLVM_CONFIG_EXPORTS_FILE@")
+  @llvm_config_include_exports@
   @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
 # building in-tree with LLVM or not.
 if(NOT TARGET intrinsics_gen)
   add_custom_target(intrinsics_gen)

llvm/cmake/modules/LLVMDistributionSupport.cmake

+# Utility functions for packaging an LLVM distribution. See the
+# BuildingADistribution documentation for more details.
 
-if(LLVM_DISTRIBUTION_COMPONENTS)
+# These functions assume a number of conventions that are common across all LLVM
+# subprojects:
+# - The generated CMake exports file for ${project} is called ${project}Targets
+#   (except for LLVM where it's called ${project}Exports for legacy reasons).
+# - The build target for the CMake exports is called ${project}-cmake-exports
+#   (except LLVM where it's just cmake-exports).
+# - The ${PROJECT}${distribution}_HAS_EXPORTS global property holds whether a
+#   project has any exports for a particular ${distribution} (where ${PROJECT}
+#   is the project name in uppercase).
+# - The ${PROJECT}_CMAKE_DIR variable is computed by ${project}Config.cmake to
+#   hold the path of the installed CMake modules directory.
+# - The ${PROJECT}_INSTALL_PACKAGE_DIR variable contains the install destination
+#   for the project's CMake modules.
+
+include_guard(GLOBAL)
+
+if(LLVM_DISTRIBUTION_COMPONENTS AND LLVM_DISTRIBUTIONS)
+  message(FATAL_ERROR "LLVM_DISTRIBUTION_COMPONENTS and LLVM_DISTRIBUTIONS cannot be specified together")
+endif()
+
+if(LLVM_DISTRIBUTION_COMPONENTS OR LLVM_DISTRIBUTIONS)
   if(LLVM_ENABLE_IDE)
     message(FATAL_ERROR "LLVM_DISTRIBUTION_COMPONENTS cannot be specified with multi-configuration generators (i.e. Xcode or Visual Studio)")
   endif()
 endif()
 
+# Build the map of targets to distributions that's used to look up the
+# distribution for a target later. The distribution for ${target} is stored in
+# the global property LLVM_DISTRIBUTION_FOR_${target}.
+function(llvm_distribution_build_target_map)
+  foreach(target ${LLVM_DISTRIBUTION_COMPONENTS})
+    # CMake doesn't easily distinguish between properties that are unset and
+    # properties that are empty (you have to do a second get_property call with
+    # the SET option, which is unergonomic), so just use a space to denote the
+    # default (unnamed) distribution.
+    set_property(GLOBAL PROPERTY LLVM_DISTRIBUTION_FOR_${target} " ")
+  endforeach()
+
+  foreach(distribution ${LLVM_DISTRIBUTIONS})
+    foreach(target ${LLVM_${distribution}_DISTRIBUTION_COMPONENTS})
+      # We don't allow a target to be in multiple distributions, because we
+      # wouldn't know which export set to place it in.
+      get_property(current_distribution GLOBAL PROPERTY LLVM_DISTRIBUTION_FOR_${target})
+      if(current_distribution AND NOT current_distribution STREQUAL distribution)
+        message(SEND_ERROR "Target ${target} cannot be in multiple distributions ${distribution} and ${current_distribution}")
+      endif()
+      set_property(GLOBAL PROPERTY LLVM_DISTRIBUTION_FOR_${target} ${distribution})
+    endforeach()
+  endforeach()
+endfunction()
+
+# The include guard ensures this will only be called once. The rest of this file
+# only defines other functions (i.e. it doesn't execute any more code directly).
+llvm_distribution_build_target_map()
+
+# Look up the distribution a particular target belongs to. By convention, the
+# project calling this should set the ${PROJECT}${distribution}_HAS_EXPORTS
+# global property to true if the target is in ${distribution} (${PROJECT} is the
+# project name in uppercase).
+# - target: The target to look up.
+# - in_distribution_var: The variable with this name is set in the caller's
+#   scope to indicate if the target is in any distribution. If no distributions
+#   have been configured, this will always be set to true.
+# - distribution_var: The variable with this name is set in the caller's scope
+#   to indicate the distribution name for the target. If the target belongs to
+#   the default (unnamed) distribution, or if no distributions have been
+#   configured, it's set to the empty string.
+# - UMBRELLA: The (optional) umbrella target that the target is a part of. For
+#   example, all LLVM libraries have the umbrella target llvm-libraries.
+function(get_llvm_distribution target in_distribution_var distribution_var)
+  if(NOT LLVM_DISTRIBUTION_COMPONENTS AND NOT LLVM_DISTRIBUTIONS)
+    set(${in_distribution_var} YES PARENT_SCOPE)
+    set(${distribution_var} "" PARENT_SCOPE)
+    return()
+  endif()
+
+  cmake_parse_arguments(ARG "" UMBRELLA "" ${ARGN})
+  get_property(distribution GLOBAL PROPERTY LLVM_DISTRIBUTION_FOR_${target})
+  if(ARG_UMBRELLA)
+    get_property(umbrella_distribution GLOBAL PROPERTY LLVM_DISTRIBUTION_FOR_${ARG_UMBRELLA})
+    if(distribution AND umbrella_distribution AND NOT distribution STREQUAL umbrella_distribution)
+      message(SEND_ERROR "Target ${target} has different distribution ${distribution} from its"
+                         " umbrella target ${ARG_UMBRELLA} distribution ${umbrella_distribution}")
+    elseif(NOT distribution)
+      set(distribution ${umbrella_distribution})
+    endif()
+  endif()
+  if(distribution)
+    set(${in_distribution_var} YES PARENT_SCOPE)
+    if(distribution STREQUAL " ")
+      set(distribution "")
+    endif()
+    set(${distribution_var} "${distribution}" PARENT_SCOPE)
+  else()
+    set(${in_distribution_var} NO PARENT_SCOPE)
+  endif()
+endfunction()
+
+# Produce a string of CMake include() commands to include the exported targets
+# files for all distributions. See the comment at the top of this file for
+# various assumptions made.
+# - project: The project to produce the commands for. IMPORTANT: The casing of
+#   this argument should match the casing used by the project's Config.cmake
+#   file. The correct casing for the LLVM projects is Clang, Flang, LLD, LLVM,
+#   and MLIR.
+# - includes_var: The variable with this name is set in the caller's scope to
+#   the string of include commands.
+function(get_config_exports_includes project includes_var)
+  string(TOUPPER "${project}" project_upper)
+  set(prefix "\${${project_upper}_CMAKE_DIR}/${project}")
+  if(project STREQUAL "LLVM")
+    set(suffix "Exports.cmake") # legacy
+  else()
+    set(suffix "Targets.cmake")
+  endif()
+
+  if(NOT LLVM_DISTRIBUTIONS)
+    set(${includes_var} "include(\"${prefix}${suffix}\")" PARENT_SCOPE)
+  else()
+    set(includes)
+    foreach(distribution ${LLVM_DISTRIBUTIONS})
+      list(APPEND includes "include(\"${prefix}${distribution}${suffix}\" OPTIONAL)")
+    endforeach()
+    string(REPLACE ";" "\n" includes "${includes}")
+    set(${includes_var} "${includes}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+# Create the install commands and targets for the distributions' CMake exports.
+# The target to install ${distribution} for a project is called
+# ${project}-${distribution}-cmake-exports, where ${project} is the project name
+# in lowercase and ${distribution} is the distribution name in lowercase, except
+# for LLVM, where the target is just called ${distribution}-cmake-exports. See
+# the comment at the top of this file for various assumptions made.
+# - project: The project. See the comment for get_config_exports_includes above
+#   for the correct casing of this argument.
+function(install_distribution_exports project)
+  string(TOUPPER "${project}" project_upper)
+  string(TOLOWER "${project}" project_lower)
+  if(project STREQUAL "LLVM")
+    set(prefix "")
+    set(suffix "Exports") # legacy
+  else()
+    set(prefix "${project_lower}-")
+    set(suffix "Targets")
+  endif()
+  set(destination "${${project_upper}_INSTALL_PACKAGE_DIR}")
+
+  if(NOT LLVM_DISTRIBUTIONS)
+    get_property(has_exports GLOBAL PROPERTY ${project_upper}_HAS_EXPORTS)
+    if(has_exports)
+      install(EXPORT ${project}${suffix} DESTINATION "${destination}"
+              COMPONENT ${prefix}cmake-exports)
+    endif()
+  else()
+    foreach(distribution ${LLVM_DISTRIBUTIONS})
+      get_property(has_exports GLOBAL PROPERTY ${project_upper}${distribution}_HAS_EXPORTS)
+      if(has_exports)
+        string(TOLOWER ${distribution} distribution_lower)
+        set(target ${prefix}${distribution_lower}-cmake-exports)
+        install(EXPORT ${project}${distribution}${suffix} DESTINATION "${destination}"
+                COMPONENT ${target})
+        if(NOT LLVM_ENABLE_IDE)
+          add_custom_target(${target})
+          add_llvm_install_targets(install-${target} COMPONENT ${target})
+        endif()
+      endif()
+    endforeach()
+  endif()
+endfunction()
+
+# Create the targets for installing the configured distributions. The
+# ${distribution} target builds the distribution, install-${distribution}
+# installs it, and install-${distribution}-stripped installs a stripped version,
+# where ${distribution} is the distribution name in lowercase, or "distribution"
+# for the default distribution.
 function(llvm_distribution_add_targets)
-  add_custom_target(distribution)
-  add_custom_target(install-distribution)
-  add_custom_target(install-distribution-stripped)
+  set(distributions "${LLVM_DISTRIBUTIONS}")
+  if(NOT distributions)
+    # CMake seemingly doesn't distinguish between an empty list and a list
+    # containing one element which is the empty string, so just use a space for
+    # the latter and fix it in the loop.
+    set(distributions " ")
+  endif()
 
-  foreach(target ${LLVM_DISTRIBUTION_COMPONENTS}
-      ${LLVM_RUNTIME_DISTRIBUTION_COMPONENTS})
+  foreach(distribution ${distributions})
+    if(distribution STREQUAL " ")
+      set(distribution_target distribution)
+      # Preserve legacy behavior for LLVM_DISTRIBUTION_COMPONENTS.
+      set(distribution_components ${LLVM_DISTRIBUTION_COMPONENTS} ${LLVM_RUNTIME_DISTRIBUTION_COMPONENTS})
+    else()
+      string(TOLOWER ${distribution} distribution_lower)
+      set(distribution_target ${distribution_lower}-distribution)
+      set(distribution_components ${LLVM_${distribution}_DISTRIBUTION_COMPONENTS})
+    endif()
+
+    add_custom_target(${distribution_target})
+    add_custom_target(install-${distribution_target})
+    add_custom_target(install-${distribution_target}-stripped)
+
+    foreach(target ${distribution_components})
       if(TARGET ${target})
-      add_dependencies(distribution ${target})
+        add_dependencies(${distribution_target} ${target})
       else()
         message(SEND_ERROR "Specified distribution component '${target}' doesn't have a target")
       endif()
 
       if(TARGET install-${target})
-      add_dependencies(install-distribution install-${target})
+        add_dependencies(install-${distribution_target} install-${target})
       else()
         message(SEND_ERROR "Specified distribution component '${target}' doesn't have an install target")
       endif()
 
       if(TARGET install-${target}-stripped)
-      add_dependencies(install-distribution-stripped install-${target}-stripped)
+        add_dependencies(install-${distribution_target}-stripped install-${target}-stripped)
       else()
         message(SEND_ERROR
                 "Specified distribution component '${target}' doesn't have an install-stripped target."
                 " Its installation target creation should be changed to use add_llvm_install_targets,"
                 " or you should manually create the 'install-${target}-stripped' target.")
       endif()
     endforeach()
+  endforeach()
 endfunction()

llvm/docs/BuildingADistribution.rst

 development and testing of LLVM, and should only be included in distributions
 that support LLVM development.
 
 When building with *LLVM_DISTRIBUTION_COMPONENTS* the build system also
 generates a ``distribution`` target which builds all the components specified in
 the list. This is a convenience build target to allow building just the
 distributed pieces without needing to build all configured targets.
 
+.. _Multi-distribution configurations:
+
+Multi-distribution configurations
+---------------------------------
+
+The ``install-distribution`` target described above is for building a single
+distribution. LLVM's build system also supports building multiple distributions,
+which can be used to e.g. have one distribution containing just tools and
+another for libraries (to enable development). These are configured by setting
+the *LLVM_DISTRIBUTIONS* variable to hold a list of all distribution names
+(which conventionally start with an uppercase letter, e.g. "Development"), and
+then setting the *LLVM_<distribution>_DISTRIBUTION_COMPONENTS* variable to the
+list of targets for that distribution. For each distribution, the build system
+generates an ``install-${distribution}-distribution`` target, where
+``${distribution}`` is the name of the distribution in lowercase, to install
+that distribution. Each target can only be in one distribution.
+
+Each distribution creates its own set of CMake exports, and the target to
+install the CMake exports for a particular distribution for a project is named
+``${project}-${distribution}-cmake-exports``, where ``${project}`` is the name
+of the project in lowercase and ``${distribution}`` is the name of the
+distribution in lowercase, unless the project is LLVM, in which case the target
+is just named ``${distribution}-cmake-exports``. These targets need to be
+explicitly included in the *LLVM_<distribution>_DISTRIBUTION_COMPONENTS*
+variable in order to be included as part of the distribution.
+
+Unlike with the single distribution setup, when building multiple distributions,
+any components specified in *LLVM_RUNTIME_DISTRIBUTION_COMPONENTS* are not
+automatically added to any distribution. Instead, you must include the targets
+explicitly in some *LLVM_<distribution>_DISTRIBUTION_COMPONENTS* list.
+
+We strongly encourage looking at ``clang/cmake/caches/MultiDistributionExample.cmake``
+as an example of configuring multiple distributions.
+
 Special Notes for Library-only Distributions
 --------------------------------------------
 
 One of the most powerful features of LLVM is its library-first design mentality
 and the way you can compose a wide variety of tools using different portions of
 LLVM. Even in this situation using *BUILD_SHARED_LIBS* is not supported. If you
 want to distribute LLVM as a shared library for use in a tool, the recommended
 method is using *LLVM_BUILD_LLVM_DYLIB*, and you can use *LLVM_DYLIB_COMPONENTS*
**LLVM_ENABLE_RUNTIMES**:STRING
   with the just-built compiler.
 
 **LLVM_DISTRIBUTION_COMPONENTS**:STRING
   This variable can be set to a semi-colon separated list of LLVM build system
   components to install. All LLVM-based tools are components, as well as most
   of the libraries and runtimes. Component names match the names of the build
   system targets.
 
+**LLVM_DISTRIBUTIONS**:STRING
+  This variable can be set to a semi-colon separated list of distributions. See
+  the :ref:`Multi-distribution configurations` section above for details on this
+  and other CMake variables to configure multiple distributions.
+
 **LLVM_RUNTIME_DISTRIBUTION_COMPONENTS**:STRING
   This variable can be set to a semi-colon separated list of runtime library
   components. This is used in conjunction with *LLVM_ENABLE_RUNTIMES* to specify
   components of runtime libraries that you want to include in your distribution.
   Just like with *LLVM_DISTRIBUTION_COMPONENTS*, component names match the names
   of the build system targets.
 
 **LLVM_DYLIB_COMPONENTS**:STRING

mlir/cmake/modules/AddMLIR.cmake

+include(LLVMDistributionSupport)
+
 function(mlir_tablegen ofn)
   tablegen(MLIR ${ARGV})
   set(TABLEGEN_OUTPUT ${TABLEGEN_OUTPUT} ${CMAKE_CURRENT_BINARY_DIR}/${ofn}
       PARENT_SCOPE)
 endfunction()
 
 # Declare a dialect in the include directory
 function(add_mlir_dialect dialect dialect_namespace)

 endfunction(add_mlir_library)
 
 # Adds an MLIR library target for installation.
 # 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)
   set(export_to_mlirtargets)
-  if (${name} IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-      "mlir-libraries" IN_LIST LLVM_DISTRIBUTION_COMPONENTS OR
-      NOT LLVM_DISTRIBUTION_COMPONENTS)
-      set(export_to_mlirtargets EXPORT MLIRTargets)
-    set_property(GLOBAL PROPERTY MLIR_HAS_EXPORTS True)
+  get_llvm_distribution(${name} in_distribution distribution UMBRELLA mlir-libraries)
+  if (in_distribution)
+      set(export_to_mlirtargets EXPORT MLIR${distribution}Targets)
+    set_property(GLOBAL PROPERTY MLIR${distribution}_HAS_EXPORTS True)
   endif()
 
   install(TARGETS ${name}
     COMPONENT ${name}
     ${export_to_mlirtargets}
     LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
     ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX}
     RUNTIME DESTINATION bin)

mlir/cmake/modules/CMakeLists.txt

+include(LLVMDistributionSupport)
+
 # Generate a list of CMake library targets so that other CMake projects can
 # link against them. LLVM calls its version of this file LLVMExports.cmake, but
 # the usual CMake convention seems to be ${Project}Targets.cmake.
 set(MLIR_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/mlir)
 set(mlir_cmake_builddir "${CMAKE_BINARY_DIR}/${MLIR_INSTALL_PACKAGE_DIR}")
 
 # Keep this in sync with llvm/cmake/CMakeLists.txt!
 set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm)
 set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}")
 
 get_property(MLIR_EXPORTS GLOBAL PROPERTY MLIR_EXPORTS)
 export(TARGETS ${MLIR_EXPORTS} FILE ${mlir_cmake_builddir}/MLIRTargets.cmake)
 
 get_property(MLIR_ALL_LIBS GLOBAL PROPERTY MLIR_ALL_LIBS)
 get_property(MLIR_DIALECT_LIBS GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(MLIR_CONVERSION_LIBS GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
 get_property(MLIR_TRANSLATION_LIBS GLOBAL PROPERTY MLIR_TRANSLATION_LIBS)
 
 # Generate MlirConfig.cmake for the build tree.
 set(MLIR_CONFIG_CMAKE_DIR "${mlir_cmake_builddir}")
 set(MLIR_CONFIG_LLVM_CMAKE_DIR "${llvm_cmake_builddir}")
-set(MLIR_CONFIG_EXPORTS_FILE "\${MLIR_CMAKE_DIR}/MLIRTargets.cmake")
+set(mlir_config_include_exports "include(\"\${MLIR_CMAKE_DIR}/MLIRTargets.cmake\")")
 set(MLIR_CONFIG_INCLUDE_DIRS
   "${MLIR_SOURCE_DIR}/include"
   "${MLIR_BINARY_DIR}/include"
   )
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/MLIRConfig.cmake.in
   ${mlir_cmake_builddir}/MLIRConfig.cmake
   @ONLY)
 set(MLIR_CONFIG_CMAKE_DIR)
 set(MLIR_CONFIG_LLVM_CMAKE_DIR)
-set(MLIR_CONFIG_EXPORTS_FILE)
 set(MLIR_CONFIG_INCLUDE_DIRS)
 
 # For compatibility with projects that include(MLIRConfig)
 # via CMAKE_MODULE_PATH, place API modules next to it.
 # This should be removed in the future.
 file(COPY .
   DESTINATION ${mlir_cmake_builddir}
   FILES_MATCHING PATTERN *.cmake
   PATTERN CMakeFiles EXCLUDE
   )
 
 # Generate MLIRConfig.cmake for the install tree.
 set(MLIR_CONFIG_CODE "
 # Compute the installation prefix from this MLIRConfig.cmake file location.
 get_filename_component(MLIR_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 "${MLIR_INSTALL_PACKAGE_DIR}")
 foreach(p ${_count})
   set(MLIR_CONFIG_CODE "${MLIR_CONFIG_CODE}
 get_filename_component(MLIR_INSTALL_PREFIX \"\${MLIR_INSTALL_PREFIX}\" PATH)")
 endforeach(p)
 set(MLIR_CONFIG_CMAKE_DIR "\${MLIR_INSTALL_PREFIX}/${MLIR_INSTALL_PACKAGE_DIR}")
 set(MLIR_CONFIG_LLVM_CMAKE_DIR "\${MLIR_INSTALL_PREFIX}/${LLVM_INSTALL_PACKAGE_DIR}")
-set(MLIR_CONFIG_EXPORTS_FILE "\${MLIR_CMAKE_DIR}/MLIRTargets.cmake")
+get_config_exports_includes(MLIR mlir_config_include_exports)
 set(MLIR_CONFIG_INCLUDE_DIRS
   "\${MLIR_INSTALL_PREFIX}/include"
   )
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/MLIRConfig.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/MLIRConfig.cmake
   @ONLY)
 set(MLIR_CONFIG_CODE)
 set(MLIR_CONFIG_CMAKE_DIR)
 set(MLIR_CONFIG_LLVM_CMAKE_DIR)
-set(MLIR_CONFIG_EXPORTS_FILE)
 set(MLIR_CONFIG_INCLUDE_DIRS)
 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   # Not TOOLCHAIN ONLY, so install the MLIR parts as well
   # Include the cmake files so other tools can use mlir-tblgen, etc.
-  get_property(mlir_has_exports GLOBAL PROPERTY MLIR_HAS_EXPORTS)
-  if(mlir_has_exports)
-    install(EXPORT MLIRTargets DESTINATION ${MLIR_INSTALL_PACKAGE_DIR}
-            COMPONENT mlir-cmake-exports)
-  endif()
+  install_distribution_exports(MLIR)
 
   install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/MLIRConfig.cmake
     ${CMAKE_CURRENT_SOURCE_DIR}/AddMLIR.cmake
     DESTINATION ${MLIR_INSTALL_PACKAGE_DIR}
     COMPONENT mlir-cmake-exports)
 
   if(NOT LLVM_ENABLE_IDE)
     # Add a dummy target so this can be used with LLVM_DISTRIBUTION_COMPONENTS
     add_custom_target(mlir-cmake-exports)
     add_llvm_install_targets(install-mlir-cmake-exports
                              COMPONENT mlir-cmake-exports)
   endif()
 endif()

mlir/cmake/modules/MLIRConfig.cmake.in

 set(MLIR_MAIN_SRC_DIR "@MLIR_MAIN_SRC_DIR@")
 
 set_property(GLOBAL PROPERTY MLIR_ALL_LIBS "@MLIR_ALL_LIBS@")
 set_property(GLOBAL PROPERTY MLIR_DIALECT_LIBS "@MLIR_DIALECT_LIBS@")
 set_property(GLOBAL PROPERTY MLIR_CONVERSION_LIBS "@MLIR_CONVERSION_LIBS@")
 set_property(GLOBAL PROPERTY MLIR_TRANSLATION_LIBS "@MLIR_TRANSLATION_LIBS@")
 
 # Provide all our library targets to users.
-include("@MLIR_CONFIG_EXPORTS_FILE@")
+@mlir_config_include_exports@
 
 # By creating these targets here, subprojects that depend on MLIR's
 # tablegen-generated headers can always depend on these targets whether building
 # in-tree with MLIR or not.
 if(NOT TARGET mlir-tablegen-targets)
   add_custom_target(mlir-tablegen-targets)
 endif()
 if(NOT TARGET mlir-headers)
   add_custom_target(mlir-headers)
 endif()
 if(NOT TARGET mlir-generic-headers)
   add_custom_target(mlir-generic-headers)
 endif()
 if(NOT TARGET mlir-doc)
   add_custom_target(mlir-doc)
 endif()