[CMake] Add <Project>ConfigVersion.cmake files

[alexreinking]

Summary

When supplying a package with <Project>Config.cmake files, it is required to also supply a <Project>ConfigVersion.cmake file which defines compatibility with version numbers. If these files aren't distributed then supplying a version number will fail. But on the other hand, not supplying a version number can result in the wrong package being selected. For example, because the base LLVM package does supply LLVMConfigVersion.cmake, the following can occur:

find_package(LLVM 11.0 REQUIRED)  # Succeeds
find_package(LLD 11.0)  # Fails because there's no version config
find_package(LLD)  # Succeeds, finds version 10.

This patch would not affect any existing uses of the CMake build/packages because the ConfigVersion.cmake file is ignored when no version is given and the status quo is that supplying a version fails.

This patch also fixes a bug I opened a year ago here: https://bugs.llvm.org/show_bug.cgi?id=45027

[alexreinking]

So with this patch, I tried to imitate the existing code as much as possible. However, I think it would be quite a bit better to use the write_basic_package_version_file command from CMakePackageConfigHelpers. It gained support for major + minor version compatibility matching in CMake 3.11. Since LLVM is on 3.13 now, I don't see a reason not to use this. Instead of the existing configure_file and *ConfigVersion.cmake.in combo, we would delete the template (.in) and just write:

include(CMakePackageConfigHelpers)
write_basic_package_version_file(
    ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/PollyConfigVersion.cmake
    VERSION ${POLLY_VERSION}
    COMPATIBILITY SameMinorVersion
)

If the subproject had proper calls to project(), like project(Polly VERSION ${POLLY_VERSION}), then write_basic_package_version_file would default its VERSION argument to ${PROJECT_VERSION}.

The template ConfigVersion.cmake.in files are also missing an architecture check, so it's possible that a 64-bit build of LLVM could get picked up by a project calling find_package while cross compiling to 32-bit. The ones generated by write_basic_package_version_file have this check.

[steveire]

lld/cmake/modules/LLDConfigVersion.cmake.in

1

Did you consider using write_basic_package_version_file instead of adding these files?

[steveire]

lld/cmake/modules/LLDConfigVersion.cmake.in

1

Ah, sorry, I see you did and wrote a comment about it.

[alexreinking]

Uses write_basic_package_version_file

[alexreinking]

Use PACKAGE_VERSION instead

[alexreinking]

Drop *ConfigVersion.cmake files from CMakeFiles tree

[alexreinking]

Remove unused version variables (that were used in a previous revision)

[alexreinking]

Update & wrap commit message

[steveire]

flang/cmake/modules/CMakeLists.txt

15

Instead of including this multiple times, please add it to AddLLVM.cmake. That file is used in project top-level builds too and it already contains other includes needed in the build. It is installed, but only for the purpose of building other parts of LLVM, so it's not a concern for third parties either (It is not included by LLVMConfig.cmake).

[alexreinking]

As requested, move instances of include(CMakePackageConfigHelpers) to AddLLVM.cmake.

[steveire]

LGTM, thanks!

I'll commit this on Wednesday if none of the other reviewers object by then.

clang/cmake/modules/CMakeLists.txt

 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)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/ClangConfigVersion.cmake.in
