CMakeLists.txt

cmake_minimum_required(VERSION 3.4.3)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

project(TSAR VERSION 0.0.0 LANGUAGES CXX)

if(SAPFOR_VERSION)
  set(TSAR_VERSION ${SAPFOR_VERSION})
  set(TSAR_VERSION_MAJOR ${SAPFOR_VERSION_MAJOR})
  set(TSAR_VERSION_MINOR ${SAPFOR_VERSION_MINOR})
  set(TSAR_VERSION_PATCH ${SAPFOR_VERSION_PATCH})
  set(TSAR_VERSION_SUFFIX ${SAPFOR_VERSION_SUFFIX})

  set(PROJECT_VERSION ${TSAR_VERSION})
  set(PROJECT_VERSION_MAJOR ${TSAR_VERSION_MAJOR})
  set(PROJECT_VERSION_MINOR ${TSAR_VERSION_MINOR})
  set(PROJECT_VERSION_PATCH ${TSAR_VERSION_PATCH})
endif()

option(TSAR_DIRTY_BUILD "Do not use commit-based TSAR version string" ON)
set(TSAR_VERSION_BUILD "dirty")
if (NOT TSAR_DIRTY_BUILD)
  find_package(Git)
  if (GIT_FOUND)
    execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --pretty=format:%h
      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
      RESULT_VARIABLE TSAR_SHA_ERROR OUTPUT_VARIABLE TSAR_SHA)
    if (NOT TSAR_SHA_ERROR)
      set(TSAR_VERSION_BUILD ${TSAR_SHA})
    endif()
  endif()
endif()
set_property(GLOBAL PROPERTY TSAR_VERSION_BUILD ${TSAR_VERSION_BUILD})
set(TSAR_VERSION "${TSAR_VERSION}+${TSAR_VERSION_BUILD}")

set(TSAR_DESCRIPTION "Traits Static Analyzer")
set(TSAR_HOMEPAGE_URL "https://github.com/dvm-system/tsar")

set (TSAR_FOLDER "Tools" CACHE STRING "Specify IDE folder for TSAR executable.")
set (TSAR_LIBRARY_FOLDER "Tsar libraries" CACHE STRING "Specify IDE folder for TSAR libraries.")
set (TSAR_SERVER_FOLDER "Tools" CACHE STRING "Specify IDE folder for TSAR server library.")
if (TSAR_FOLDER OR TSAR_LIBRARY_FOLDER)
  set_property(GLOBAL PROPERTY USE_FOLDERS ON)
endif()

find_package(BCL 3.0 REQUIRED CONFIG)

option(BUILD_APC "Build automated parallelizing compiler" OFF)
if (BUILD_APC)
  find_package(APC CONFIG REQUIRED)
  message(STATUS "APC version: ${APC_VERSION}")
endif()

option(BUILD_lp_solve "Build Mixed Integer Linear Programming (MILP) solver" OFF)
if (BUILD_lp_solve)
  find_package(lp_solve CONFIG QUIET)
  message(STATUS "lp_solve version: ${lp_solve_VERSION}")
endif()

set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${BCL_CMAKE_MODULE_PATH})

# Minimum LLVM version which is necessary to build TSAR.
set(LLVM_MIN_VERSION 11.0)

include(CMakeDependentOption)
include(BCLCompilerOptions)
include(BCLUtils)
include(llvm-utility)

# There are three steps to configure LLVM and Clang:
# 1.a (PACKAGE_LLVM is OFF, GIT mono repo is only supported):
#    Use LLVM as TSAR subproject (add_subdirectory() is used to build LLVM).
# 1.b (PACKAGE_LLVM is ON):
#    Use previously installed LLVM package.
# 2. Configure LLVM project (in case of 1.a only).
# 4. Specify LLVM dependences (include directories, libraries, macros etc.

option(PACKAGE_LLVM "Use previously installed LLVM package" OFF)

set(LLVM_PROJECT_DIR "" CACHE PATH
   "Root of LLVM source tree (path to llvm-project directory, usefull if PACKAGE_LLVM is set to OFF")

set(LLVM_VERSION ${LLVM_MIN_VERSION} CACHE STRING
  "Version of installed LLVM package (useful only if PACKAGE_LLVM is set)")

option(BUILD_TSAR "Build Traits Static Analyzer" ON)
option(TSAR_SERVER "Build TSAR server shared library" OFF)

