#!/usr/bin/cmake -P
## Copyright(c) 2017-2020, Intel Corporation
##
## Redistribution and use in source and binary forms, with or without
## modification, are permitted provided that the following conditions are met:
##
## * Redistributions of source code must retain the above copyright notice,
## this list of conditions and the following disclaimer.
## * Redistributions in binary form must reproduce the above copyright notice,
## this list of conditions and the following disclaimer in the documentation
## and/or other materials provided with the distribution.
## * Neither the name of Intel Corporation nor the names of its contributors
## may be used to endorse or promote products derived from this software
## without specific prior written permission.
##
## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
## AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
## IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
## ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
## LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
## CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
## SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
## INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
## CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
## ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
## POSSIBILITY OF SUCH DAMAGE.
include(CheckCCompilerFlag)
include(CheckCXXCompilerFlag)
if(NOT CMAKE_C_COMPILER)
message("-- No C compiler was found. Please install the gcc package for your distribution:
DEB: apt install gcc
RPM: yum install gcc")
endif()
if(NOT CMAKE_CXX_COMPILER)
message("-- No C++ compiler was found. Please install the g++ package for your distribution:
DEB: apt install g++
RPM: yum install gcc-c++")
endif()
set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
find_package(Threads)
############################################################################
## Set the default build type to Release with debug info. ##################
############################################################################
if(CMAKE_BUILD_TYPE STREQUAL "")
set(CMAKE_BUILD_TYPE RelWithDebInfo
CACHE STRING
"Type of build: {Debug Release RelWithDebInfo MinSizeRel Coverage}"
FORCE)
function(opae_coverage_build)
endfunction()
elseif(CMAKE_BUILD_TYPE STREQUAL "Coverage")
find_program(OPAE_GCOV_EXECUTABLE gcov)
if(NOT OPAE_GCOV_EXECUTABLE)
message(FATAL_ERROR "Coverage requested, but gcov not found. Aborting...")
endif()
find_program(OPAE_LCOV_EXECUTABLE lcov)
find_program(OPAE_GENHTML_EXECUTABLE genhtml)
# example:
# opae_coverage_build(TARGET opae-c SOURCE a.c b.c)
function(opae_coverage_build)
set(options )
set(oneValueArgs TARGET)
set(multiValueArgs SOURCE)
cmake_parse_arguments(OPAE_COVERAGE_BUILD "${options}"
"${oneValueArgs}" "${multiValueArgs}" ${ARGN})
set_property(SOURCE ${OPAE_COVERAGE_BUILD_SOURCE} APPEND_STRING PROPERTY COMPILE_FLAGS
" -g -O0 -Wall -Wextra -Werror -pthread --coverage -fprofile-arcs -ftest-coverage")
target_link_libraries(${OPAE_COVERAGE_BUILD_TARGET} "-lgcov")
endfunction()
else()
function(opae_coverage_build)
endfunction()
endif()
set(CMAKE_C_FLAGS_DEBUG "-g -O0 -Wall -Wextra -Werror -pthread")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -Wall -Wextra -Werror -pthread")
set(CMAKE_C_FLAGS_RELEASE "-O2 -Wall -Wextra -Werror -pthread")
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -Wall -Wextra -Werror -pthread")
set(CMAKE_C_FLAGS_RELWITHDEBINFO "-g -O2 -Wall -Wextra -Werror -pthread")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-g -O2 -Wall -Wextra -Werror -pthread")
set(CMAKE_C_FLAGS_MINSIZEREL "-Os -Wall -Wextra -Werror -pthread")
set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -Wall -Wextra -Werror -pthread")
############################################################################
## Enable defensive options for Release builds. ############################
############################################################################
if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
# C options
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wformat -Wformat-security")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -D_FORTIFY_SOURCE=2")
if(GCC_VERSION VERSION_GREATER 4.9 OR GCC_VERSION VERSION_EQUAL 4.9)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector-strong")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -z noexecstack -z relro -z now")
else()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector-all")
endif()
# C++ options
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat -Wformat-security")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -D_FORTIFY_SOURCE=2")
if(GCC_VERSION VERSION_GREATER 4.9 OR GCC_VERSION VERSION_EQUAL 4.9)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -z noexecstack -z relro -z now")
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-all")
endif()
# Linker options
if (NOT ${CMAKE_C_COMPILER} MATCHES "clang")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pie")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie")
endif()
endif()
# Check if support for C++ 11/14/0x is available
check_cxx_compiler_flag("-std=c++14" COMPILER_SUPPORTS_CXX14)
check_cxx_compiler_flag("-std=c++11" COMPILER_SUPPORTS_CXX11)
check_cxx_compiler_flag("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
if(COMPILER_SUPPORTS_CXX14)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
set(CMAKE_CXX_STANDARD 14)
elseif(COMPILER_SUPPORTS_CXX11)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
set(CMAKE_CXX_STANDARD 11)
elseif(COMPILER_SUPPORTS_CXX0X)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
endif()
# If building on a 32-bit system, make sure off_t can store offsets > 2GB.
if(CMAKE_COMPILER_IS_GNUCC)
if(CMAKE_SIZEOF_VOID_P EQUAL 4)
add_definitions(-D_LARGEFILE_SOURCE)
add_definitions(-D_FILE_OFFSET_BITS=64)
endif()
endif()
macro(set_install_rpath target_name)
if(OPAE_INSTALL_RPATH)
set_target_properties(${target_name} PROPERTIES
INSTALL_RPATH "\$ORIGIN/../${OPAE_LIB_INSTALL_DIR}"
INSTALL_RPATH_USE_LINK_PATH TRUE
SKIP_BUILD_RPATH FALSE
BUILD_WITH_INSTALL_RPATH FALSE)
endif()
endmacro()
function(opae_add_subdirectory directory_name)
get_filename_component(full_dir_path "${directory_name}" REALPATH)
if(EXISTS "${full_dir_path}" AND IS_DIRECTORY "${full_dir_path}" AND EXISTS "${full_dir_path}/CMakeLists.txt")
add_subdirectory(${directory_name})
else()
message("Directory or CMakeLists.txt not found: ${full_dir_path}")
endif()
endfunction()
# example:
# opae_add_executable(TARGET fpgaconf SOURCE a.c b.c LIBS opae-c)
function(opae_add_executable)
set(options )
set(oneValueArgs TARGET COMPONENT DESTINATION)
set(multiValueArgs SOURCE LIBS)
cmake_parse_arguments(OPAE_ADD_EXECUTABLE "${options}"
"${oneValueArgs}" "${multiValueArgs}" ${ARGN})
add_executable(${OPAE_ADD_EXECUTABLE_TARGET} ${OPAE_ADD_EXECUTABLE_SOURCE})
target_include_directories(${OPAE_ADD_EXECUTABLE_TARGET} PUBLIC
$<BUILD_INTERFACE:${OPAE_LIBS_ROOT}/include>
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE ${OPAE_LIBS_ROOT}
PUBLIC ${libjson-c_INCLUDE_DIRS}
PUBLIC ${libuuid_INCLUDE_DIRS})
set_property(TARGET ${OPAE_ADD_EXECUTABLE_TARGET} PROPERTY C_STANDARD 99)
target_compile_definitions(${OPAE_ADD_EXECUTABLE_TARGET}
PRIVATE
HAVE_CONFIG_H=1)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
target_compile_definitions(${OPAE_ADD_EXECUTABLE_TARGET}
PRIVATE
LIBOPAE_DEBUG=1)
endif()
target_link_libraries(${OPAE_ADD_EXECUTABLE_TARGET} ${OPAE_ADD_EXECUTABLE_LIBS})
opae_coverage_build(TARGET ${OPAE_ADD_EXECUTABLE_TARGET} SOURCE ${OPAE_ADD_EXECUTABLE_SOURCE})
set_install_rpath(${OPAE_ADD_EXECUTABLE_TARGET})
if(OPAE_ADD_EXECUTABLE_COMPONENT)
if(OPAE_ADD_EXECUTABLE_DESTINATION)
set(dest ${OPAE_ADD_EXECUTABLE_DESTINATION})
else(OPAE_ADD_EXECUTABLE_DESTINATION)
set(dest bin)
endif(OPAE_ADD_EXECUTABLE_DESTINATION)
install(TARGETS ${OPAE_ADD_EXECUTABLE_TARGET}
RUNTIME DESTINATION ${dest}
COMPONENT ${OPAE_ADD_EXECUTABLE_COMPONENT})
endif(OPAE_ADD_EXECUTABLE_COMPONENT)
endfunction()
# example:
# opae_add_shared_library(TARGET opae-c SOURCE a.c b.c LIBS dl)
function(opae_add_shared_library)
set(options )
set(oneValueArgs TARGET VERSION SOVERSION COMPONENT DESTINATION)
set(multiValueArgs SOURCE LIBS)
cmake_parse_arguments(OPAE_ADD_SHARED_LIBRARY "${options}"
"${oneValueArgs}" "${multiValueArgs}" ${ARGN})
add_library(${OPAE_ADD_SHARED_LIBRARY_TARGET} SHARED ${OPAE_ADD_SHARED_LIBRARY_SOURCE})
target_include_directories(${OPAE_ADD_SHARED_LIBRARY_TARGET} PUBLIC
$<BUILD_INTERFACE:${OPAE_LIBS_ROOT}/include>
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE ${OPAE_LIBS_ROOT}
PUBLIC ${libjson-c_INCLUDE_DIRS}
PUBLIC ${libuuid_INCLUDE_DIRS})
set_property(TARGET ${OPAE_ADD_SHARED_LIBRARY_TARGET} PROPERTY C_STANDARD 99)
target_compile_definitions(${OPAE_ADD_SHARED_LIBRARY_TARGET}
PRIVATE
HAVE_CONFIG_H=1)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
target_compile_definitions(${OPAE_ADD_SHARED_LIBRARY_TARGET}
PRIVATE
LIBOPAE_DEBUG=1)
endif()
if(OPAE_ADD_SHARED_LIBRARY_VERSION AND OPAE_ADD_SHARED_LIBRARY_SOVERSION)
set_target_properties(${OPAE_ADD_SHARED_LIBRARY_TARGET} PROPERTIES
VERSION ${OPAE_ADD_SHARED_LIBRARY_VERSION}
SOVERSION ${OPAE_ADD_SHARED_LIBRARY_SOVERSION})
endif()
target_link_libraries(${OPAE_ADD_SHARED_LIBRARY_TARGET} ${OPAE_ADD_SHARED_LIBRARY_LIBS})
opae_coverage_build(TARGET ${OPAE_ADD_SHARED_LIBRARY_TARGET} SOURCE ${OPAE_ADD_SHARED_LIBRARY_SOURCE})
set_install_rpath(${OPAE_ADD_SHARED_LIBRARY_TARGET})
if(OPAE_ADD_SHARED_LIBRARY_COMPONENT)
if(OPAE_ADD_SHARED_LIBRARY_DESTINATION)
set(dest ${OPAE_ADD_SHARED_LIBRARY_DESTINATION})
else(OPAE_ADD_SHARED_LIBRARY_DESTINATION)
set(dest ${OPAE_LIB_INSTALL_DIR})
endif(OPAE_ADD_SHARED_LIBRARY_DESTINATION)
install(TARGETS ${OPAE_ADD_SHARED_LIBRARY_TARGET}
LIBRARY DESTINATION ${dest}
COMPONENT ${OPAE_ADD_SHARED_LIBRARY_COMPONENT})
endif(OPAE_ADD_SHARED_LIBRARY_COMPONENT)
endfunction()
# example:
# opae_add_module_library(TARGET xfpga SOURCE a.c b.c LIBS opae-c)
function(opae_add_module_library)
set(options )
set(oneValueArgs TARGET COMPONENT DESTINATION)
set(multiValueArgs SOURCE LIBS)
cmake_parse_arguments(OPAE_ADD_MODULE_LIBRARY "${options}"
"${oneValueArgs}" "${multiValueArgs}" ${ARGN})
add_library(${OPAE_ADD_MODULE_LIBRARY_TARGET} MODULE ${OPAE_ADD_MODULE_LIBRARY_SOURCE})
target_include_directories(${OPAE_ADD_MODULE_LIBRARY_TARGET} PUBLIC
$<BUILD_INTERFACE:${OPAE_LIBS_ROOT}/include>
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
PRIVATE ${OPAE_LIBS_ROOT}
PUBLIC ${libjson-c_INCLUDE_DIRS}
PUBLIC ${libuuid_INCLUDE_DIRS})
set_property(TARGET ${OPAE_ADD_MODULE_LIBRARY_TARGET} PROPERTY C_STANDARD 99)
target_compile_definitions(${OPAE_ADD_MODULE_LIBRARY_TARGET}
PRIVATE
HAVE_CONFIG_H=1)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
target_compile_definitions(${OPAE_ADD_MODULE_LIBRARY_TARGET}
PRIVATE
LIBOPAE_DEBUG=1)
endif()
target_link_libraries(${OPAE_ADD_MODULE_LIBRARY_TARGET} ${OPAE_ADD_MODULE_LIBRARY_LIBS})
opae_coverage_build(TARGET ${OPAE_ADD_MODULE_LIBRARY_TARGET} SOURCE ${OPAE_ADD_MODULE_LIBRARY_SOURCE})
if(OPAE_ADD_MODULE_LIBRARY_COMPONENT)
if(OPAE_ADD_MODULE_LIBRARY_DESTINATION)
set(dest ${OPAE_ADD_MODULE_LIBRARY_DESTINATION})
else(OPAE_ADD_MODULE_LIBRARY_DESTINATION)
set(dest ${OPAE_LIB_INSTALL_DIR}/opae)
endif(OPAE_ADD_MODULE_LIBRARY_DESTINATION)
install(TARGETS ${OPAE_ADD_MODULE_LIBRARY_TARGET}
LIBRARY DESTINATION ${dest}
COMPONENT ${OPAE_ADD_MODULE_LIBRARY_COMPONENT})
endif(OPAE_ADD_MODULE_LIBRARY_COMPONENT)
endfunction()
# example:
# opae_add_static_library(TARGET sometarget SOURCE ${SRC})
function(opae_add_static_library)
set(options )
set(oneValueArgs TARGET COMPONENT DESTINATION)
set(multiValueArgs SOURCE LIBS)
cmake_parse_arguments(OPAE_ADD_STATIC_LIBRARY "${options}"
"${oneValueArgs}" "${multiValueArgs}" ${ARGN})
add_library(${OPAE_ADD_STATIC_LIBRARY_TARGET} STATIC ${OPAE_ADD_STATIC_LIBRARY_SOURCE})
target_include_directories(${OPAE_ADD_STATIC_LIBRARY_TARGET} PUBLIC
$<BUILD_INTERFACE:${OPAE_LIBS_ROOT}/include>
$<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
set_property(TARGET ${OPAE_ADD_STATIC_LIBRARY_TARGET} PROPERTY C_STANDARD 99)
set_property(TARGET ${OPAE_ADD_STATIC_LIBRARY_TARGET}
PROPERTY
POSITION_INDEPENDENT_CODE ON)
target_compile_definitions(${OPAE_ADD_STATIC_LIBRARY_TARGET}
PRIVATE
PIC=1
HAVE_CONFIG_H=1)
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
target_compile_definitions(${OPAE_ADD_STATIC_LIBRARY_TARGET}
PRIVATE
LIBOPAE_DEBUG=1)
endif()
target_link_libraries(${OPAE_ADD_STATIC_LIBRARY_TARGET}
${OPAE_ADD_STATIC_LIBRARY_LIBS})
opae_coverage_build(TARGET ${OPAE_ADD_STATIC_LIBRARY_TARGET} SOURCE ${OPAE_ADD_STATIC_LIBRARY_SOURCE})
endfunction()