[Polly][Cmake] Optionally use a system isl version.

[philip.pfaffe]

Summary

This patch adds an option to build against a version of libisl already installed on the system. The installation is autodetected using the pkg-config file shipped with isl.

Usually the detection of the library would go into a FindISL.cmake module that creates an imported target. Here, I do this manually and in the root CMakeLists.txt. The main reason for this is that recent versions of FindPkgConfig (shipped with cmake 3.6 and up) will do this on their own. We should just wait until we can bump the minimum required cmake version to that point, or, if that's not going to happen soon, backport FindPkgConfig from cmake trunk (I didn't do this because I'm not up to speed on licensing).

BTW: The minimum required cmake version of Polly is currently 2.8 if built outside the LLVM tree. We should bump that at least to 3.4.3 to match LLVM.

[philip.pfaffe]

Fix small mistake.

[Meinersbur]

Thanks for the patch.

I did not understand the argument of not using a FindISL.cmake. You can have a FindISL.cmake and use FindPkgConfig in there? Once we bump to cmake 3.6 we can switch to using IMPORTED_TARGET in there and remove the manual creation of an imported target.

CMakeLists.txt

172 ↗

(On Diff #88729)

target_include_directories?

185 ↗

(On Diff #88729)

target_compile_options?

205–208 ↗

(On Diff #88729)

I'd prefer to declare a variable ISL_INCLUDE_DIRS that contains the required directories and is set by the POLLY_USE_EXTERNAL_ISL-handling mechanism to the directories of choice. It avoids having extra cases for POLLY_USE_EXTERNAL_ISL whenever it is used.

Would using target_include_directories(PollyISL INTERFACE ...) make this unnecessary?

lib/External/CMakeLists.txt

3 ↗

(On Diff #88729)

Indention

[philip.pfaffe]

Addressed the comments. I also took the liberty to advance the minimum required cmake version for building out-of-tree. This patch doesn't work with cmake 2.8, because IMPORTED targets aren't supported.

Nevertheless I stumbled onto a minor issue with this approach: if linked into the LLVM tools, the rpaths are lost. CMake builds everything with full rpath by default, but LLVM overwrites this with $ORIGIN/../lib. If Polly is linked statically into a tool, e.g. opt, the isl rpath is gone. Without putting libisl into the LD_LIBRARY_PATH, opt won't find it, or might even pick up the wrong one.

[philip.pfaffe]

CMakeLists.txt

185 ↗

(On Diff #88729)

This doesn't apply for IMPORTED targets.

[philip.pfaffe]

CMakeLists.txt

205–208 ↗

(On Diff #88729)

I'm using ISL_INCLUDE_DIRS now.

target_include_directories(PollyISL INTERFACE ...) doesn't easily work here, because you can't have source-tree or build-tree paths on a targets INTERFACE when it's being installed.

[Meinersbur]

Did you forget to add the additional files (cmake/CMakeLists.txt, cmake/FindIsl.cmake)?

I already commit the version bump to cmake 3.4.3.

[philip.pfaffe]

I absolutely did. The former was even superfluous.

[Meinersbur]

One suggestion left: I feel that the name POLLY_USE_EXTERNAL_ISL is ambiguous. Could be confused with LLVM_EXTERNAL_*. If it is OFF it uses isl from lib/External/isl. Could we change it to POLLY_BUNDLED_ISL and set it to ON by default? What do you think?

I tried it under Windows as well and it didn't work: no pkg-config available there. pkg_search_module also doesn't allow to configure the isl lib/include dirs manually. However, this is no concern atm as I don't know a reason why I would want an external isl on Windows.

[philip.pfaffe]

Renamed the POLLY_USE_EXTERNAL_ISL switch to POLLY_BUNDLED_ISL.

[Meinersbur]

Thanks.

I am going to commit it at the next occasion.

polly/trunk/CMakeLists.txt

 endif(POLLY_ENABLE_GPGPU_CODEGEN)
 
 
 # Support GPGPU code generation if the library is available.
 if (CUDALIB_FOUND)
   INCLUDE_DIRECTORIES( ${CUDALIB_INCLUDE_DIR} )
 endif(CUDALIB_FOUND)
 
+option(POLLY_BUNDLED_ISL "Use the bundled version of libisl included in Polly" ON)
+if (NOT POLLY_BUNDLED_ISL)
+  find_package(ISL MODULE REQUIRED)
+  message(STATUS "Using external libisl ${ISL_VERSION} in: ${ISL_PREFIX}")
+  set(ISL_TARGET ISL)
+else()
+  set(ISL_INCLUDE_DIRS
+    ${CMAKE_CURRENT_BINARY_DIR}/lib/External/isl/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/lib/External/isl/include
+  )
+  set(ISL_TARGET PollyISL)
+endif()
+
 include_directories(
   BEFORE
   ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${ISL_INCLUDE_DIRS}
   ${CMAKE_CURRENT_SOURCE_DIR}/lib/External/JSON/include
-  ${CMAKE_CURRENT_BINARY_DIR}/lib/External/isl/include
-  ${CMAKE_CURRENT_SOURCE_DIR}/lib/External/isl/include
   ${CMAKE_CURRENT_SOURCE_DIR}/lib/External/pet/include
   ${CMAKE_CURRENT_SOURCE_DIR}/lib/External
   ${CMAKE_CURRENT_BINARY_DIR}/include
   )
 
 if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
   install(DIRECTORY include/
     DESTINATION include

polly/trunk/cmake/FindISL.cmake

+find_package(PkgConfig REQUIRED)
+pkg_search_module(ISL isl)
+if (NOT ISL_FOUND EQUAL 1)
+  message(FATAL_ERROR "No libisl found on this system. Consider setting PKG_CONFIG_PATH.")
+endif()
+
+add_library(ISL INTERFACE IMPORTED)
+foreach (incl IN LISTS ISL_INCLUDE_DIRS)
+  set_property(TARGET ISL APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${incl})
+endforeach()
+
+foreach (libname IN LISTS ISL_LIBRARIES)
+  if (ISL_LIBRARY_DIRS)
+    foreach (dir IN LISTS ISL_LIBRARY_DIRS)
+      list(APPEND hints  ${dir})
+    endforeach()
+  endif()
+  find_library(lib NAMES ${libname} HINTS ${hints} NO_DEFAULT_PATH)
+  set_property(TARGET ISL APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${lib})
+endforeach()
+
+foreach (opt IN LISTS ISL_CFLAGS ISL_CFLAGS_OTHER)
+  set_property(TARGET ISL APPEND PROPERTY INTERFACE_COMPILE_OPTIONS ${opt})
+endforeach()

polly/trunk/lib/CMakeLists.txt

add_polly_library(Polly
   Transform/DeLICM.cpp
   ${POLLY_HEADER_FILES}
   )
 
 if (GPU_CODEGEN)
   target_link_libraries(Polly PollyPPCG)
 endif (GPU_CODEGEN)
 
-target_link_libraries(Polly PollyISL)
+target_link_libraries(Polly ${ISL_TARGET})
 
 if (BUILD_SHARED_LIBS)
   target_link_libraries(Polly
     LLVMSupport
     LLVMCore
     LLVMScalarOpts
     LLVMInstCombine
     LLVMTransformUtils

polly/trunk/lib/External/CMakeLists.txt

 # External: Integer Set Library
+if (POLLY_BUNDLED_ISL)
   set(ISL_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/isl")
   set(ISL_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/isl")
 
   # Determine version of isl
   if (EXISTS "${ISL_SOURCE_DIR}/GIT_HEAD_ID")
     # The source comes from a 'make dist' archive
     file(READ "${ISL_SOURCE_DIR}/GIT_HEAD_ID" ISL_GIT_HEAD_ID)
     string(STRIP "${ISL_GIT_HEAD_ID}" ISL_GIT_HEAD_ID)
   elseif (EXISTS "${ISL_SOURCE_DIR}/gitversion.h")
     # The source directory is preconfigured
     file(READ "${ISL_SOURCE_DIR}/gitversion.h" GITVERSION_H)
     string(REGEX REPLACE ".*\\\"([^\\\"]*)\\\".*" "\\1" ISL_GIT_HEAD_ID "${GITVERSION_H}")
   elseif ()
     # Unknown revision
     # TODO: We could look for a .git and get the revision from HEAD
     set(ISL_GIT_HEAD_ID "UNKNOWN")
   endif ()
 
   message(STATUS "ISL version: ${ISL_GIT_HEAD_ID}")
 
   # Enable small integer optimization and imath
   set(USE_GMP_FOR_MP OFF)
   set(USE_IMATH_FOR_MP ON)
   set(USE_SMALL_INT_OPT ON)
 
   # Determine compiler characteristics
   include(CheckCSourceCompiles)
 
   # Like check_c_source_compiles, but sets the result to either
   # 0 (error while compiling) or 1 (compiled successfully)
   # Required for compatibility with autotool's AC_CHECK_DECLS
   function (check_c_source_compiles_numeric _prog _var)
     check_c_source_compiles("${_prog}" "${_var}")
     if ("${${_var}}")
       set("${_var}" 1 PARENT_SCOPE)
     else ()
       set("${_var}" 0 PARENT_SCOPE)
     endif ()
   endfunction ()
 
   # Check for the existance of a type
   function (check_c_type_exists _type _files _variable)
     set(_includes "")
     foreach (file_name ${_files})
       set(_includes "${_includes}#include<${file_name}>\n")
     endforeach()
     check_c_source_compiles("
     ${_includes}
     ${_type} typeVar;
     int main() {
-        return 0;
     }
     " ${_variable})
   endfunction ()
 
 
   check_c_source_compiles("
   int func(void) __attribute__((__warn_unused_result__));
   int main() { return 0; }
   " HAS_ATTRIBUTE_WARN_UNUSED_RESULT)
   set(GCC_WARN_UNUSED_RESULT)
   if (HAS_ATTRIBUTE_WARN_UNUSED_RESULT)
     set(GCC_WARN_UNUSED_RESULT "__attribute__((__warn_unused_result__))")
   endif ()
 
   check_c_source_compiles("
   __attribute__ ((unused)) static void foo(void);
   int main() { return 0; }
   " HAVE___ATTRIBUTE__)
 
 
   check_c_source_compiles_numeric("
   #include <strings.h>
   int main() { (void)ffs(0); return 0; }
   " HAVE_DECL_FFS)
 
   check_c_source_compiles_numeric("
   int main() { (void)__builtin_ffs(0); return 0; }
   " HAVE_DECL___BUILTIN_FFS)
 
   check_c_source_compiles_numeric("
   #include <intrin.h>
   int main() { (void)_BitScanForward(NULL, 0); return 0; }
   " HAVE_DECL__BITSCANFORWARD)
 
   if (NOT HAVE_DECL_FFS AND
       NOT HAVE_DECL___BUILTIN_FFS AND
       NOT HAVE_DECL__BITSCANFORWARD)
     message(FATAL_ERROR "No ffs implementation found")
   endif ()
 
 
   check_c_source_compiles_numeric("
   #include <strings.h>
   int main() { (void)strcasecmp(\"\", \"\"); return 0; }
   " HAVE_DECL_STRCASECMP)
 
   check_c_source_compiles_numeric("
   #include <string.h>
   int main() { (void)_stricmp(\"\", \"\"); return 0; }
   " HAVE_DECL__STRICMP)
 
   if (NOT HAVE_DECL_STRCASECMP AND NOT HAVE_DECL__STRICMP)
     message(FATAL_ERROR "No strcasecmp implementation found")
   endif ()
 
 
   check_c_source_compiles_numeric("
   #include <strings.h>
   int main() { (void)strncasecmp(\"\", \"\", 0); return 0; }
   " HAVE_DECL_STRNCASECMP)
 
   check_c_source_compiles_numeric("
   #include <string.h>
   int main() { (void)_strnicmp(\"\", \"\", 0); return 0; }
   " HAVE_DECL__STRNICMP)
 
   if (NOT HAVE_DECL_STRNCASECMP AND NOT HAVE_DECL__STRNICMP)
     message(FATAL_ERROR "No strncasecmp implementation found")
   endif ()
 
 
   check_c_source_compiles_numeric("
   #include <stdio.h>
   int main() { snprintf((void*)0, 0, \" \"); return 0; }
   " HAVE_DECL_SNPRINTF)
 
   check_c_source_compiles_numeric("
   #include <stdio.h>
   int main() { _snprintf((void*)0, 0, \" \"); return 0; }
   " HAVE_DECL__SNPRINTF)
 
   if (NOT HAVE_DECL_SNPRINTF AND NOT HAVE_DECL__SNPRINTF)
     message(FATAL_ERROR "No snprintf implementation found")
   endif ()
 
 
   check_c_type_exists(uint8_t "" HAVE_UINT8T)
   check_c_type_exists(uint8_t "stdint.h" HAVE_STDINT_H)
   check_c_type_exists(uint8_t "inttypes.h" HAVE_INTTYPES_H)
   check_c_type_exists(uint8_t "sys/types.h" HAVE_SYS_INTTYPES_H)
   if (HAVE_UINT8T)
     set(INCLUDE_STDINT_H "")
   elseif (HAVE_STDINT_H)
     set(INCLUDE_STDINT_H "#include <stdint.h>")
   elseif (HAVE_INTTYPES_H)
     set(INCLUDE_STDINT_H "#include <inttypes.h>")
   elseif (HAVE_SYS_INTTYPES_H)
     set(INCLUDE_STDINT_H "#include <sys/inttypes.h>")
   else ()
     message(FATAL_ERROR "No stdint.h or compatible found")
   endif ()
 
   # Write configure result
   # configure_file(... COPYONLY) avoids that the time stamp changes if the file is identical
   file(WRITE "${ISL_BINARY_DIR}/gitversion.h.tmp"
-     "#define GIT_HEAD_ID \"${ISL_GIT_HEAD_ID}\"")
   configure_file("${ISL_BINARY_DIR}/gitversion.h.tmp"
-               "${ISL_BINARY_DIR}/gitversion.h" COPYONLY)
 
   file(WRITE "${ISL_BINARY_DIR}/include/isl/stdint.h.tmp"
-     "${INCLUDE_STDINT_H}\n")
   configure_file("${ISL_BINARY_DIR}/include/isl/stdint.h.tmp"
-               "${ISL_BINARY_DIR}/include/isl/stdint.h" COPYONLY)
 
   configure_file("isl_config.h.cmake" "${ISL_BINARY_DIR}/isl_config.h")
   configure_file("isl_srcdir.c.cmake" "${ISL_BINARY_DIR}/isl_srcdir.c")
 
   include_directories(BEFORE
     ${ISL_BINARY_DIR}
     ${ISL_SOURCE_DIR}/imath
     ${ISL_SOURCE_DIR}/include
     ${ISL_SOURCE_DIR}
     )
 
   # ISL files to compile
   set (ISL_FILES
     isl/basis_reduction_tab.c
     isl/isl_aff.c
     isl/isl_affine_hull.c
     isl/isl_arg.c
     isl/isl_ast_build.c
     isl/isl_ast_build_expr.c
     isl/isl_ast.c
     isl/isl_ast_codegen.c
set (ISL_FILES
     isl/isl_version.c
     isl/isl_vertices.c
     isl/print.c
     isl/imath/gmp_compat.c
     isl/imath/imath.c
     isl/imath/imrat.c
     )
 
   add_polly_library(PollyISL
     ${ISL_FILES}
     )
 
 
-# TODO: optionally use system isl instead
   if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY)
     install(DIRECTORY
       ${ISL_SOURCE_DIR}/include/
       ${ISL_BINARY_DIR}/include/
       DESTINATION include/polly
       FILES_MATCHING
       PATTERN "*.h"
       PATTERN "CMakeFiles" EXCLUDE
       PATTERN ".svn" EXCLUDE
       )
   endif()
 
   add_executable(polly-isl-test
     isl/isl_test.c
     )
   set_target_properties(polly-isl-test PROPERTIES FOLDER "Polly")
 
   target_link_libraries(polly-isl-test
     PollyISL
     )
 
   # ISL requires at least C99 to compile. gcc < 5.0 use -std=gnu89 as default.
   target_enable_c99(PollyISL)
   target_enable_c99(polly-isl-test)
+endif (POLLY_BUNDLED_ISL)
 
 set(PET_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/pet")
 set(PPCG_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ppcg")
 set(PPCG_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/ppcg")
 
 # Determine version of ppcg
 if (EXISTS "${PPCG_SOURCE_DIR}/GIT_HEAD_ID")
   # The source comes from a 'make dist' archive
include_directories(BEFORE
   ${PPCG_SOURCE_DIR}/include
   ${PET_SOURCE_DIR}/include
 )
 
 add_polly_library(PollyPPCG
   ${PPCG_FILES}
 )
 
-target_link_libraries(PollyPPCG PollyISL)
+target_link_libraries(PollyPPCG ${ISL_TARGET})
 
 # Disable warnings for upstream projects.
 if (MSVC)
   set(DISABLE_WARNING_FLAGS
     -wd4018 # 'expression' : signed/unsigned mismatch
     -wd4090 # 'operation' : different 'modifier' qualifiers
     -wd4200 # nonstandard extension used: zero-sized array in struct/union
     -wd4201 # nonstandard extension used: nameless struct/union
     -wd4334 # 'operator': result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
   )
+  if (POLLY_BUNDLED_ISL)
     target_compile_options(PollyISL PRIVATE ${DISABLE_WARNING_FLAGS})
     target_compile_options(polly-isl-test PRIVATE ${DISABLE_WARNING_FLAGS})
+  endif (POLLY_BUNDLED_ISL)
   target_compile_options(PollyPPCG PRIVATE ${DISABLE_WARNING_FLAGS})
 else ()
-  set_target_properties(PollyISL polly-isl-test PollyPPCG PROPERTIES
-    COMPILE_FLAGS "-w"
-  )
+  if (POLLY_BUNDLED_ISL)
+    set_target_properties(PollyISL polly-isl-test PROPERTIES COMPILE_FLAGS "-w")
+  endif (POLLY_BUNDLED_ISL)
+  set_target_properties(PollyPPCG PROPERTIES COMPILE_FLAGS "-w")
 endif ()
 
 if(MSVC)
   # In the Windows API (with some exceptions), the maximum length for a path is
   # MAX_PATH, which is defined as 260 characters. 
   target_compile_definitions(PollyPPCG PRIVATE "-DPATH_MAX=260")
 endif ()

polly/trunk/test/CMakeLists.txt

 add_custom_target(check-polly)
 set_target_properties(check-polly PROPERTIES FOLDER "Polly")
 
 if (NOT DEFINED LLVM_MAIN_SRC_DIR)
 
   # We are building polly out of tree, adjust the settings.
   # FIXME: FileCheck is not available in llvm install directory at the moment.
   set(LLVM_LIT ${LLVM_INSTALL_ROOT}/bin/llvm-lit)
+  if (POLLY_BUNDLED_ISL)
     set(POLLY_TEST_DEPS LLVMPolly polly-isl-test)
+  endif (POLLY_BUNDLED_ISL)
   if (POLLY_GTEST_AVAIL)
     list(APPEND POLLY_TEST_DEPS PollyUnitTests)
   endif ()
 
   set(LLVM_BINARY_DIR "${LLVM_INSTALL_ROOT}")
   set(LLVM_TOOLS_DIR "${LLVM_INSTALL_ROOT}/bin")
   set(LLVM_LIBS_DIR "${LLVM_INSTALL_ROOT}/lib")
   set(POLLY_LIB_DIR "${POLLY_BINARY_DIR}/lib")
if (POLLY_GTEST_AVAIL)
                   DEPENDS PollyUnitTests
                   COMMENT "Running Polly unit tests")
       set_target_properties(check-polly-unittests PROPERTIES FOLDER "Polly")
     endif ()
     configure_file(
       ${CMAKE_CURRENT_SOURCE_DIR}/UnitIsl/lit.site.cfg.in
       ${CMAKE_CURRENT_BINARY_DIR}/UnitIsl/lit.site.cfg)
 
+
+    if (POLLY_BUNDLED_ISL)
       add_custom_target(check-polly-isl
         command ${LLVM_LIT}
                   --param polly_site_config=${CMAKE_CURRENT_BINARY_DIR}/UnitIsl/lit.site.cfg
                   --param build_config=${CMAKE_CFG_INTDIR}
                   -sv ${POLLY_TEST_EXTRA_ARGS}
                   ${CMAKE_CURRENT_BINARY_DIR}
                   DEPENDS polly-isl-test
                   COMMENT "Running isl unit tests")
       set_target_properties(check-polly-isl PROPERTIES FOLDER "Polly")
+    endif (POLLY_BUNDLED_ISL)
   endif()
 
 else (NOT DEFINED LLVM_MAIN_SRC_DIR)
 
   set(LLVM_LIT ${LLVM_TOOLS_BINARY_DIR}/llvm-lit)
-  set(POLLY_TEST_DEPS llvm-config opt LLVMPolly FileCheck not polly-isl-test)
+  set(POLLY_TEST_DEPS llvm-config opt LLVMPolly FileCheck not)
+  if (POLLY_BUNDLED_ISL)
+    list(APPEND POLLY_TEST_DEPS polly-isl-test)
+  endif()
   if (POLLY_GTEST_AVAIL)
     list(APPEND POLLY_TEST_DEPS PollyUnitTests)
   endif ()
 
   set(LLVM_BINARY_DIR "${LLVM_BINARY_DIR}")
   set(LLVM_TOOLS_DIR "${LLVM_TOOLS_BINARY_DIR}")
   set(LLVM_LIBS_DIR "${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}")
   set(POLLY_LIB_DIR "${LLVM_LIBS_DIR}")
add_lit_testsuite(check-polly-unittests "Running polly unit tests only"
       )
     set_target_properties(check-polly-unittests PROPERTIES FOLDER "Polly")
   endif ()
 
   configure_file(
     ${CMAKE_CURRENT_SOURCE_DIR}/UnitIsl/lit.site.cfg.in
     ${CMAKE_CURRENT_BINARY_DIR}/UnitIsl/lit.site.cfg)
 
+  if (POLLY_BUNDLED_ISL)
     add_lit_testsuite(check-polly-isl "Running isl unit tests only"
       ${CMAKE_CURRENT_BINARY_DIR}/UnitIsl
       PARAMS polly_site_config=${CMAKE_CURRENT_BINARY_DIR}/UnitIsl/lit.site.cfg
       DEPENDS polly-isl-test
       )
     set_target_properties(check-polly-isl PROPERTIES FOLDER "Polly")
+  endif (POLLY_BUNDLED_ISL)
 
   # Run polly-check-format as part of polly-check only if we are compiling with
   # clang, so clang-format is available.
   # if (TARGET clang-format) would be preferable, but this target is only added
   # after Polly, i.e. there is no such target yet at this point. The CMake cache
   # entry LLVM_TOOL_CLANG_BUILD will only be defined after clang has been
   # configured at least once, i.e. format will be checked only after a rerun of
   # CMake's configure.