cmake_dependent_option(BUILD_CLANG "Build LLVM native C/C++/Objective-C compiler Clang" OFF
  "NOT PACKAGE_LLVM" OFF)
cmake_dependent_option(BUILD_PROFILE "Build profile runtime" OFF
  "NOT PACKAGE_LLVM" OFF)
cmake_dependent_option(BUILD_OPT "Build LLVM optimizer" OFF
  "NOT PACKAGE_LLVM" OFF)
cmake_dependent_option(BUILD_LLC "Build LLVM IR static compiler" OFF
  "NOT PACKAGE_LLVM" OFF)
cmake_dependent_option(BUILD_LINK "Build LLVM bitcode linker" OFF
  "NOT PACKAGE_LLVM" OFF)
cmake_dependent_option(BUILD_FLANG "Build LLVM native Fortran compiler Flang" OFF UNIX OFF)

option(TSAR_ENABLE_LLVM_DUMP "Enable use of dump() method for LLVM types" ON)

set(LLVM_SOURCE_DIR "${LLVM_PROJECT_DIR}/llvm")
set(CLANG_SOURCE_DIR "${LLVM_PROJECT_DIR}/clang")
set(FLANG_SOURCE_DIR "${LLVM_PROJECT_DIR}/flang")
set(COMPILER_RT_SOURCE_DIR "${LLVM_PROJECT_DIR}/compiler-rt")

set(LLVM_BINARY_DIR "${CMAKE_BINARY_DIR}/llvm-build")
set(CLANG_BINARY_DIR "${LLVM_BINARY_DIR}/tools/clang")
set(FLANG_BINARY_DIR "${LLVM_BINARY_DIR}/tools/flang")

set(FLANG_FOUND OFF)

if(PACKAGE_LLVM)
  find_package(LLVM ${LLVM_VERSION} REQUIRED CONFIG)
  set(LLVM_SOURCE_DIR "${LLVM_BINARY_DIR}/include/llvm")
  set(CLANG_SOURCE_DIR "${LLVM_BINARY_DIR}/include/clang")
  set(FLANG_SOURCE_DIR "${LLVM_BINARY_DIR}/include/flang")
  set(CLANG_INCLUDE_DIR "${LLVM_BINARY_DIR}/lib/clang/${LLVM_VERSION}/include")
  set(CLANG_EXECUTABLE "${LLVM_BINARY_DIR}/bin/clang${CMAKE_EXECUTABLE_SUFFIX}")
  if (EXISTS ${FLANG_SOURCE_DIR})
    set(FLANG_FOUND ON)
  else()
    message(WARNING "Flang compiler is not found, build with limited Fortran support")
  endif()
  if (MSVC_IDE)
    if (TARGET intrinsics_gen)
      set_target_properties(intrinsics_gen PROPERTIES FOLDER "Tablegenning")
    endif()
  endif()
