[Polly] Really fix Windows builds.

[DiamondLovesYou]

Summary

Cleanup and refactor the lib/ CMake script to utilize modern LLVM CMake features. Moved lib/Polly.cpp to lib/Polly/Polly.cpp to satisfy LLVM CMake checks.

Combined with a forthcoming patch to LLVM and LLVM_LINK_LLVM_DYLIB, allows building LLVMPolly on Windows.

[Meinersbur]

Does this fix the Windows or "non-MSVC" builds (as D51904)? For which configurations?

The patch moves some code around. Could you detail what you did and why?
(I intend to test all/most configurations before accepting)

[DiamondLovesYou]

Update the unit tests to work with the changes in this patch and the changes from upstream.

[Meinersbur]

Currently, when I apply this, I get the following error (Windows and Linux):

CMake Error at cmake/modules/LLVM-Config.cmake:105 (target_link_libraries):
  Target "LLVMPolly" of type MODULE_LIBRARY may not be linked into another
  target.  One may link only to STATIC or SHARED libraries, or to executables
  with the ENABLE_EXPORTS property set.
Call Stack (most recent call first):
  cmake/modules/LLVM-Config.cmake:93 (explicit_llvm_config)
  cmake/modules/AddLLVM.cmake:774 (llvm_config)
  cmake/modules/AddLLVM.cmake:1108 (add_llvm_executable)
  tools/polly/unittests/CMakeLists.txt:9 (add_unittest)
  tools/polly/unittests/Isl/CMakeLists.txt:1 (add_polly_unittest)

Can you ping this review when the a forthcoming patch to LLVM has landed?

[Meinersbur]

When applying this patch to the current trunk, I get:

CMake Error at tools/polly/lib/CMakeLists.txt:116 (add_llvm_loadable_module):
  Unknown CMake command "add_llvm_loadable_module".

