CMakeLists.txt

# Copyright (C) 2019-2020 IBM Corp.
#
# This program is Licensed under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#   http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License. See accompanying LICENSE file.

# Enforce CMake v3.20 on MacOS else set minimum to v3.16
if (APPLE)
  cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
else ()
  cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
endif ()

project(helib_superbuild LANGUAGES C CXX)

# STRINGS avoids having the 2 newline characters at the end of the string.
# Alternatively it's possible to use file(READ ...) and then
# string(REGEX REPLACE "\n$" "" HELIB_VERSION "${HELIB_VERSION}")
file(STRINGS "${PROJECT_SOURCE_DIR}/VERSION" HELIB_VERSION)

# Fail if the target architecture is not 64-bit.
if (NOT (CMAKE_SIZEOF_VOID_P EQUAL 8))
  message(FATAL_ERROR "HElib requires a 64-bit architecture.")
endif ()

# Use -std=c++17 as default.
set(CMAKE_CXX_STANDARD 17)
# Disable C++ extensions
set(CMAKE_CXX_EXTENSIONS OFF)
# Require full C++ standard
set(CMAKE_CXX_STANDARD_REQUIRED ON)

################################################################################
#                                                                              #
#                             FOLDER DEFINITIONS                               #
#                                                                              #
################################################################################

# Define standard installation directories (GNU)
include(GNUInstallDirs)

# Setting compiler output directories
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY
    ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR})