+  ${clang_cmake_builddir}/ClangConfigVersion.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)")

 set(CLANG_CONFIG_EXPORTS_FILE "\${CLANG_CMAKE_DIR}/ClangTargets.cmake")
 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)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/ClangConfigVersion.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/ClangConfigVersion.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(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/ClangConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/ClangConfigVersion.cmake
     ${CMAKE_CURRENT_SOURCE_DIR}/AddClang.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/ClangConfigVersion.cmake.in

+set(PACKAGE_VERSION "@PACKAGE_VERSION@")
+
+# Clang is API-compatible only with matching major.minor versions
+# and patch versions not less than that requested.
+if("@CLANG_VERSION_MAJOR@.@CLANG_VERSION_MINOR@" VERSION_EQUAL
+    "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}"
+   AND NOT "@CLANG_VERSION_PATCHLEVEL@" VERSION_LESS "${PACKAGE_FIND_VERSION_PATCH}")
+  set(PACKAGE_VERSION_COMPATIBLE 1)
+  if("@CLANG_VERSION_PATCHLEVEL@" VERSION_EQUAL
+      "${PACKAGE_FIND_VERSION_PATCH}")
+    set(PACKAGE_VERSION_EXACT 1)
+  endif()
+endif()

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_DIRS
   "${FLANG_SOURCE_DIR}/include"
   "${FLANG_BINARY_DIR}/include"
   )
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/FlangConfig.cmake.in
   ${flang_cmake_builddir}/FlangConfig.cmake
   @ONLY)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/FlangConfigVersion.cmake.in
+  ${flang_cmake_builddir}/FlangConfigVersion.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)")

 set(FLANG_CONFIG_EXPORTS_FILE "\${FLANG_CMAKE_DIR}/FlangTargets.cmake")
 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)
 
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/FlangConfigVersion.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/FlangConfigVersion.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(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/FlangConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/FlangConfigVersion.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/FlangConfigVersion.cmake.in

+set(PACKAGE_VERSION "@PACKAGE_VERSION@")
+
+# Flang is API-compatible only with matching major.minor versions
+# and patch versions not less than that requested.
+if("@FLANG_VERSION_MAJOR@.@FLANG_VERSION_MINOR@" VERSION_EQUAL
+    "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}"
+   AND NOT "@FLANG_VERSION_PATCHLEVEL@" VERSION_LESS "${PACKAGE_FIND_VERSION_PATCH}")
+  set(PACKAGE_VERSION_COMPATIBLE 1)
+  if("@FLANG_VERSION_PATCHLEVEL@" VERSION_EQUAL
+      "${PACKAGE_FIND_VERSION_PATCH}")
+    set(PACKAGE_VERSION_EXACT 1)
+  endif()
+endif()

lld/CMakeLists.txt

 set(LLD_VENDOR ${PACKAGE_VENDOR} CACHE STRING
   "Vendor-specific text for showing with version information.")
 
 if(LLD_VENDOR)
   add_definitions(-DLLD_VENDOR="${LLD_VENDOR}")
 endif()
 
 # Compute the LLD version from the LLVM version.
-string(REGEX MATCH "[0-9]+\\.[0-9]+(\\.[0-9]+)?" LLD_VERSION
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)(\\.([0-9]+))?" LLD_VERSION
   ${PACKAGE_VERSION})
 message(STATUS "LLD version: ${LLD_VERSION}")
 
-string(REGEX REPLACE "([0-9]+)\\.[0-9]+(\\.[0-9]+)?" "\\1" LLD_VERSION_MAJOR
-  ${LLD_VERSION})
-string(REGEX REPLACE "[0-9]+\\.([0-9]+)(\\.[0-9]+)?" "\\1" LLD_VERSION_MINOR
-  ${LLD_VERSION})
+set(LLD_VERSION_MAJOR "${CMAKE_MATCH_1}")
+set(LLD_VERSION_MINOR "${CMAKE_MATCH_2}")
+set(LLD_VERSION_PATCH "${CMAKE_MATCH_4}")  # Using 4 instead of 3 skips the dot before the patch number.
 
 # Configure the Version.inc file.
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/include/lld/Common/Version.inc.in
   ${CMAKE_CURRENT_BINARY_DIR}/include/lld/Common/Version.inc)
 
 
 if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)

lld/cmake/modules/CMakeLists.txt

 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)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/LLDConfigVersion.cmake.in