else()
  if (NOT LLVM_PROJECT_DIR)
    message(FATAL_ERROR "Unable to find LLVM sources. \
                         Set LLVM_PROJECT_DIR to build LLVM from sources or \
                         use PACKAGE_LLVM option to access previously installed LLVM package.")
  endif()
  if(NOT EXISTS ${LLVM_SOURCE_DIR})
    message(FATAL_ERROR "LLVM_SOURCE_DIR '${LLVM_SOURCE_DIR}' does not exist")
  endif()
  if ((BUILD_CLANG OR BUILD_TSAR) AND NOT EXISTS ${CLANG_SOURCE_DIR})
    message(FATAL_ERROR "CLANG_SOURCE_DIR '${CLANG_SOURCE_DIR}' does not exist")
  endif()
  if (BUILD_FLANG AND NOT EXISTS ${FLANG_SOURCE_DIR})
    message(FATAL_ERROR "FLANG_SOURCE_DIR '${FLANG_SOURCE_DIR}' does not exist")
  endif()
  if (BUILD_PROFILE AND NOT EXISTS ${COMPILER_RT_SOURCE_DIR})
    message(FATAL_ERROR "COMPILER_RT_SOURCE_DIR '${COMPILER_RT_SOURCE_DIR}' does not exist")
  endif()
  set(LLVM_STATUS "Configuring LLVM project")
  message(STATUS ${LLVM_STATUS})
  set(LLVM_PROJECTS clang)
  if (BUILD_FLANG)
    set(LLVM_PROJECTS ${LLVM_PROJECTS} flang)
  endif()
  if (BUILD_PROFILE)
    set(LLVM_PROJECTS ${LLVM_PROJECTS} compiler-rt)
  endif()
  set(LLVM_ENABLE_PROJECTS ${LLVM_PROJECTS} CACHE STRING "" FORCE)
  unset(LLVM_DIR CACHE)
  add_subdirectory(${LLVM_SOURCE_DIR} ${LLVM_BINARY_DIR} EXCLUDE_FROM_ALL)
  find_package(LLVM CONFIG HINTS ${LLVM_BINARY_DIR} NO_DEFAULT_PATH)
  if(NOT LLVM_FOUND)
    message(FATAL_ERROR "${LLVM_STATUS} - error")
  else()
    message(STATUS "${LLVM_STATUS} - done")
  endif()
  set(LLVM_VERSION ${LLVM_VERSION} CACHE STRING "" FORCE)
  if(BUILD_PROFILE AND (NOT LLVM_TOOL_COMPILER_RT_BUILD))
    message(FATAL_ERROR
      "To build profile runtime LLVM_TOOL_COMPILER_RT_BUILD must be set to ON.")
  endif()
  if (BUILD_FLANG)
    set(FLANG_FOUND ON)
  endif()
  set(TSAR_INCLUDE_PATH "lib/clang/${LLVM_VERSION}/include")
  add_custom_target(tsar-resource-headers ALL
    COMMAND ${CMAKE_COMMAND} -E copy_directory "$<TARGET_PROPERTY:clang-resource-headers,RUNTIME_OUTPUT_DIRECTORY>"
                                               "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/${TSAR_INCLUDE_PATH}"
    COMMENT "Copy header files to ${TSAR_INCLUDE_PATH}...")
  add_dependencies(tsar-resource-headers clang-resource-headers)
  set_target_properties(tsar-resource-headers PROPERTIES
    FOLDER Misc
    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/${TSAR_INCLUDE_PATH}")
  install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/${TSAR_INCLUDE_PATH}
    DESTINATION ${TSAR_INCLUDE_PATH}/.. FILES_MATCHING PATTERN *.h)
  set(CLANG_INCLUDE_DIR "${LLVM_BINARY_DIR}/$<CONFIG>/lib/clang/${LLVM_VERSION}/include")
  set(CLANG_EXECUTABLE "${LLVM_BINARY_DIR}/$<CONFIG>/bin/clang${CMAKE_EXECUTABLE_SUFFIX}")
  sapfor_install_llvm()
endif(PACKAGE_LLVM)

if(BUILD_TSAR)
  if("${LLVM_VERSION}" VERSION_LESS "${LLVM_MIN_VERSION}")
    message(FATAL_ERROR
      "To build TSAR at least LLVM ${LLVM_MIN_VERSION} is required.")
  endif()
else()
  return()
endif()

set(LLVM_STATUS
  "Specifying LLVM dependences (include directories, libraries, macros etc.)")
message(STATUS ${LLVM_STATUS})

set(LLVM_COMPONENTS
  analysis asmparser bitreader core instrumentation irreader scalaropts support
  tablegen target transformutils coverage mcparser option debuginfodwarf
  frontendopenacc)

llvm_map_components_to_libnames(LLVM_LIBS ${LLVM_COMPONENTS})

# Add targets to the list of necessary LLVM libraries (LLVM_LIBS).
llvm_map_components_to_libnames(LLVM_TARGETS_LIBS ${LLVM_TARGETS_TO_BUILD})
foreach(L ${LLVM_TARGETS_LIBS})
  string(TOLOWER ${L} TO_COMPARE)
  string(REGEX MATCH "(asmparser|info|codegen|desc)$" FIND_RES ${TO_COMPARE})
  if (FIND_RES)
    list(APPEND LLVM_LIBS "${L}")
  endif()
endforeach()

set(CLANG_LIBS
  clangTooling clangCodeGen clangFrontend clangDriver clangSerialization
  clangParse clangSema clangAnalysis clangRewrite clangEdit clangAST clangLex
  clangBasic clangASTMatchers clangFormat clangToolingCore clangToolingInclusions)

if(FLANG_FOUND)
  set(FLANG_LIBS
    FortranSemantics FortranEvaluate FortranParser FortranDecimal FortranCommon)
endif()

