wehub-resource-sync
480 lines
17 KiB
CMake
480 lines
17 KiB
CMake
include(${PROJECT_SOURCE_DIR}/cmake/architecture.cmake)
|
|
|
|
paddle_normalize_target_arch(CINN_HOST_ARCH)
|
|
set(CINN_X86_CXX_FLAGS "")
|
|
if(CINN_HOST_ARCH STREQUAL "x86_64")
|
|
set(CINN_X86_CXX_FLAGS " -mavx -mfma")
|
|
endif()
|
|
|
|
set(CMAKE_CXX_FLAGS
|
|
"${CMAKE_CXX_FLAGS} -fPIC${CINN_X86_CXX_FLAGS} -Wno-write-strings -Wno-psabi"
|
|
)
|
|
|
|
set(PADDLE_RESOURCE_URL
|
|
"http://paddle-inference-dist.bj.bcebos.com"
|
|
CACHE STRING "inference download url")
|
|
|
|
function(cinn_cc_library TARGET_NAME)
|
|
set(options STATIC static SHARED shared)
|
|
set(oneValueArgs "")
|
|
set(multiValueArgs SRCS DEPS)
|
|
cmake_parse_arguments(cinn_cc_library "${options}" "${oneValueArgs}"
|
|
"${multiValueArgs}" ${ARGN})
|
|
if(cinn_cc_library_SRCS)
|
|
if(cinn_cc_library_SHARED OR cinn_cc_library_shared) # build *.so
|
|
add_library(${TARGET_NAME} SHARED ${cinn_cc_library_SRCS})
|
|
else()
|
|
add_library(${TARGET_NAME} STATIC ${cinn_cc_library_SRCS})
|
|
endif()
|
|
|
|
if(cinn_cc_library_DEPS)
|
|
target_link_libraries(${TARGET_NAME} ${cinn_cc_library_DEPS})
|
|
add_dependencies(${TARGET_NAME} ${cinn_cc_library_DEPS})
|
|
endif()
|
|
|
|
# cpplint code style
|
|
foreach(source_file ${cinn_cc_library_SRCS})
|
|
string(REGEX REPLACE "\\.[^.]*$" "" source ${source_file})
|
|
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
|
|
list(APPEND cinn_cc_library_HEADERS
|
|
${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
|
|
endif()
|
|
endforeach()
|
|
else()
|
|
if(cinn_cc_library_DEPS)
|
|
cinn_merge_static_libs(${TARGET_NAME} ${cinn_cc_library_DEPS})
|
|
else()
|
|
message(
|
|
FATAL_ERROR
|
|
"Please specify source files or libraries in cinn_cc_library(${TARGET_NAME} ...)."
|
|
)
|
|
endif()
|
|
endif()
|
|
|
|
if((NOT ("${TARGET_NAME}" STREQUAL "cinn_gtest_main"))
|
|
AND (NOT ("${TARGET_NAME}" STREQUAL "utils"))
|
|
AND (NOT ("${TARGET_NAME}" STREQUAL "lib")))
|
|
target_link_libraries(${TARGET_NAME} Threads::Threads)
|
|
|
|
endif(
|
|
(NOT ("${TARGET_NAME}" STREQUAL "cinn_gtest_main"))
|
|
AND (NOT ("${TARGET_NAME}" STREQUAL "utils"))
|
|
AND (NOT ("${TARGET_NAME}" STREQUAL "lib")))
|
|
endfunction()
|
|
|
|
list(APPEND CMAKE_CTEST_ARGUMENTS)
|
|
|
|
function(remove_gflags TARGET_NAME)
|
|
get_target_property(TARGET_LIBRARIES ${TARGET_NAME} LINK_LIBRARIES)
|
|
list(REMOVE_ITEM TARGET_LIBRARIES glog)
|
|
list(REMOVE_ITEM TARGET_LIBRARIES gflags)
|
|
set_property(TARGET ${TARGET_NAME} PROPERTY LINK_LIBRARIES
|
|
${TARGET_LIBRARIES})
|
|
endfunction()
|
|
|
|
function(cinn_cc_test TARGET_NAME)
|
|
if(WITH_TESTING)
|
|
set(options SERIAL)
|
|
set(oneValueArgs "")
|
|
set(multiValueArgs SRCS DEPS ARGS)
|
|
cmake_parse_arguments(cinn_cc_test "${options}" "${oneValueArgs}"
|
|
"${multiValueArgs}" ${ARGN})
|
|
add_executable(${TARGET_NAME} ${cinn_cc_test_SRCS})
|
|
get_property(os_dependency_modules GLOBAL PROPERTY OS_DEPENDENCY_MODULES)
|
|
target_link_libraries(${TARGET_NAME} ${os_dependency_modules}
|
|
paddle_gtest_main gtest glog ${cinn_cc_test_DEPS})
|
|
if(WITH_SHARED_PHI)
|
|
target_link_libraries(${TARGET_NAME} -Wl,--as-needed phi_core phi_gpu
|
|
-Wl,--no-as-needed)
|
|
endif()
|
|
add_dependencies(${TARGET_NAME} paddle_gtest_main gtest glog
|
|
${cinn_cc_test_DEPS})
|
|
|
|
add_test(
|
|
NAME ${TARGET_NAME}
|
|
COMMAND ${TARGET_NAME} "${cinn_cc_test_ARGS}"
|
|
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
|
|
if(${cinn_cc_test_SERIAL})
|
|
set_property(TEST ${TARGET_NAME} PROPERTY RUN_SERIAL 1)
|
|
endif()
|
|
# No unit test should exceed 10 minutes.
|
|
set_tests_properties(${TARGET_NAME} PROPERTIES TIMEOUT 6000)
|
|
remove_gflags(${TARGET_NAME})
|
|
endif()
|
|
endfunction()
|
|
|
|
function(cinn_nv_library TARGET_NAME)
|
|
if(WITH_GPU)
|
|
set(options STATIC static SHARED shared)
|
|
set(oneValueArgs "")
|
|
set(multiValueArgs SRCS DEPS)
|
|
cmake_parse_arguments(cinn_nv_library "${options}" "${oneValueArgs}"
|
|
"${multiValueArgs}" ${ARGN})
|
|
if(cinn_nv_library_SRCS)
|
|
if(cinn_nv_library_SHARED OR cinn_nv_library_shared) # build *.so
|
|
cuda_add_library(${TARGET_NAME} SHARED ${cinn_nv_library_SRCS})
|
|
else()
|
|
cuda_add_library(${TARGET_NAME} STATIC ${cinn_nv_library_SRCS})
|
|
endif()
|
|
if(cinn_nv_library_DEPS)
|
|
add_dependencies(${TARGET_NAME} ${cinn_nv_library_DEPS})
|
|
target_link_libraries(${TARGET_NAME} ${cinn_nv_library_DEPS})
|
|
endif()
|
|
# cpplint code style
|
|
foreach(source_file ${cinn_nv_library_SRCS})
|
|
string(REGEX REPLACE "\\.[^.]*$" "" source ${source_file})
|
|
if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
|
|
list(APPEND cinn_nv_library_HEADERS
|
|
${CMAKE_CURRENT_SOURCE_DIR}/${source}.h)
|
|
endif()
|
|
endforeach()
|
|
else()
|
|
if(cinn_nv_library_DEPS)
|
|
cinn_merge_static_libs(${TARGET_NAME} ${cinn_nv_library_DEPS})
|
|
else()
|
|
message(FATAL
|
|
"Please specify source file or library in cinn_nv_library.")
|
|
endif()
|
|
endif()
|
|
target_link_libraries(${TARGET_NAME} Threads::Threads)
|
|
endif()
|
|
endfunction()
|
|
|
|
function(cinn_nv_binary TARGET_NAME)
|
|
if(WITH_GPU)
|
|
set(options "")
|
|
set(oneValueArgs "")
|
|
set(multiValueArgs SRCS DEPS)
|
|
cmake_parse_arguments(cinn_nv_binary "${options}" "${oneValueArgs}"
|
|
"${multiValueArgs}" ${ARGN})
|
|
add_executable(${TARGET_NAME} ${cinn_nv_binary_SRCS})
|
|
if(cinn_nv_binary_DEPS)
|
|
target_link_libraries(${TARGET_NAME} ${cinn_nv_binary_DEPS})
|
|
add_dependencies(${TARGET_NAME} ${cinn_nv_binary_DEPS})
|
|
common_link(${TARGET_NAME})
|
|
endif()
|
|
endif()
|
|
endfunction()
|
|
|
|
function(cinn_nv_test TARGET_NAME)
|
|
if(WITH_GPU AND WITH_TESTING)
|
|
set(options SERIAL)
|
|
set(oneValueArgs "")
|
|
set(multiValueArgs SRCS DEPS ARGS)
|
|
cmake_parse_arguments(cinn_nv_test "${options}" "${oneValueArgs}"
|
|
"${multiValueArgs}" ${ARGN})
|
|
# Attention:
|
|
# 1. cuda_add_executable is deprecated after cmake v3.10, use add_executable for CUDA please.
|
|
# 2. cuda_add_executable does not support ccache.
|
|
# Reference: https://cmake.org/cmake/help/v3.10/module/FindCUDA.html
|
|
add_executable(${TARGET_NAME} ${cinn_nv_test_SRCS})
|
|
get_property(os_dependency_modules GLOBAL PROPERTY OS_DEPENDENCY_MODULES)
|
|
target_link_libraries(
|
|
${TARGET_NAME}
|
|
${cinn_nv_test_DEPS}
|
|
paddle_gtest_main
|
|
gtest
|
|
${os_dependency_modules}
|
|
${CUDNN_LIBRARY}
|
|
${CUBLAS_LIBRARIES}
|
|
${CUDA_LIBRARIES})
|
|
if(WITH_SHARED_PHI)
|
|
target_link_libraries(${TARGET_NAME} -Wl,--as-needed phi_core phi_gpu
|
|
-Wl,--no-as-needed)
|
|
endif()
|
|
add_dependencies(${TARGET_NAME} ${cinn_nv_test_DEPS} paddle_gtest_main
|
|
gtest)
|
|
common_link(${TARGET_NAME})
|
|
add_test(
|
|
NAME ${TARGET_NAME}
|
|
COMMAND ${TARGET_NAME} "${cinn_nv_test_ARGS}"
|
|
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
|
|
if(cinn_nv_test_SERIAL)
|
|
set_property(TEST ${TARGET_NAME} PROPERTY RUN_SERIAL 1)
|
|
endif()
|
|
target_link_libraries(
|
|
${TARGET_NAME} Threads::Threads ${CUDA_NVRTC_LIB} ${CUDA_LIBRARIES}
|
|
${CUDA_cudart_static_LIBRARY}
|
|
${CUDA_TOOLKIT_ROOT_DIR}/lib64/stubs/libcuda.so)
|
|
if(NVTX_FOUND)
|
|
target_link_libraries(${TARGET_NAME} ${CUDA_NVTX_LIB})
|
|
endif()
|
|
remove_gflags(${TARGET_NAME})
|
|
endif()
|
|
endfunction()
|
|
|
|
# Add dependency that TARGET will depend on test result of DEP, this function executes the DEP during make.
|
|
function(add_run_test_dependency TARGET_NAME DEP_NAME)
|
|
if(WITH_TESTING)
|
|
set(custom_target_name ${TARGET_NAME}_TEST_OUTPUT_DEPENDENCY_ON_${DEP_NAME})
|
|
add_custom_target(
|
|
${custom_target_name}
|
|
COMMAND
|
|
cd ${CMAKE_CURRENT_BINARY_DIR} && ./${DEP_NAME}
|
|
--cinn_x86_builtin_code_root=${CMAKE_SOURCE_DIR}/paddle/cinn/backends
|
|
COMMAND cd ${CMAKE_BINARY_DIR}
|
|
DEPENDS ${DEP_NAME})
|
|
add_dependencies(${TARGET_NAME} ${DEP_NAME} ${custom_target_name})
|
|
endif()
|
|
endfunction()
|
|
|
|
# find all third_party modules is used for paddle static library
|
|
# for reduce the dependency when building the inference libs.
|
|
set_property(GLOBAL PROPERTY FLUID_THIRD_PARTY)
|
|
function(find_fluid_thirdparties TARGET_NAME)
|
|
get_filename_component(__target_path ${TARGET_NAME} ABSOLUTE)
|
|
string(REGEX REPLACE "^${PADDLE_SOURCE_DIR}/" "" __target_path
|
|
${__target_path})
|
|
string(FIND "${__target_path}" "third_party" pos)
|
|
if(pos GREATER 1)
|
|
get_property(fluid_ GLOBAL PROPERTY FLUID_THIRD_PARTY)
|
|
set(fluid_third_partys ${fluid_third_partys} ${TARGET_NAME})
|
|
set_property(GLOBAL PROPERTY FLUID_THIRD_PARTY "${fluid_third_partys}")
|
|
endif()
|
|
endfunction()
|
|
|
|
function(cinn_merge_static_libs TARGET_NAME)
|
|
set(libs ${ARGN})
|
|
list(REMOVE_DUPLICATES libs)
|
|
|
|
# Get all propagation dependencies from the merged libraries
|
|
foreach(lib ${libs})
|
|
list(APPEND libs_deps ${${lib}_LIB_DEPENDS})
|
|
endforeach()
|
|
if(libs_deps)
|
|
list(REMOVE_DUPLICATES libs_deps)
|
|
endif()
|
|
|
|
# To produce a library we need at least one source file.
|
|
# It is created by add_custom_command below and will helps
|
|
# also help to track dependencies.
|
|
set(target_SRCS ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}_dummy.c)
|
|
|
|
if(APPLE) # Use OSX's libtool to merge archives
|
|
# Make the generated dummy source file depended on all static input
|
|
# libs. If input lib changes, the source file is touched
|
|
# which causes the desired effect (relink).
|
|
add_custom_command(
|
|
OUTPUT ${target_SRCS}
|
|
COMMAND ${CMAKE_COMMAND} -E touch ${target_SRCS}
|
|
DEPENDS ${libs})
|
|
|
|
# Generate dummy static lib
|
|
file(WRITE ${target_SRCS}
|
|
"const char *dummy_${TARGET_NAME} = \"${target_SRCS}\";")
|
|
add_library(${TARGET_NAME} STATIC ${target_SRCS})
|
|
target_link_libraries(${TARGET_NAME} ${libs_deps})
|
|
|
|
foreach(lib ${libs})
|
|
# Get the file names of the libraries to be merged
|
|
set(libfiles ${libfiles} $<TARGET_FILE:${lib}>)
|
|
endforeach()
|
|
add_custom_command(
|
|
TARGET ${TARGET_NAME}
|
|
POST_BUILD
|
|
COMMAND rm "${CMAKE_CURRENT_BINARY_DIR}/lib${TARGET_NAME}.a"
|
|
COMMAND /usr/bin/libtool -static -o
|
|
"${CMAKE_CURRENT_BINARY_DIR}/lib${TARGET_NAME}.a" ${libfiles})
|
|
endif()
|
|
if(LINUX
|
|
)# general UNIX: use "ar" to extract objects and re-add to a common lib
|
|
set(target_DIR ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}.dir)
|
|
|
|
foreach(lib ${libs})
|
|
set(objlistfile ${target_DIR}/${lib}.objlist
|
|
)# list of objects in the input library
|
|
set(objdir ${target_DIR}/${lib}.objdir)
|
|
|
|
add_custom_command(
|
|
OUTPUT ${objdir}
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${objdir}
|
|
DEPENDS ${lib})
|
|
|
|
add_custom_command(
|
|
OUTPUT ${objlistfile}
|
|
COMMAND ${CMAKE_AR} -x "$<TARGET_FILE:${lib}>"
|
|
COMMAND ${CMAKE_AR} -t "$<TARGET_FILE:${lib}>" > ${objlistfile}
|
|
DEPENDS ${lib} ${objdir}
|
|
WORKING_DIRECTORY ${objdir})
|
|
|
|
list(APPEND target_OBJS "${objlistfile}")
|
|
endforeach()
|
|
|
|
# Make the generated dummy source file depended on all static input
|
|
# libs. If input lib changes, the source file is touched
|
|
# which causes the desired effect (relink).
|
|
add_custom_command(
|
|
OUTPUT ${target_SRCS}
|
|
COMMAND ${CMAKE_COMMAND} -E touch ${target_SRCS}
|
|
DEPENDS ${libs} ${target_OBJS})
|
|
|
|
# Generate dummy static lib
|
|
file(WRITE ${target_SRCS}
|
|
"const char *dummy_${TARGET_NAME} = \"${target_SRCS}\";")
|
|
add_library(${TARGET_NAME} STATIC ${target_SRCS})
|
|
target_link_libraries(${TARGET_NAME} ${libs_deps})
|
|
|
|
# Get the file name of the generated library
|
|
set(target_LIBNAME "$<TARGET_FILE:${TARGET_NAME}>")
|
|
|
|
add_custom_command(
|
|
TARGET ${TARGET_NAME}
|
|
POST_BUILD
|
|
COMMAND ${CMAKE_AR} crs ${target_LIBNAME} `find ${target_DIR} -name '*.o'`
|
|
COMMAND ${CMAKE_RANLIB} ${target_LIBNAME}
|
|
WORKING_DIRECTORY ${target_DIR})
|
|
endif()
|
|
if(WIN32)
|
|
|
|
# windows do not support gcc/nvcc combined compiling. Use msvc lib.exe to merge libs.
|
|
# Make the generated dummy source file depended on all static input
|
|
# libs. If input lib changes, the source file is touched
|
|
# which causes the desired effect (relink).
|
|
add_custom_command(
|
|
OUTPUT ${target_SRCS}
|
|
COMMAND ${CMAKE_COMMAND} -E touch ${target_SRCS}
|
|
DEPENDS ${libs})
|
|
|
|
# Generate dummy static lib
|
|
file(WRITE ${target_SRCS}
|
|
"const char *dummy_${TARGET_NAME} = \"${target_SRCS}\";")
|
|
add_library(${TARGET_NAME} STATIC ${target_SRCS})
|
|
target_link_libraries(${TARGET_NAME} ${libs_deps})
|
|
|
|
foreach(lib ${libs})
|
|
# Get the file names of the libraries to be merged
|
|
set(libfiles ${libfiles} $<TARGET_FILE:${lib}>)
|
|
endforeach()
|
|
# msvc will put library in directory of "/Release/xxxlib" by default
|
|
# COMMAND cmake -E remove "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${TARGET_NAME}.lib"
|
|
add_custom_command(
|
|
TARGET ${TARGET_NAME}
|
|
POST_BUILD
|
|
COMMAND cmake -E make_directory
|
|
"${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}"
|
|
COMMAND
|
|
lib
|
|
/OUT:${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/lib${TARGET_NAME}.lib
|
|
${libfiles})
|
|
endif()
|
|
endfunction()
|
|
|
|
# Modification of standard 'protobuf_generate_cpp()' with protobuf-lite support
|
|
# Usage:
|
|
# paddle_protobuf_generate_cpp(<proto_srcs> <proto_hdrs> <proto_files>)
|
|
|
|
function(paddle_protobuf_generate_cpp SRCS HDRS)
|
|
if(NOT ARGN)
|
|
message(
|
|
SEND_ERROR
|
|
"Error: paddle_protobuf_generate_cpp() called without any proto files")
|
|
return()
|
|
endif()
|
|
|
|
set(${SRCS})
|
|
set(${HDRS})
|
|
|
|
foreach(FIL ${ARGN})
|
|
get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
|
|
get_filename_component(FIL_WE ${FIL} NAME_WE)
|
|
|
|
set(_protobuf_protoc_src "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.cc")
|
|
set(_protobuf_protoc_hdr "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h")
|
|
list(APPEND ${SRCS} "${_protobuf_protoc_src}")
|
|
list(APPEND ${HDRS} "${_protobuf_protoc_hdr}")
|
|
|
|
add_custom_command(
|
|
OUTPUT "${_protobuf_protoc_src}" "${_protobuf_protoc_hdr}"
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CURRENT_BINARY_DIR}"
|
|
COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} -I${CMAKE_SOURCE_DIR} --cpp_out
|
|
"${CMAKE_BINARY_DIR}" ${ABS_FIL}
|
|
DEPENDS ${ABS_FIL} protoc
|
|
COMMENT "Running C++ protocol buffer compiler on ${FIL}"
|
|
VERBATIM)
|
|
endforeach()
|
|
|
|
set_source_files_properties(${${SRCS}} ${${HDRS}} PROPERTIES GENERATED TRUE)
|
|
set(${SRCS}
|
|
${${SRCS}}
|
|
PARENT_SCOPE)
|
|
set(${HDRS}
|
|
${${HDRS}}
|
|
PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(cinn_proto_library TARGET_NAME)
|
|
set(oneValueArgs "")
|
|
set(multiValueArgs SRCS DEPS)
|
|
cmake_parse_arguments(cinn_proto_library "${options}" "${oneValueArgs}"
|
|
"${multiValueArgs}" ${ARGN})
|
|
set(proto_srcs)
|
|
set(proto_hdrs)
|
|
paddle_protobuf_generate_cpp(proto_srcs proto_hdrs ${cinn_proto_library_SRCS})
|
|
cinn_cc_library(${TARGET_NAME} SRCS ${proto_srcs} DEPS
|
|
${cinn_proto_library_DEPS} protobuf)
|
|
set("${TARGET_NAME}_HDRS"
|
|
${proto_hdrs}
|
|
PARENT_SCOPE)
|
|
set("${TARGET_NAME}_SRCS"
|
|
${proto_srcs}
|
|
PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(common_link TARGET_NAME)
|
|
if(WITH_PROFILER)
|
|
target_link_libraries(${TARGET_NAME} gperftools::profiler)
|
|
endif()
|
|
|
|
if(WITH_JEMALLOC)
|
|
target_link_libraries(${TARGET_NAME} jemalloc::jemalloc)
|
|
endif()
|
|
endfunction()
|
|
|
|
# This method is borrowed from Paddle-Lite.
|
|
function(download_and_uncompress INSTALL_DIR URL FILENAME)
|
|
message(STATUS "Download inference test stuff from ${URL}/${FILENAME}")
|
|
string(REGEX REPLACE "[-%.]" "_" FILENAME_EX ${FILENAME})
|
|
set(EXTERNAL_PROJECT_NAME "extern_lite_download_${FILENAME_EX}")
|
|
set(UNPACK_DIR "${INSTALL_DIR}/src/${EXTERNAL_PROJECT_NAME}")
|
|
ExternalProject_Add(
|
|
${EXTERNAL_PROJECT_NAME}
|
|
${EXTERNAL_PROJECT_LOG_ARGS}
|
|
PREFIX ${INSTALL_DIR}
|
|
DOWNLOAD_COMMAND
|
|
/bin/sh -c
|
|
"[ -f '${FILENAME}' ] && echo 'skip download' || wget --no-check-certificate -q -O '${FILENAME}' '${URL}/${FILENAME}'"
|
|
&& ${CMAKE_COMMAND} -E tar xzf ${FILENAME}
|
|
DOWNLOAD_DIR ${INSTALL_DIR}
|
|
DOWNLOAD_NO_PROGRESS 1
|
|
CONFIGURE_COMMAND ""
|
|
BUILD_COMMAND ""
|
|
UPDATE_COMMAND ""
|
|
INSTALL_COMMAND "")
|
|
endfunction()
|
|
|
|
function(gather_srcs SRC_GROUP)
|
|
set(options)
|
|
set(oneValueArgs)
|
|
set(multiValueArgs "SRCS")
|
|
cmake_parse_arguments(prefix "" "" "${multiValueArgs}" ${ARGN})
|
|
foreach(cpp ${prefix_SRCS})
|
|
set(${SRC_GROUP}
|
|
"${${SRC_GROUP}};${CMAKE_CURRENT_SOURCE_DIR}/${cpp}"
|
|
CACHE INTERNAL "")
|
|
endforeach()
|
|
endfunction()
|
|
|
|
function(core_gather_headers)
|
|
file(
|
|
GLOB includes
|
|
LIST_DIRECTORIES false
|
|
RELATIVE ${CMAKE_SOURCE_DIR}
|
|
*.h)
|
|
|
|
foreach(header ${includes})
|
|
set(core_includes
|
|
"${core_includes};${header}"
|
|
CACHE INTERNAL "")
|
|
endforeach()
|
|
endfunction()
|