+  ${lld_cmake_builddir}/LLDConfigVersion.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")
 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)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/LLDConfigVersion.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/LLDConfigVersion.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(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/LLDConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/LLDConfigVersion.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/LLDConfigVersion.cmake.in

+set(PACKAGE_VERSION "@PACKAGE_VERSION@")
+
+# LLD is API-compatible only with matching major.minor versions
+# and patch versions not less than that requested.
+if("@LLD_VERSION_MAJOR@.@LLD_VERSION_MINOR@" VERSION_EQUAL
+    "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}"
+   AND NOT "@LLD_VERSION_PATCH@" VERSION_LESS "${PACKAGE_FIND_VERSION_PATCH}")
+  set(PACKAGE_VERSION_COMPATIBLE 1)
+  if("@LLD_VERSION_PATCH@" VERSION_EQUAL
+      "${PACKAGE_FIND_VERSION_PATCH}")
+    set(PACKAGE_VERSION_EXACT 1)
+  endif()
+endif()

mlir/CMakeLists.txt

if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   set(UNITTEST_DIR ${LLVM_MAIN_SRC_DIR}/utils/unittest)
   if(EXISTS ${UNITTEST_DIR}/googletest/include/gtest/gtest.h)
     add_subdirectory(${UNITTEST_DIR} utils/unittest)
   endif()
 
   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
     "${CMAKE_CURRENT_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}")
   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
+
+  set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
 endif()
 
 set(MLIR_MAIN_SRC_DIR     ${CMAKE_CURRENT_SOURCE_DIR}  )
 set(MLIR_MAIN_INCLUDE_DIR ${MLIR_MAIN_SRC_DIR}/include )
 
 set(MLIR_SOURCE_DIR  ${CMAKE_CURRENT_SOURCE_DIR})
 set(MLIR_BINARY_DIR  ${CMAKE_CURRENT_BINARY_DIR})
 set(MLIR_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/include)
 set(MLIR_TOOLS_DIR   ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 
+# Compute the MLIR version from the LLVM version.
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)(\\.([0-9]+))?" MLIR_VERSION ${PACKAGE_VERSION})
+message(STATUS "MLIR version: ${MLIR_VERSION}")
+
+set(MLIR_VERSION_MAJOR "${CMAKE_MATCH_1}")
+set(MLIR_VERSION_MINOR "${CMAKE_MATCH_2}")
+set(MLIR_VERSION_PATCH "${CMAKE_MATCH_4}")  # Using 4 instead of 3 skips the dot before the patch number.
+
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 
 include(AddMLIR)
 
 # Forbid implicit function declaration: this may lead to subtle bugs and we
 # don't have a reason to support this.
 check_c_compiler_flag("-Werror=implicit-function-declaration" C_SUPPORTS_WERROR_IMPLICIT_FUNCTION_DECLARATION)
 append_if(C_SUPPORTS_WERROR_IMPLICIT_FUNCTION_DECLARATION "-Werror=implicit-function-declaration" CMAKE_C_FLAGS)

mlir/cmake/modules/CMakeLists.txt

 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)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/MLIRConfigVersion.cmake.in