# Location of the root folder of HElib (the one where this file is)
set(HELIB_PROJECT_ROOT_DIR "${PROJECT_SOURCE_DIR}")
# Location of the cmake extra files
set(HELIB_CMAKE_EXTRA_DIR "${PROJECT_SOURCE_DIR}/cmake")
# Prefix of the header files (directory to be added to the include list)
set(HELIB_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/include")
# Location of helib header files
set(HELIB_HEADER_DIR "${HELIB_INCLUDE_DIR}/helib")
# Location of the source files
set(HELIB_SOURCE_DIR "${PROJECT_SOURCE_DIR}/src")
# Location of the google tests
set(HELIB_TESTS_DIR "${PROJECT_SOURCE_DIR}/tests")
# Location of the dependencies
set(HELIB_DEPENDENCIES_DIR "${PROJECT_SOURCE_DIR}/dependencies")
# Location of the directory containing the test binary (runTests). If
# PACKAGE_BUILD=ON, this location will be changed to reflect the tests location.
set(HELIB_TEST_BIN_DIR "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}")

# GMP minimal version to be used if not PACKAGE_BUILD
set(GMP_MINIMAL_VERSION "6.2.0")
# NTL minimal version to be used if NOT PACKAGE_BUILD
set(NTL_MINIMAL_VERSION "11.4.3")

# The -isysroot flag needs set.
if ((APPLE OR (CMAKE_CXX_PLATFORM_ID STREQUAL "Darwin")) AND
    # This addresses the problem when CMAKE_OSX_SYSROOT is "" (e.g. when /usr/include/sys/types.h exists)
    NOT CMAKE_OSX_SYSROOT STREQUAL "")
  set(macos_isysroot_flag "-isysroot ${CMAKE_OSX_SYSROOT}")
else()
  set(macos_isysroot_flag "")
endif()

# Setting up RelWithDebInfo as default CMAKE_BUILD_TYPE
if (NOT CMAKE_BUILD_TYPE)
  # Setting RelWithDebInfo as it will compile with -O2 -g
  set(CMAKE_BUILD_TYPE RelWithDebInfo
      CACHE
      STRING "Choose the type of build, options are: Debug RelWithDebInfo Release MinSizeRel"
      FORCE)

endif (NOT CMAKE_BUILD_TYPE)

# Adding possible gui values to CMAKE_BUILD_TYPE variable
set_property(CACHE
             CMAKE_BUILD_TYPE
             PROPERTY
             STRINGS "Debug" "RelWithDebInfo" "Release" "MinSizeRel")

# Creating and documenting TARGET_ARCHITECTURE cmake property
set(TARGET_ARCHITECTURE "${TARGET_ARCHITECTURE}"
    CACHE
    STRING "Target architecture used for -march (default is native)")
# If TARGET_ARCHITECTURE is not set use default
if (NOT TARGET_ARCHITECTURE)
  set(TARGET_ARCHITECTURE "native"
      CACHE
      STRING "Target architecture used for -march (default is native)"
      FORCE)
endif (NOT TARGET_ARCHITECTURE)

set(HELIB_SP_NBITS "0" 
    CACHE 
    STRING "Override the bitsize for the ciphertext primes used")
if (NOT HELIB_SP_NBITS EQUAL 0)
  # Now check within bounds. NB. zero is special value to not override
  if (HELIB_SP_NBITS LESS 1 OR HELIB_SP_NBITS GREATER 64)
    message(FATAL_ERROR "HELIB_SP_NBITS must be in range [1, 64].")
  endif()
  add_compile_definitions(HELIB_SP_NBITS=${HELIB_SP_NBITS})
endif()

# Path containing FindGMP.cmake and FindNTL.cmake
list(APPEND CMAKE_MODULE_PATH "${HELIB_CMAKE_EXTRA_DIR}")

option(BUILD_SHARED "Build as shared library" OFF)

option(PACKAGE_BUILD
       "Download dependencies and build as a self-contained package"
       OFF)

option(ENABLE_THREADS
       "Enable threads support.  Requires NTL built with NTL_THREADS=on"
       ON)

option(HELIB_DEBUG
       "Build with HELIB_DEBUG (enables extra debugging info, but needs to be initialized)"
       OFF)
option(ENABLE_TEST "Enable tests" OFF)
option(USE_INTEL_HEXL "Use Intel HEXL library" OFF)
option(PEDANTIC_BUILD "Use -Wall -Wpedantic -Wextra -Werror during build" ON)

# Add properties dependent to PACKAGE_BUILD
if (PACKAGE_BUILD)
  # Properties to be enabled when using PACKAGE_BUILD
  set(PACKAGE_DIR
      ""
      CACHE
      STRING "Folder with the compilation output directory (DEFAULT: helib_pack)")

  option(FETCH_GMP "Fetch and compile the GMP library (DEFAULT: ON)" ON)
else (PACKAGE_BUILD)
  # Properties to be enabled when not using PACKAGE_BUILD
endif (PACKAGE_BUILD)

# Allow GMP_DIR and search in it if not using PACKAGE_BUILD or using
# PACKAGE_BUILD and !FETCH_GMP
if ((NOT PACKAGE_BUILD) OR NOT FETCH_GMP)
  set(GMP_DIR
      ""
      CACHE
      STRING "Prefix of the GMP library (ignored when PACKAGE_BUILD is ON)")
endif ((NOT PACKAGE_BUILD) OR NOT FETCH_GMP)

# Allow NTL_DIR only if not PACKAGE_BUILD
if (NOT PACKAGE_BUILD)
  set(NTL_DIR
      ""
      CACHE
      STRING "Prefix of the NTL library (ignored when PACKAGE_BUILD is ON)")
endif (NOT PACKAGE_BUILD)

# Setting flag lists to avoid polluting CMAKE_CXX_FLAGS.
# PUBLIC_HELIB_CXX_FLAGS will be exported to the installed target.
set(PRIVATE_HELIB_CXX_FLAGS "-march=${TARGET_ARCHITECTURE}")
set(PUBLIC_HELIB_CXX_FLAGS "")
# Add extra checks during build
if (PEDANTIC_BUILD)
  list(APPEND PRIVATE_HELIB_CXX_FLAGS "-Wall" "-Wpedantic" "-Wextra" "-Werror")
endif (PEDANTIC_BUILD)

if (ENABLE_TEST)
  enable_testing()
endif (ENABLE_TEST)

# Look for pthread using default FindThreads.cmake script
find_package(Threads)
if (ENABLE_THREADS AND Threads_NOTFOUND)
  message(FATAL_ERROR "Cannot find pthreads (ENABLE_THREADS is ON).")
endif ()

# Build optional Intel HEXL library
if(USE_INTEL_HEXL)
  # HEXL currently only supported using Library Build
  if(PACKAGE_BUILD)
    message(FATAL_ERROR "Intel HEXL currently not supported with Package "
      "Build. Please use the Library Build when enabling Intel HEXL.")
  endif(PACKAGE_BUILD)

  if(HEXL_DIR)
    set(HEXL_DIR
        ""
        CACHE
        STRING "Set location of HEXL cmake data for linking."
        )
    set(INIT_HEXL_DIR ${HEXL_DIR})
  endif()

  # Set minimum version of HEXL
  set(HEXL_MIN_VERSION 1.2.1)

  find_package(HEXL HINTS ${HEXL_DIR} REQUIRED)

  # Check the version found is greater than the minimum
  if(HEXL_MIN_VERSION VERSION_GREATER HEXL_VERSION)
    message(FATAL_ERROR "Minimum Intel HEXL version required is ${HEXL_MIN_VERSION}, found ${HEXL_VERSION}")
  else()
    message(STATUS "Intel HEXL Version: ${HEXL_VERSION} found (minimum required is ${HEXL_MIN_VERSION})")
  endif()

  if(INIT_HEXL_DIR AND NOT INIT_HEXL_DIR STREQUAL HEXL_DIR)
    message(WARNING "HEXL location provided '${INIT_HEXL_DIR}' \
            does not equal chosen '${HEXL_DIR}'.")
  endif()
  include_directories(${HEXL_INCLUDE_DIRS})
  add_compile_definitions(USE_INTEL_HEXL)
endif(USE_INTEL_HEXL)

# NOTE: Consider reconfiguring everything when PACKAGE_BUILD changes value.
# Options from the previous value will remain otherwise.
# Set up extra properties depending on the value of PACKAGE_BUILD
if (PACKAGE_BUILD)
  # Setting up dependencies versions
  # GMP version to be used (and eventually downloaded) if PACKAGE_BUILD
  set(FETCHED_GMP_VERSION "6.2.1")
  # NTL version to be used (and eventually downloaded) if PACKAGE_BUILD
  set(FETCHED_NTL_VERSION "11.5.1")
  # Setting up default compilation output directory
  if (NOT PACKAGE_DIR)
    set(PACKAGE_DIR "helib_pack")
  endif (NOT PACKAGE_DIR)
  if (NOT IS_ABSOLUTE ${PACKAGE_DIR})
    # Make CMAKE_PACKAGE_DIR absolute
    set(PACKAGE_DIR
        "${CMAKE_BINARY_DIR}/${PACKAGE_DIR}"
        CACHE
        STRING "Folder with the compilation output directory (DEFAULT: helib_pack)"
        FORCE)
  endif ()

  # Setting up download/build path of external dependencies
  set(DEPENDENCIES_FOLDER "${CMAKE_BINARY_DIR}/dependencies")
  set_property(DIRECTORY PROPERTY EP_BASE "${DEPENDENCIES_FOLDER}")

  # Raising warning when PACKAGE_BUILD is ON
  # warn if installing globally
  # NOTE: this is a somewhat fragile check that can be enhanced
  string(FIND "${CMAKE_INSTALL_PREFIX}" "/usr" install_in_usr)
  if ("${install_in_usr}" EQUAL 0)
    message(WARNING
            "CAUTION: Package build should not be installed globally as it will potentially override dependencies.")
  endif ()
  unset(install_in_usr)

  # Warn existing dependencies are ignored and rebuilt
  if (GMP_DIR)
    if (FETCH_GMP)
      message(WARNING "GMP_DIR is ignored when PACKAGE_BUILD is ON.")
    else (FETCH_GMP)
      message(STATUS
              "GMP_DIR is not the system one.  This may prevent relocatability of the package.")
    endif (FETCH_GMP)
  endif (GMP_DIR)

  if (NTL_DIR)
    message(WARNING "NTL_DIR is ignored when PACKAGE_BUILD is ON.")
  endif (NTL_DIR)

  # Add an imported target to propagate the library locations
  add_library(gmp_external SHARED IMPORTED)
  add_library(ntl_external SHARED IMPORTED)

  # RPATH will be empty since ntl, gmp, and helib are all in PACKAGE_DIR/lib
  set(PACKAGE_RPATH "")

  if (NOT FETCH_GMP)
    # find GMP library
    # Try to find the GMP package (using cmake/FindGMP.cmake script)
    # REQUIRED arg make cmake to fail if GMP is not found
    # Checks that at least version GMP_MINIMAL_VERSION is available
    find_package(GMP "${GMP_MINIMAL_VERSION}" REQUIRED)
    set_target_properties(gmp_external
                          PROPERTIES
                          INTERFACE_INCLUDE_DIRECTORIES "${GMP_INCLUDE_PATHS}"
                          IMPORTED_LOCATION "${GMP_LIBRARIES}")
  endif (NOT FETCH_GMP)

  # Add the external dependencies (done in dependencies/CMakeLists.txt)
  add_subdirectory(dependencies)

  # get gmp and ntl include/link directories
  get_target_property(GMP_INCLUDE_PATHS
                      gmp_external
                      INTERFACE_INCLUDE_DIRECTORIES)
  get_target_property(GMP_LIBRARIES gmp_external IMPORTED_LOCATION)
  get_target_property(NTL_INCLUDE_PATHS
                      ntl_external
                      INTERFACE_INCLUDE_DIRECTORIES)
  get_target_property(NTL_LIBRARIES ntl_external IMPORTED_LOCATION)

  # Track if helib requires pthreads as dependency
  set(HELIB_REQUIRES_PTHREADS ${ENABLE_THREADS})
else (PACKAGE_BUILD)
  # find GMP library
  # Try to find the GMP package (using cmake/FindGMP.cmake script)
  # REQUIRED arg make cmake to fail if GMP is not found
  # Checks that at least version GMP_MINIMAL_VERSION is available
  find_package(GMP "${GMP_MINIMAL_VERSION}" REQUIRED)

  # find NTL library
  # Try to find the NTL package (using cmake/FindNTL.cmake script)
  # REQUIRED arg make cmake to fail if NTL is not found
  # Checks that at least version NTL_MINIMAL_VERSION is available
  find_package(NTL "${NTL_MINIMAL_VERSION}" REQUIRED)

  # Thread enabling checks
  # Checking if NTL is built with NTL_THREADS=on
  set(ntl_config_file "${NTL_INCLUDE_PATHS}/NTL/config.h")
  if (EXISTS "${ntl_config_file}")
    include(CheckCXXSymbolExists)
    check_cxx_symbol_exists("NTL_THREADS" "${ntl_config_file}" ntl_has_threads)
  else ()
    message(
      FATAL_ERROR "Cannot locate NTL configuration file (${ntl_config_file}).")
  endif ()

  # Raising errors when threads are misconfigured
  if (ENABLE_THREADS AND NOT ntl_has_threads)
    message(FATAL_ERROR
            "Cannot enable threads since NTL was built without.  Consider re-building NTL with NTL_THREADS=on.")
  endif (ENABLE_THREADS AND NOT ntl_has_threads)

  # This should not really happen
  if (ntl_has_threads AND Threads_NOTFOUND)
    message(FATAL_ERROR "NTL requires pthreads that has not been found.")
  endif (ntl_has_threads AND Threads_NOTFOUND)

  # Track if helib requires pthreads as dependency
  set(HELIB_REQUIRES_PTHREADS ${ntl_has_threads})

  unset(ntl_config_file)
  unset(ntl_has_threads)
endif (PACKAGE_BUILD)

# Building HELIB here
if (PACKAGE_BUILD)
  # Adding HELIB as an external project
  include(ExternalProject)

  # Before building helib_external wait compilation of gmp and ntl.
  list(APPEND helib_external_deps "gmp_external" "ntl_external")

  ExternalProject_Add(
    helib_external
    DEPENDS # await compilation of gmp and ntl
            gmp_external ntl_external
    SOURCE_DIR ${CMAKE_SOURCE_DIR}/src
    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PACKAGE_DIR}
               -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
               -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
               -DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}
               -DCMAKE_CXX_STANDARD_REQUIRED=${CMAKE_CXX_STANDARD_REQUIRED}
               -DCMAKE_CXX_EXTENSIONS=${CMAKE_CXX_EXTENSIONS}
               -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
               -DPRIVATE_HELIB_CXX_FLAGS=${PRIVATE_HELIB_CXX_FLAGS}
               -DPUBLIC_HELIB_CXX_FLAGS=${PUBLIC_HELIB_CXX_FLAGS}
               -DGMP_LIBRARIES=${GMP_LIBRARIES}
               -DNTL_INCLUDE_PATHS=${NTL_INCLUDE_PATHS}
               -DNTL_LIBRARIES=${NTL_LIBRARIES}
               -DENABLE_THREADS=${ENABLE_THREADS}
               -DHELIB_REQUIRES_PTHREADS=${HELIB_REQUIRES_PTHREADS}
               -DBUILD_SHARED=${BUILD_SHARED}
               -DPACKAGE_BUILD=${PACKAGE_BUILD}
               -DFETCH_GMP=${FETCH_GMP}
               -DENABLE_TEST=${ENABLE_TEST}
               -DHELIB_DEBUG=${HELIB_DEBUG}
               -DUSE_INTEL_HEXL=${USE_INTEL_HEXL}
               -DHELIB_PROJECT_ROOT_DIR=${HELIB_PROJECT_ROOT_DIR}
               -DHELIB_CMAKE_EXTRA_DIR=${HELIB_CMAKE_EXTRA_DIR}
               -DHELIB_INCLUDE_DIR=${HELIB_INCLUDE_DIR}
               -DHELIB_HEADER_DIR=${HELIB_HEADER_DIR}
               -DHELIB_SOURCE_DIR=${HELIB_SOURCE_DIR}
               -DHELIB_TESTS_DIR=${HELIB_TESTS_DIR}
               -DHELIB_DEPENDENCIES_DIR=${HELIB_DEPENDENCIES_DIR}
               -DHELIB_VERSION=${HELIB_VERSION}
    BUILD_ALWAYS ON)

    if (ENABLE_TEST)
      # Tests for PACKAGE_BUILD are located in
      # ${DEPENDENCIES_FOLDER}/Build/helib_external/${CMAKE_INSTALL_BINDIR}.
      # Update its location and add the tests to cmake to avoid re-creating
      # their targets (as they are already built by ExternalProject_Add)
      set(HELIB_TEST_BIN_DIR
          "${DEPENDENCIES_FOLDER}/Build/helib_external/${CMAKE_INSTALL_BINDIR}")
      set(ONLY_ADD_TEST ON)
      add_subdirectory("${HELIB_TESTS_DIR}" tests)
      unset(ONLY_ADD_TEST)
    endif (ENABLE_TEST)

  # To install copy the whole PACKAGE_DIR directory to the defined prefix
  install(
    DIRECTORY ${PACKAGE_DIR}
    DESTINATION
      # this is interpreted relative to the value of CMAKE_INSTALL_PREFIX
      .
    USE_SOURCE_PERMISSIONS)
else (PACKAGE_BUILD)
  # If not compiling as PACKAGE_BUILD then add helib as subfolder and not as an
  # external project
  add_subdirectory(src)
endif (PACKAGE_BUILD)