if(NOT PACKAGE_LLVM)
  list(APPEND LLVM_INCLUDE_DIRS
    ${CLANG_SOURCE_DIR}/include ${CLANG_BINARY_DIR}/include)
endif()
if(NOT PACKAGE_LLVM AND FLANG_FOUND)
  list(APPEND LLVM_INCLUDE_DIRS
    ${FLANG_SOURCE_DIR}/include ${FLANG_BINARY_DIR}/include)
endif()
include_directories(${LLVM_INCLUDE_DIRS})

if(PACKAGE_LLVM)
  list(APPEND CMAKE_MODULE_PATH ${LLVM_BINARY_DIR}/lib/cmake/llvm)
  include(AddLLVM)
  include(TableGen)
  link_directories(${LLVM_LIBRARY_DIRS})
endif()

add_definitions(${LLVM_DEFINITIONS})
message(STATUS "${LLVM_STATUS} - done")

# Set additional include directories and definitions
include_directories(
  ${CMAKE_CURRENT_SOURCE_DIR}/include
  ${CMAKE_CURRENT_BINARY_DIR})

if(NOT LLVM_ENABLE_RTTI)
  if(BCL_COMPILER_IS_GCC_COMPATIBLE)
    bcl_replace(CMAKE_CXX_FLAGS "-frtti" "-fno-rtti")
  elseif(MSVC)
    bcl_replace(CMAKE_CXX_FLAGS "/GR" "/GR-")
  endif()
endif()

if(DEFINED LLVM_BUILD_TYPE)
  if ("${LLVM_BUILD_TYPE}" STREQUAL Debug)
    set(LLVM_DEBUG_BUILD ${LLVM_BUILD_TYPE})
  elseif (NOT("${LLVM_BUILD_TYPE}" STREQUAL ""))
    set(LLVM_RELEASE_BUILD ${LLVM_BUILD_TYPE})
  endif()
endif()

# To avoid conflicts between linked library appropriate run-time library
# must be specified manually.
if (MSVC)
  option(LLVM_PACKAGE_DEBUG
   "LLVM package has debug build type (useful only if PACKAGE_LLVM is set)" OFF)
  if (PACKAGE_LLVM)
    if (LLVM_PACKAGE_DEBUG)
      set(LLVM_DEBUG_BUILD "\"\"")
      add_compile_options("/MDd")
    else()
      set(LLVM_RELEASE_BUILD "\"\"")
      add_compile_options("/MD")
    endif()
  endif()
endif()

foreach(C ${CMAKE_CONFIGURATION_TYPES})
  string(TOUPPER ${C} SUFFIX)
  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${SUFFIX} "${CMAKE_CURRENT_BINARY_DIR}/${C}/bin")
endforeach()
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")

add_subdirectory(utils/TableGen)
add_subdirectory(lib tsar)
add_subdirectory(tools)
add_subdirectory(test)

set_target_properties(${TSAR_TABLEGEN} PROPERTIES FOLDER "Tablegenning")

# Build Config-file Package configuration.
export(EXPORT TSARExports
  FILE ${CMAKE_CURRENT_BINARY_DIR}/TSARExports.cmake)
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
  "${CMAKE_CURRENT_BINARY_DIR}/TSARConfigVersion.cmake"
  COMPATIBILITY AnyNewerVersion)

get_property(TSAR_LLVM_TOOLS GLOBAL PROPERTY TSAR_LLVM_TOOLS)
set_property(GLOBAL APPEND PROPERTY PACKAGE_PREFIX_PATH ${CMAKE_CURRENT_BINARY_DIR})

set(TSAR_EXECUTABLE /bin/tsar${CMEAK_EXECUTABLE_SUFFIX})
if (TSAR_SERVER)
  set(TSAR_SERVER_EXECUTABLE /bin/tsar-server${CMEAK_EXECUTABLE_SUFFIX})
endif()

configure_file(cmake/TSARConfig.cmake.in
  ${CMAKE_CURRENT_BINARY_DIR}/TSARConfig.cmake @ONLY)

install(EXPORT TSARExports
  FILE TSARExports.cmake DESTINATION lib/cmake/tsar)
install(FILES
  ${CMAKE_CURRENT_BINARY_DIR}/TSARConfig.cmake
  ${CMAKE_CURRENT_BINARY_DIR}/TSARConfigVersion.cmake
  DESTINATION lib/cmake/tsar)