+  ${mlir_cmake_builddir}/MLIRConfigVersion.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.

 set(MLIR_CONFIG_EXPORTS_FILE "\${MLIR_CMAKE_DIR}/MLIRTargets.cmake")
 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)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/MLIRConfigVersion.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/MLIRConfigVersion.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(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/MLIRConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/MLIRConfigVersion.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/MLIRConfigVersion.cmake.in

+set(PACKAGE_VERSION "@PACKAGE_VERSION@")
+
+# MLIR is API-compatible only with matching major.minor versions
+# and patch versions not less than that requested.
+if("@MLIR_VERSION_MAJOR@.@MLIR_VERSION_MINOR@" VERSION_EQUAL
+    "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}"
+   AND NOT "@MLIR_VERSION_PATCH@" VERSION_LESS "${PACKAGE_FIND_VERSION_PATCH}")
+  set(PACKAGE_VERSION_COMPATIBLE 1)
+  if("@MLIR_VERSION_PATCH@" VERSION_EQUAL
+      "${PACKAGE_FIND_VERSION_PATCH}")
+    set(PACKAGE_VERSION_EXACT 1)
+  endif()
+endif()

polly/CMakeLists.txt

 # Check if this is a in tree build.
 if (NOT DEFINED LLVM_MAIN_SRC_DIR)
   project(Polly)
   cmake_minimum_required(VERSION 3.13.4)
 
   # Where is LLVM installed?
   find_package(LLVM CONFIG REQUIRED)
+  set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
   set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${LLVM_CMAKE_DIR})
   include(HandleLLVMOptions)
   include(AddLLVM)
 
   # Add the llvm header path.
   include_directories(${LLVM_INCLUDE_DIRS})
 
   # Sources available, too?

 else ()
   set(LLVM_SOURCE_ROOT "${LLVM_MAIN_SRC_DIR}")
   set(POLLY_GTEST_AVAIL 1)
 endif ()
 
 set(POLLY_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(POLLY_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
+# Compute the Polly version from the LLVM version.
+string(REGEX MATCH "([0-9]+)\\.([0-9]+)(\\.([0-9]+))?" POLLY_VERSION ${PACKAGE_VERSION})
+message(STATUS "Polly version: ${POLLY_VERSION}")
+
+set(POLLY_VERSION_MAJOR "${CMAKE_MATCH_1}")
+set(POLLY_VERSION_MINOR "${CMAKE_MATCH_2}")
+set(POLLY_VERSION_PATCH "${CMAKE_MATCH_4}")  # Using 4 instead of 3 skips the dot before the patch number.
+
 # Add path for custom modules
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
   )
 
 include("polly_macros")
 

polly/cmake/CMakeLists.txt

 endforeach(tgt)
 
 # PollyConfig holds the target definitions and general settings, PollyExports
 # the imported locations
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/PollyConfig.cmake.in
   ${POLLY_CONFIG_CMAKE_DIR}/PollyConfig.cmake
   @ONLY)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/PollyConfigVersion.cmake.in
+  ${POLLY_CONFIG_CMAKE_DIR}/PollyConfigVersion.cmake
+  @ONLY)
 
 file(GENERATE
   OUTPUT ${POLLY_CONFIG_CMAKE_DIR}/${POLLY_EXPORTS_FILE_NAME}
   CONTENT "${POLLY_EXPORTS}")
 
 
 # Generate PollyConfig.cmake for the install tree.
 unset(POLLY_EXPORTS)

 ${POLLY_EXPORTS}")
   endif()
 endforeach(tgt)
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/PollyConfig.cmake.in
   ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/PollyConfig.cmake
   @ONLY)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/PollyConfigVersion.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/PollyConfigVersion.cmake
+  @ONLY)
 file(GENERATE OUTPUT
   ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${POLLY_EXPORTS_FILE_NAME}
   CONTENT "${POLLY_EXPORTS}")
 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   install(
     FILES
     "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/PollyConfig.cmake"
+    "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/PollyConfigVersion.cmake"
     "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${POLLY_EXPORTS_FILE_NAME}"
     DESTINATION "${POLLY_INSTALL_PACKAGE_DIR}")
 endif ()

polly/cmake/PollyConfigVersion.cmake.in

+set(PACKAGE_VERSION "@PACKAGE_VERSION@")
+
+# Polly is API-compatible only with matching major.minor versions
+# and patch versions not less than that requested.
+if("@POLLY_VERSION_MAJOR@.@POLLY_VERSION_MINOR@" VERSION_EQUAL
+    "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}"
+   AND NOT "@POLLY_VERSION_PATCH@" VERSION_LESS "${PACKAGE_FIND_VERSION_PATCH}")
+  set(PACKAGE_VERSION_COMPATIBLE 1)
+  if("@POLLY_VERSION_PATCH@" VERSION_EQUAL
+      "${PACKAGE_FIND_VERSION_PATCH}")
+    set(PACKAGE_VERSION_EXACT 1)
+  endif()
+endif()