CMakeLists.txt

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)
+  set(ISL_TARGET LLVMPollyISL)
 endif()
 
 include_directories(
   BEFORE
   ${CMAKE_CURRENT_SOURCE_DIR}/include
   ${ISL_INCLUDE_DIRS}
   ${CMAKE_CURRENT_SOURCE_DIR}/lib/External/pet/include
   ${CMAKE_CURRENT_SOURCE_DIR}/lib/External

cmake/CMakeLists.txt

 # Keep this in sync with llvm/cmake/CMakeLists.txt!
 
 set(LLVM_INSTALL_PACKAGE_DIR "lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm")
 set(POLLY_INSTALL_PACKAGE_DIR "lib${LLVM_LIBDIR_SUFFIX}/cmake/polly")
 if (CMAKE_CONFIGURATION_TYPES)
   set(POLLY_EXPORTS_FILE_NAME "PollyExports-$<LOWER_CASE:$<CONFIG>>.cmake")
 else()
   # avoid conflicts in the build-tree when changing configuration
   set(POLLY_EXPORTS_FILE_NAME "PollyExports-all.cmake")
 endif()
 
 set(POLLY_CONFIG_EXPORTED_TARGETS Polly ${ISL_TARGET})
-if (NOT MSVC)
-  # LLVMPolly is a dummy target on Win
-  list(APPEND POLLY_CONFIG_EXPORTED_TARGETS LLVMPolly)
-endif()
 if (POLLY_ENABLE_GPGPU_CODEGEN)
-  list(APPEND POLLY_CONFIG_EXPORTED_TARGETS PollyPPCG)
+  list(APPEND POLLY_CONFIG_EXPORTED_TARGETS LLVMPollyPPCG)
 endif()
 
 # Get the target type for every exported target
 foreach(tgt IN LISTS POLLY_CONFIG_EXPORTED_TARGETS)
   get_target_property(tgt_type ${tgt} TYPE)
   string(REPLACE "_LIBRARY" "" tgt_type ${tgt_type})
   set(POLLY_CONFIG_TARGET_${tgt}_TYPE ${tgt_type})
 endforeach()

cmake/polly_macros.cmake

file( GLOB_RECURSE headers
       ../../include/polly${dir}/*.h)
     set(srcs ${srcs} ${headers})
   endif(MSVC_IDE OR XCODE)
   if (MODULE)
     set(libkind MODULE)
   elseif (SHARED_LIBRARY)
     set(libkind SHARED)
   else()
-    set(libkind)
+    set(libkind STATIC)
   endif()
-  add_library( ${name} ${libkind} ${srcs} )
-  set_target_properties(${name} PROPERTIES FOLDER "Polly")
+  add_llvm_library( ${name}
+    ${srcs}
 
-  if( LLVM_COMMON_DEPENDS )
-    add_dependencies( ${name} ${LLVM_COMMON_DEPENDS} )
-  endif( LLVM_COMMON_DEPENDS )
-  if( LLVM_USED_LIBS )
-    foreach(lib ${LLVM_USED_LIBS})
-      target_link_libraries( ${name} PUBLIC ${lib} )
-    endforeach(lib)
-  endif( LLVM_USED_LIBS )
-
-  if(POLLY_LINK_LIBS)
-    foreach(lib ${POLLY_LINK_LIBS})
-      target_link_libraries(${name} PUBLIC ${lib})
-    endforeach(lib)
-  endif(POLLY_LINK_LIBS)
-
-  if( LLVM_LINK_COMPONENTS )
-    llvm_config(${name} ${LLVM_LINK_COMPONENTS})
-  endif( LLVM_LINK_COMPONENTS )
-  if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY OR ${name} STREQUAL "LLVMPolly")
-    install(TARGETS ${name}
-      EXPORT LLVMExports
-      LIBRARY DESTINATION lib${LLVM_LIBDIR_SUFFIX}
-      ARCHIVE DESTINATION lib${LLVM_LIBDIR_SUFFIX})
-  endif()
-  set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
+    ${libkind}
+
+    LINK_LIBS ${POLLY_LINK_LIBS}
+    )
+  set_target_properties(${name} PROPERTIES FOLDER "Polly")
 endmacro(add_polly_library)
 
 macro(add_polly_loadable_module name)
   set(srcs ${ARGN})
   # klduge: pass different values for MODULE with multiple targets in same dir
   # this allows building shared-lib and module in same dir
   # there must be a cleaner way to achieve this....
   if (MODULE)
   else()
     set(GLOBAL_NOT_MODULE TRUE)
   endif()
   set(MODULE TRUE)
   add_polly_library(${name} ${srcs})
-  set_target_properties(${name} PROPERTIES FOLDER "Polly")
   if (GLOBAL_NOT_MODULE)
     unset (MODULE)
   endif()
   if (APPLE)
     # Darwin-specific linker flags for loadable modules.
     set_target_properties(${name} PROPERTIES
       LINK_FLAGS "-Wl,-flat_namespace -Wl,-undefined -Wl,suppress")
   endif()

lib/CMakeLists.txt

 # Compile ISL into a separate library.
 add_subdirectory(External)
 
 set(POLLY_HEADER_FILES)
 if (MSVC_IDE OR XCODE)
   file(GLOB_RECURSE POLLY_HEADER_FILES "${POLLY_SOURCE_DIR}/include/polly/*.h")
 endif ()
 
+# Polly-ACC requires the NVPTX backend to work. Ask LLVM about its libraries.
+set(nvptx_libs)
+if (GPU_CODEGEN)
+  # This call emits an error if they NVPTX backend is not enable.
+  llvm_map_components_to_libnames(nvptx_libs NVPTX)
+endif ()
+
+set(LLVM_COMPONENTS
+  Support
+  Core
+  ScalarOpts
+  InstCombine
+  TransformUtils
+  Analysis
+  ipo
+  MC
+  Passes
+  Linker
+  IRReader
+  ${nvptx_libs}
+  # The libraries below are required for darwin: http://PR26392
+  BitReader
+  MCParser
+  Object
+  ProfileData
+  Target
+  Vectorize
+
+  PollyISL
+  )
+
+# Additional dependencies for Polly-ACC.
+if (GPU_CODEGEN)
+  list(APPEND LLVM_COMPONENTS PollyPPCG)
+endif ()
+
 # Use an object-library to add the same files to multiple libs without requiring
 # the sources them to be recompiled for each of them.
-add_library(PollyCore OBJECT
+add_llvm_library(Polly
   Analysis/DependenceInfo.cpp
   Analysis/PolyhedralInfo.cpp
   Analysis/ScopDetection.cpp
   Analysis/ScopDetectionDiagnostic.cpp
   Analysis/ScopInfo.cpp
   Analysis/ScopBuilder.cpp
   Analysis/ScopGraphPrinter.cpp
   Analysis/ScopPass.cpp
add_llvm_library(Polly
   Transform/ForwardOpTree.cpp
   Transform/DeLICM.cpp
   Transform/ZoneAlgo.cpp
   Transform/Simplify.cpp
   Transform/MaximalStaticExpansion.cpp
   Transform/RewriteByReferenceParameters.cpp
   Transform/ScopInliner.cpp
   ${POLLY_HEADER_FILES}
-  )
-set_target_properties(PollyCore PROPERTIES FOLDER "Polly")
 
-# Create the library that can be linked into LLVM's tools and Polly's unittests.
-# It depends on all library it needs, such that with
-# LLVM_POLLY_LINK_INTO_TOOLS=ON, its dependencies like PollyISL are linked as
-# well.
-add_polly_library(Polly $<TARGET_OBJECTS:PollyCore>)
-target_link_libraries(Polly PUBLIC
-  ${ISL_TARGET}
-)
+  OBJECT
+  STATIC
 
-# Additional dependencies for Polly-ACC.
-if (GPU_CODEGEN)
-  target_link_libraries(Polly PUBLIC PollyPPCG)
-endif ()
+  DEPENDS intrinsics_gen
 
-
-# Polly-ACC requires the NVPTX backend to work. Ask LLVM about its libraries.
-set(nvptx_libs)
-if (GPU_CODEGEN)
-  # This call emits an error if they NVPTX backend is not enable.
-  llvm_map_components_to_libnames(nvptx_libs NVPTX)
-endif ()
-
-if (LLVM_LINK_LLVM_DYLIB)
-  # The shlib/dylib contains all the LLVM components
-  # (including NVPTX is enabled) already. Adding them to target_link_libraries
-  # would cause them being twice in the address space
-  # (their LLVM*.a/so and their copies in libLLVM.so)
-  # which results in errors when the two instances try to register the same
-  # command-line switches.
-  target_link_libraries(Polly PUBLIC LLVM)
-else ()
-  target_link_libraries(Polly PUBLIC
-    LLVMSupport
-    LLVMCore
-    LLVMScalarOpts
-    LLVMInstCombine
-    LLVMTransformUtils
-    LLVMAnalysis
-    LLVMipo
-    LLVMMC
-    LLVMPasses
-    LLVMLinker
-    LLVMIRReader
-    ${nvptx_libs}
-    # The libraries below are required for darwin: http://PR26392
-    LLVMBitReader
-    LLVMMCParser
-    LLVMObject
-    LLVMProfileData
-    LLVMTarget
-    LLVMVectorize
-    )
-endif ()
+  LINK_COMPONENTS ${LLVM_COMPONENTS}
+  LINK_LIBS ${POLLY_LINK_LIBS}
+set_target_properties(Polly PROPERTIES FOLDER "Polly")
 
-# Create a loadable module Polly.so that can be loaded using
-# LLVM's/clang's "-load" option.
-if (MSVC)
-  # Add dummy target, because loadable modules are not supported on Windows
-  add_custom_target(LLVMPolly)
-  set_target_properties(LLVMPolly PROPERTIES FOLDER "Polly")
-else ()
-  add_polly_loadable_module(LLVMPolly
-    Polly.cpp
-    $<TARGET_OBJECTS:PollyCore>
-  )
+add_llvm_loadable_module(LLVMPolly
+  Polly/Polly.cpp
+  $<TARGET_OBJECTS:obj.Polly>
 
-  # Only add the dependencies that are not part of LLVM. The latter are assumed
-  # to be already available in the address space the module is loaded into.
-  # Adding them once more would have the effect that both copies try to register
-  # the same command line options, to which LLVM reacts with an error.
-  # If Polly-ACC is enabled, the NVPTX target is also expected to reside in the
-  # hosts. This is not the case for bugpoint. Use LLVM_POLLY_LINK_INTO_TOOLS=ON
-  # instead which will automatically resolve the additional dependencies by
-  # Polly.
-  target_link_libraries(LLVMPolly PUBLIC ${ISL_TARGET})
-  if (GPU_CODEGEN)
-    target_link_libraries(LLVMPolly PUBLIC PollyPPCG)
-  endif ()
+  LINK_COMPONENTS ${LLVM_COMPONENTS}
+  LINK_LIBS ${POLLY_LINK_LIBS}
+  )
 
-  set_target_properties(LLVMPolly
-    PROPERTIES
-    LINKER_LANGUAGE CXX
-    PREFIX "")
-endif ()
-
-if (TARGET intrinsics_gen)
-  # Check if we are building as part of an LLVM build
-  add_dependencies(PollyCore intrinsics_gen)
-endif()
-
+  FOLDER "Polly"
+  PREFIX ""
+  )

lib/External/CMakeLists.txt

set (ISL_FILES
     isl/set_from_map.c
     isl/uset_to_umap.c
     isl/uset_from_umap.c
     isl/imath/gmp_compat.c
     isl/imath/imath.c
     isl/imath/imrat.c
     )
 
-  add_polly_library(PollyISL
+  add_polly_library(LLVMPollyISL
     ${ISL_FILES}
     )
 
 
   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
+  set(LLVM_LINK_COMPONENTS PollyISL)
+  add_llvm_executable(polly-isl-test
     isl/isl_test.c
     )
   set_target_properties(polly-isl-test PROPERTIES FOLDER "Polly")
-
-  target_link_libraries(polly-isl-test PRIVATE
-    PollyISL
-    )
+  set(LLVM_LINK_COMPONENTS)
 
   # ISL requires at least C99 to compile. gcc < 5.0 use -std=gnu89 as default.
-  target_enable_c99(PollyISL)
+  target_enable_c99(LLVMPollyISL)
   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

 
 include_directories(BEFORE
   ${PPCG_BINARY_DIR}
   ${PPCG_SOURCE_DIR}/imath
   ${PPCG_SOURCE_DIR}/include
   ${PET_SOURCE_DIR}/include
 )
 
-add_polly_library(PollyPPCG
+add_llvm_library(LLVMPollyPPCG
   ${PPCG_FILES}
-)
 
-target_link_libraries(PollyPPCG PUBLIC ${ISL_TARGET})
+  LINK_COMPONENTS PollyISL
+)
 
 # 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?)
     -wd4221 # nonstandard extension used : 'identifier' : cannot be initialized using address of automatic variable
   )
   if (POLLY_BUNDLED_ISL)
-    target_compile_options(PollyISL PRIVATE ${DISABLE_WARNING_FLAGS})
+    target_compile_options(LLVMPollyISL 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})
+  target_compile_options(LLVMPollyPPCG PRIVATE ${DISABLE_WARNING_FLAGS})
 else ()
   if (POLLY_BUNDLED_ISL)
-    set_target_properties(PollyISL polly-isl-test PROPERTIES COMPILE_FLAGS "-w")
+    set_target_properties(LLVMPollyISL polly-isl-test PROPERTIES COMPILE_FLAGS "-w")
   endif (POLLY_BUNDLED_ISL)
-  set_target_properties(PollyPPCG PROPERTIES COMPILE_FLAGS "-w")
+  set_target_properties(LLVMPollyPPCG 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")
+  target_compile_definitions(LLVMPollyPPCG PRIVATE "-DPATH_MAX=260")
 endif ()

lib/Polly/Polly.cpp

 //===---------- Polly.cpp - Initialize the Polly Module -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //===----------------------------------------------------------------------===//
 
 #include "polly/RegisterPasses.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 
 namespace {
 
 /// Initialize Polly passes when library is loaded.
 ///
 /// We use the constructor of a statically declared object to initialize the
 /// different Polly passes right after the Polly library is loaded. This ensures
 /// that the Polly passes are available e.g. in the 'opt' tool.
 class StaticInitializer {
 public:
   StaticInitializer() {
     llvm::PassRegistry &Registry = *llvm::PassRegistry::getPassRegistry();
     polly::initializePollyPasses(Registry);
   }
 };
 static StaticInitializer InitializeEverything;
 } // end of anonymous namespace.

unittests/CMakeLists.txt

 add_custom_target(PollyUnitTests)
 set_target_properties(PollyUnitTests PROPERTIES FOLDER "Polly")
 
 # add_polly_unittest(test_dirname file1.cpp file2.cpp)
 #
 # Will compile the list of files together and link against Polly and its dependences.
 function(add_polly_unittest test_name)
-  if(COMMAND add_unittest)
-    add_unittest(PollyUnitTests ${test_name} ${ARGN})
-  else()
-    add_executable(${test_name} EXCLUDE_FROM_ALL ${ARGN})
-    set_target_properties(${test_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
-    target_link_libraries(${test_name} PRIVATE gtest_main gtest)
-    add_dependencies(PollyUnitTests ${test_name})
-
-    set_property(TARGET ${test_name} PROPERTY FOLDER "Polly")
-  endif()
-  target_link_libraries(${test_name} PRIVATE Polly)
+  list(APPEND LLVM_LINK_COMPONENTS Analysis Core Passes Polly PollyISL)
 endfunction()
 
 add_subdirectory(Isl)
 add_subdirectory(Flatten)
 add_subdirectory(DeLICM)
 add_subdirectory(ScopPassManager)
 add_subdirectory(ScheduleOptimizer)
 add_subdirectory(Support)