diff options
Diffstat (limited to 'cmake')
| -rw-r--r-- | cmake/Build.cmake | 27 | ||||
| -rw-r--r-- | cmake/CheckAFLCCompiler.cmake | 24 | ||||
| -rw-r--r-- | cmake/DockerImage.cmake | 25 | ||||
| -rw-r--r-- | cmake/FindCheckPatch.cmake | 31 | ||||
| -rw-r--r-- | cmake/FindClangFormat.cmake | 20 | ||||
| -rw-r--r-- | cmake/FindDocker.cmake | 20 | ||||
| -rw-r--r-- | cmake/FindFuse.cmake | 181 | ||||
| -rw-r--r-- | cmake/FindKernelHeaders.cmake | 61 | ||||
| -rw-r--r-- | cmake/FindLibatomic.cmake | 45 | ||||
| -rw-r--r-- | cmake/FindStdatomic.cmake | 14 | ||||
| -rw-r--r-- | cmake/GenerateBuild.cmake | 11 | ||||
| -rw-r--r-- | cmake/GenerateVersion.cmake | 20 | ||||
| -rw-r--r-- | cmake/InstallVersionFile.cmake.in | 8 | ||||
| -rw-r--r-- | cmake/Kernel.cmake | 58 | ||||
| -rw-r--r-- | cmake/Lint.cmake | 70 | ||||
| -rw-r--r-- | cmake/PostVersionPackaging.cmake | 9 | ||||
| -rw-r--r-- | cmake/PreVersionPackaging.cmake | 11 | ||||
| -rw-r--r-- | cmake/Version.cmake | 125 | ||||
| -rw-r--r-- | cmake/toolchain/Aarch64LinuxGnu.cmake | 24 | ||||
| -rw-r--r-- | cmake/toolchain/PowerpcLinuxGnu.cmake | 24 |
20 files changed, 786 insertions, 22 deletions
diff --git a/cmake/Build.cmake b/cmake/Build.cmake new file mode 100644 index 0000000..a7f4c07 --- /dev/null +++ b/cmake/Build.cmake @@ -0,0 +1,27 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +macro(gen_build_type BUILD_INPUT_FILE_TEMPLATE BUILD_OUTPUT_FILE) + get_filename_component(BUILD_OUTPUT_FILENAME ${BUILD_OUTPUT_FILE} NAME) + # command that will trigger a rebuild of build.h every time + add_custom_command(OUTPUT regenerate-build-file + COMMAND ${CMAKE_COMMAND} -E sleep 0 + COMMENT "Trigger generating ${BUILD_OUTPUT_FILENAME}") + + # call the GenerateBuild.cmake file to generate the build.h file + add_custom_command(OUTPUT ${BUILD_OUTPUT_FILE} + COMMAND ${CMAKE_COMMAND} -D BUILD_INPUT_FILE_TEMPLATE=${BUILD_INPUT_FILE_TEMPLATE} + -D BUILD_OUTPUT_FILE=${BUILD_OUTPUT_FILE} + -D BUILD_TYPE=${CMAKE_BUILD_TYPE} + -P ${PROJECT_MODULES_DIR}/GenerateBuild.cmake + COMMENT "Generating ${BUILD_OUTPUT_FILENAME}" + DEPENDS regenerate-build-file) + add_custom_target(dnbd3-generate-build DEPENDS ${BUILD_OUTPUT_FILE}) + + # create target to expose project build type + add_library(dnbd3-build INTERFACE) + target_include_directories(dnbd3-build INTERFACE ${PROJECT_INCLUDE_GEN_DIR}) + add_dependencies(dnbd3-build dnbd3-generate-build) +endmacro(gen_build_type BUILD_INPUT_FILE_TEMPLATE BUILD_OUTPUT_FILE) diff --git a/cmake/CheckAFLCCompiler.cmake b/cmake/CheckAFLCCompiler.cmake new file mode 100644 index 0000000..249248b --- /dev/null +++ b/cmake/CheckAFLCCompiler.cmake @@ -0,0 +1,24 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +# check if corresponding AFL C Compiler form original C compiler is available +# if an AFL C compiler is available, then the path to the AFL C compiler is returned in AFL_C_COMPILER +macro(check_afl_c_compiler AFL_C_COMPILER AFL_C_COMPILER_NAME C_COMPILER_PATH C_COMPILER_ID) + # determine AFL C compiler suffix from original C compiler ID + if(${C_COMPILER_ID} MATCHES "GNU") + set(AFL_C_COMPILER_SUFFIX "gcc") + elseif(${C_COMPILER_ID} MATCHES "Clang") + set(AFL_C_COMPILER_SUFFIX "clang") + else(${C_COMPILER_ID} MATCHES "Clang") + get_filename_component(AFL_C_COMPILER_SUFFIX ${C_COMPILER_PATH} NAME) + endif(${C_COMPILER_ID} MATCHES "GNU") + + # define search file name and search for AFL C compiler program + set(AFL_C_COMPILER_SEARCH_NAME "afl-${AFL_C_COMPILER_SUFFIX}") + find_program(${AFL_C_COMPILER} NAMES ${AFL_C_COMPILER_SEARCH_NAME}) + + # return the AFL C compiler name to the caller + set(${AFL_C_COMPILER_NAME} ${AFL_C_COMPILER_SEARCH_NAME}) +endmacro(check_afl_c_compiler)
\ No newline at end of file diff --git a/cmake/DockerImage.cmake b/cmake/DockerImage.cmake new file mode 100644 index 0000000..83f4b9d --- /dev/null +++ b/cmake/DockerImage.cmake @@ -0,0 +1,25 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +# create a pseudo target to do packaging before docker image is built +add_custom_target(package_docker + COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target package + VERBATIM) + +# macro to build a docker image based on a provided Dockerfile and an installation package +macro(add_docker_image TARGET_NAME DOCKER_IMAGE DOCKER_FILE DOCKER_TAG PACKAGE_FILE BUILD_DIR) + get_filename_component(PACKAGE_FILE_PATH ${PACKAGE_FILE} PATH) + get_filename_component(PACKAGE_FILE_NAME ${PACKAGE_FILE} NAME) + + # commands and target to build docker image + add_custom_command(OUTPUT ${DOCKER_IMAGE} + COMMAND docker image build -t ${DOCKER_TAG} --file ${DOCKER_FILE} --build-arg DNBD3_PACKAGE_FILE_NAME=${PACKAGE_FILE_NAME} ${BUILD_DIR} + COMMAND docker image save -o ${DOCKER_IMAGE} ${DOCKER_TAG} + COMMAND docker image rm ${DOCKER_TAG} + DEPENDS ${DOCKER_FILE} + package_docker) + add_custom_target(${TARGET_NAME} + DEPENDS ${DOCKER_IMAGE}) +endmacro(add_docker_image TARGET_NAME DOCKER_IMAGE DOCKER_FILE PACKAGE_FILE) diff --git a/cmake/FindCheckPatch.cmake b/cmake/FindCheckPatch.cmake new file mode 100644 index 0000000..8454e6b --- /dev/null +++ b/cmake/FindCheckPatch.cmake @@ -0,0 +1,31 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2021 Manuel Bentele <development@manuel-bentele.de> +# + +# check if custom Linux kernel script directory was specified +if(NOT KERNEL_SCRIPTS_DIR) + set(KERNEL_SCRIPTS_DIR "${KERNEL_BUILD_DIR}/scripts" + CACHE PATH "Path to Linux kernel scripts directory") +endif(NOT KERNEL_SCRIPTS_DIR) + +# find the checkpatch.pl script in the given KERNEL_SCRIPTS_DIR +find_program(CheckPatch_EXECUTABLE + NAMES checkpatch.pl + PATHS ${KERNEL_SCRIPTS_DIR}) + + +# get the checkpatch.pl version +if(CheckPatch_EXECUTABLE) + execute_process(COMMAND ${CheckPatch_EXECUTABLE} --version + OUTPUT_VARIABLE CheckPatch_VERBOSE_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE) + string(REGEX REPLACE ".*Version:.([0-9]+\\.[0-9]+).*" "\\1" CheckPatch_VERSION "${CheckPatch_VERBOSE_VERSION}") +endif(CheckPatch_EXECUTABLE) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(CheckPatch + FOUND_VAR CheckPatch_FOUND + REQUIRED_VARS CheckPatch_EXECUTABLE + VERSION_VAR CheckPatch_VERSION + FAIL_MESSAGE "checkpatch.pl is not available! Please install checkpatch.pl to lint and format the source code!") diff --git a/cmake/FindClangFormat.cmake b/cmake/FindClangFormat.cmake new file mode 100644 index 0000000..a6c77d4 --- /dev/null +++ b/cmake/FindClangFormat.cmake @@ -0,0 +1,20 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2021 Manuel Bentele <development@manuel-bentele.de> +# + +find_program(ClangFormat_EXECUTABLE NAMES clang-format) + +if(ClangFormat_EXECUTABLE) + execute_process(COMMAND clang-format --version + OUTPUT_VARIABLE ClangFormat_VERBOSE_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE) + string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" ClangFormat_VERSION ${ClangFormat_VERBOSE_VERSION}) +endif(ClangFormat_EXECUTABLE) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(ClangFormat + FOUND_VAR ClangFormat_FOUND + REQUIRED_VARS ClangFormat_EXECUTABLE + VERSION_VAR ClangFormat_VERSION + FAIL_MESSAGE "clang-format is not available! Please install clang-format to lint and format the source code!") diff --git a/cmake/FindDocker.cmake b/cmake/FindDocker.cmake new file mode 100644 index 0000000..ef3046d --- /dev/null +++ b/cmake/FindDocker.cmake @@ -0,0 +1,20 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +find_program(Docker_EXECUTABLE NAMES docker) + +if(Docker_EXECUTABLE) + execute_process(COMMAND docker version --format "{{.Server.Version}}" + OUTPUT_VARIABLE Docker_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE) +endif(Docker_EXECUTABLE) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Docker + FOUND_VAR Docker_FOUND + REQUIRED_VARS Docker_EXECUTABLE + VERSION_VAR Docker_VERSION + FAIL_MESSAGE "Docker is not available! Please install docker to build and run containers!") + diff --git a/cmake/FindFuse.cmake b/cmake/FindFuse.cmake index b9c6f91..09e8ba0 100644 --- a/cmake/FindFuse.cmake +++ b/cmake/FindFuse.cmake @@ -1,30 +1,167 @@ -# - Find fuse -# Find the native fuse includes and library +# This module can find FUSE Library # -# FUSE_INCLUDE_DIR - where to find fuse/fuse.h. -# FUSE_LIBRARIES - List of libraries when using fuse. -# FUSE_FOUND - True if fuse found. +# Requirements: +# - CMake >= 2.8.3 +# +# The following variables will be defined for your use: +# - FUSE_FOUND : was FUSE found? +# - FUSE_INCLUDE_DIRS : FUSE include directory +# - FUSE_LIBRARIES : FUSE library +# - FUSE_DEFINITIONS : FUSE cflags +# - FUSE_VERSION : complete version of FUSE (major.minor) +# - FUSE_MAJOR_VERSION : major version of FUSE +# - FUSE_MINOR_VERSION : minor version of FUSE +# +# Example Usage: +# +# 1. Copy this file in the root of your project source directory +# 2. Then, tell CMake to search this non-standard module in your project directory by adding to your CMakeLists.txt: +# set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}) +# 3. Finally call find_package() once, here are some examples to pick from +# +# Require FUSE 2.6 or later +# find_package(FUSE 2.6 REQUIRED) +# +# if(FUSE_FOUND) +# add_definitions(${FUSE_DEFINITIONS}) +# include_directories(${FUSE_INCLUDE_DIRS}) +# add_executable(myapp myapp.c) +# target_link_libraries(myapp ${FUSE_LIBRARIES}) +# endif() + +#============================================================================= +# Copyright (c) 2012, julp +# +# Distributed under the OSI-approved BSD License +# +# This software is distributed WITHOUT ANY WARRANTY; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +#============================================================================= + +cmake_minimum_required(VERSION 2.8.12) + +########## Private ########## +function(fusedebug _varname) + if(FUSE_DEBUG) + message("${_varname} = ${${_varname}}") + endif(FUSE_DEBUG) +endfunction(fusedebug) + +########## Public ########## +set(FUSE_FOUND TRUE) +set(FUSE_LIBRARIES ) +set(FUSE_DEFINITIONS ) +set(FUSE_INCLUDE_DIRS ) + +find_package(PkgConfig QUIET) + +set(PC_FUSE_INCLUDE_DIRS "/usr/include/fuse") +set(PC_FUSE_LIBRARY_DIRS ) +if(PKG_CONFIG_FOUND) + pkg_check_modules(PC_FUSE "fuse" QUIET) + if(PC_FUSE_FOUND) +# fusedebug(PC_FUSE_LIBRARIES) +# fusedebug(PC_FUSE_LIBRARY_DIRS) +# fusedebug(PC_FUSE_LDFLAGS) +# fusedebug(PC_FUSE_LDFLAGS_OTHER) +# fusedebug(PC_FUSE_INCLUDE_DIRS) +# fusedebug(PC_FUSE_CFLAGS) +# fusedebug(PC_FUSE_CFLAGS_OTHER) + set(FUSE_DEFINITIONS "${PC_FUSE_CFLAGS_OTHER}") + endif(PC_FUSE_FOUND) +endif(PKG_CONFIG_FOUND) + +find_path( + FUSE_INCLUDE_DIRS + NAMES fuse_common.h fuse_lowlevel.h fuse.h + PATHS "${PC_FUSE_INCLUDE_DIRS}" + DOC "Include directories for FUSE" +) + +if(NOT FUSE_INCLUDE_DIRS) + set(FUSE_FOUND FALSE) +endif(NOT FUSE_INCLUDE_DIRS) + +find_library( + FUSE_LIBRARIES + NAMES "fuse" + PATHS "${PC_FUSE_LIBRARY_DIRS}" + DOC "Libraries for FUSE" +) +if(NOT FUSE_LIBRARIES) + set(FUSE_FOUND FALSE) +endif(NOT FUSE_LIBRARIES) -IF (FUSE_INCLUDE_DIR) - # Already in cache, be silent - SET(FUSE_FIND_QUIETLY TRUE) -ENDIF (FUSE_INCLUDE_DIR) +if(FUSE_FOUND) + if(EXISTS "${FUSE_INCLUDE_DIRS}/fuse_common.h") + file(READ "${FUSE_INCLUDE_DIRS}/fuse_common.h" _contents) + string(REGEX REPLACE ".*# *define *FUSE_MAJOR_VERSION *([0-9]+).*" "\\1" FUSE_MAJOR_VERSION "${_contents}") + string(REGEX REPLACE ".*# *define *FUSE_MINOR_VERSION *([0-9]+).*" "\\1" FUSE_MINOR_VERSION "${_contents}") + set(FUSE_VERSION "${FUSE_MAJOR_VERSION}.${FUSE_MINOR_VERSION}") + endif() -FIND_PATH(FUSE_INCLUDE_DIR fuse/fuse.h) + include(CheckCSourceCompiles) + # Backup CMAKE_REQUIRED_* + set(OLD_CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}") + set(OLD_CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}") + set(OLD_CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}") + # Add FUSE compilation flags + set(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}" "${FUSE_INCLUDE_DIRS}") + set(CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}" "${FUSE_LIBRARIES}") + set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}" "${FUSE_DEFINITIONS}") + check_c_source_compiles("#include <stdlib.h> +#include <fuse.h> +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <fcntl.h> -SET(FUSE_NAMES fuse) -FIND_LIBRARY(FUSE_LIBRARY NAMES ${FUSE_NAMES} ) +int main(void) { +return 0; +}" FUSE_CFLAGS_CHECK) + if(NOT FUSE_CFLAGS_CHECK) + set(FUSE_DEFINITIONS "-D_FILE_OFFSET_BITS=64") + # Should we run again previous test to assume the failure was due to missing definition -D_FILE_OFFSET_BITS=64? + endif(NOT FUSE_CFLAGS_CHECK) + # Restore CMAKE_REQUIRED_* + set(CMAKE_REQUIRED_INCLUDES "${OLD_CMAKE_REQUIRED_INCLUDES}") + set(CMAKE_REQUIRED_LIBRARIES "${OLD_CMAKE_REQUIRED_LIBRARIES}") + set(CMAKE_REQUIRED_DEFINITIONS "${OLD_CMAKE_REQUIRED_DEFINITIONS}") +endif(FUSE_FOUND) -# handle the QUIETLY and REQUIRED arguments and set FUSE_FOUND to TRUE if -# all listed variables are TRUE -INCLUDE(FindPackageHandleStandardArgs) -FIND_PACKAGE_HANDLE_STANDARD_ARGS(FUSE REQUIRED FUSE_LIBRARY FUSE_INCLUDE_DIR) +if(FUSE_INCLUDE_DIRS) + include(FindPackageHandleStandardArgs) + if(FUSE_FIND_REQUIRED AND NOT FUSE_FIND_QUIETLY) + find_package_handle_standard_args(Fuse REQUIRED_VARS FUSE_LIBRARIES FUSE_INCLUDE_DIRS VERSION_VAR FUSE_VERSION) + else() + find_package_handle_standard_args(Fuse "FUSE not found" FUSE_LIBRARIES FUSE_INCLUDE_DIRS) + endif() +else(FUSE_INCLUDE_DIRS) + if(FUSE_FIND_REQUIRED AND NOT FUSE_FIND_QUIETLY) + message(FATAL_ERROR "Could not find FUSE include directory") + endif() +endif(FUSE_INCLUDE_DIRS) -IF(FUSE_FOUND) - SET( FUSE_LIBRARIES ${FUSE_LIBRARY} ) -ELSE(FUSE_FOUND) - SET( FUSE_LIBRARIES ) -ENDIF(FUSE_FOUND) +mark_as_advanced( + FUSE_INCLUDE_DIRS + FUSE_LIBRARIES +) -MARK_AS_ADVANCED( FUSE_LIBRARY FUSE_INCLUDE_DIR ) +# IN (args) +fusedebug("FUSE_FIND_COMPONENTS") +fusedebug("FUSE_FIND_REQUIRED") +fusedebug("FUSE_FIND_QUIETLY") +fusedebug("FUSE_FIND_VERSION") +# OUT +# Found +fusedebug("FUSE_FOUND") +# Definitions +fusedebug("FUSE_DEFINITIONS") +# Linking +fusedebug("FUSE_INCLUDE_DIRS") +fusedebug("FUSE_LIBRARIES") +# Version +fusedebug("FUSE_MAJOR_VERSION") +fusedebug("FUSE_MINOR_VERSION") +fusedebug("FUSE_VERSION") diff --git a/cmake/FindKernelHeaders.cmake b/cmake/FindKernelHeaders.cmake new file mode 100644 index 0000000..c04243e --- /dev/null +++ b/cmake/FindKernelHeaders.cmake @@ -0,0 +1,61 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +# check if custom Linux kernel build directory was specified +if(NOT KERNEL_BUILD_DIR) + set(KERNEL_BUILD_DIR "/lib/modules/${CMAKE_SYSTEM_VERSION}/build" + CACHE PATH "Path to Linux kernel modules to compile against") +endif(NOT KERNEL_BUILD_DIR) + +# check if custom Linux kernel output directory was specified +if(NOT KERNEL_INSTALL_DIR) + set(KERNEL_INSTALL_DIR "/lib/modules/${CMAKE_SYSTEM_VERSION}/extra" + CACHE PATH "Path to install Linux kernel modules") +endif(NOT KERNEL_INSTALL_DIR) + +if(NOT EXISTS "${KERNEL_BUILD_DIR}/Module.symvers") + message(WARNING "\n\nModule.symvers not found in ${KERNEL_BUILD_DIR}\n" + "Your kernel sources don't seem to belong to a built kernel," + " expect missing symbols when building kernel module.\n\n") +endif() + +# find the Linux kernel headers from given KERNEL_BUILD_DIR +find_path(KernelHeaders_INCLUDE_DIR + NAMES linux/kernel.h + linux/module.h + generated/utsrelease.h + PATHS ${KERNEL_BUILD_DIR}/include + NO_DEFAULT_PATH) + +# get Linux kernel headers version +file(READ "${KERNEL_BUILD_DIR}/include/generated/utsrelease.h" tmpvar) +string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" KernelHeaders_VERSION ${tmpvar}) +if("${KernelHeaders_VERSION}" EQUAL "") + file(READ "${KERNEL_BUILD_DIR}/include/config/kernel.release" tmpvar) + string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" KernelHeaders_VERSION ${tmpvar}) +endif() +if("${KernelHeaders_VERSION}" EQUAL "") + string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" KernelHeaders_VERSION ${KernelHeaders_INCLUDE_DIR}) +endif() +if("${KernelHeaders_VERSION}" EQUAL "") + message(FATAL_ERROR "Cannot determine kernel version") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(KernelHeaders + FOUND_VAR KernelHeaders_FOUND + REQUIRED_VARS KernelHeaders_INCLUDE_DIR + VERSION_VAR KernelHeaders_VERSION + FAIL_MESSAGE "Linux kernel headers are not available! Please install them to build kernel modules!") + +mark_as_advanced(KernelHeaders_INCLUDE_DIR KernelHeaders_MODULE_INSTALL_DIR) + +# print found information +if(${CMAKE_VERSION} VERSION_GREATER "3.15.0") + message(VERBOSE "KERNEL_BUILD_DIR: ${KERNEL_BUILD_DIR}") + message(VERBOSE "KERNEL_INSTALL_DIR: ${KERNEL_INSTALL_DIR}") + message(VERBOSE "KernelHeaders_FOUND: ${KernelHeaders_FOUND}") + message(VERBOSE "KernelHeaders_VERSION: ${KernelHeaders_VERSION}") +endif(${CMAKE_VERSION} VERSION_GREATER "3.15.0") diff --git a/cmake/FindLibatomic.cmake b/cmake/FindLibatomic.cmake new file mode 100644 index 0000000..e1c4915 --- /dev/null +++ b/cmake/FindLibatomic.cmake @@ -0,0 +1,45 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +# Use pkg-config to get the directories and then use these values +# in the FIND_PATH() and FIND_LIBRARY() calls +find_package(PkgConfig QUIET) +pkg_check_modules(PKG_Libatomic QUIET libatomic) + +set(Libatomic_COMPILE_OPTIONS ${PKG_Libatomic_CFLAGS_OTHER}) +set(Libatomic_VERSION ${PKG_Libatomic_VERSION}) + +find_library(Libatomic_LIBRARY + NAMES atomic + HINTS ${CMAKE_C_IMPLICIT_LINK_DIRECTORIES} + ${PKG_Libatomic_LIBRARY_DIRS}) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Libatomic + FOUND_VAR Libatomic_FOUND + REQUIRED_VARS Libatomic_LIBRARY + VERSION_VAR Libatomic_VERSION + FAIL_MESSAGE "Library 'atomic' is not available! Please install this required library!") + +if(Libatomic_FOUND AND NOT TARGET Libatomic::Libatomic) + add_library(Libatomic::Libatomic UNKNOWN IMPORTED) + set_target_properties(Libatomic::Libatomic PROPERTIES + IMPORTED_LOCATION "${Libatomic_LIBRARY}" + INTERFACE_COMPILE_OPTIONS "${Libatomic_COMPILE_OPTIONS}") +endif(Libatomic_FOUND AND NOT TARGET Libatomic::Libatomic) + +mark_as_advanced(Libatomic_LIBRARY) + +if(Libatomic_FOUND) + set(Libatomic_LIBRARIES ${Libatomic_LIBRARY}) +endif(Libatomic_FOUND) + +# print found information +if(${CMAKE_VERSION} VERSION_GREATER "3.15.0") + message(VERBOSE "Libatomic_FOUND: ${Libatomic_FOUND}") + message(VERBOSE "Libatomic_VERSION: ${Libatomic_VERSION}") + message(VERBOSE "Libatomic_COMPILE_OPTIONS: ${Libatomic_COMPILE_OPTIONS}") + message(VERBOSE "Libatomic_LIBRARIES: ${Libatomic_LIBRARIES}") +endif(${CMAKE_VERSION} VERSION_GREATER "3.15.0") diff --git a/cmake/FindStdatomic.cmake b/cmake/FindStdatomic.cmake new file mode 100644 index 0000000..d7ee9b8 --- /dev/null +++ b/cmake/FindStdatomic.cmake @@ -0,0 +1,14 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2021 Manuel Bentele <development@manuel-bentele.de> +# + +find_file(Stdatomic_INCLUDE_FILE + NAMES stdatomic.h + HINTS ${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES}) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Stdatomic + FOUND_VAR Stdatomic_FOUND + REQUIRED_VARS Stdatomic_INCLUDE_FILE + FAIL_MESSAGE "Compiler does not support atomic operations!") diff --git a/cmake/GenerateBuild.cmake b/cmake/GenerateBuild.cmake new file mode 100644 index 0000000..96b2906 --- /dev/null +++ b/cmake/GenerateBuild.cmake @@ -0,0 +1,11 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +# set current build type of the project +set(DNBD3_BUILD ${BUILD_TYPE}) +string(TIMESTAMP DNBD3_BUILD_DATE "%Y-%m-%d" UTC) + +# write dnbd3 build type into a new C source file based on the specified build file template +configure_file(${BUILD_INPUT_FILE_TEMPLATE} ${BUILD_OUTPUT_FILE}) diff --git a/cmake/GenerateVersion.cmake b/cmake/GenerateVersion.cmake new file mode 100644 index 0000000..b7579bc --- /dev/null +++ b/cmake/GenerateVersion.cmake @@ -0,0 +1,20 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +# set CMake module path to include version macros +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} + ${VERSION_MODULE_PATH}) + +# include version macros +include(Version) + +# get Git version of Git repository +get_repository_version(DNBD3_VERSION DNBD3_VERSION_SHORT DNBD3_BRANCH ${VERSION_INPUT_FILE} ${VERSION_BUILD_TYPE} ${GIT_EXECUTABLE} ${REPOSITORY_DIR}) + +# generate version header if header does not exists +if(NOT EXISTS ${VERSION_INPUT_FILE}) + # write dnbd3 version into a new C source file based on the specified version template + configure_file(${VERSION_INPUT_FILE_TEMPLATE} ${VERSION_OUTPUT_FILE}) +endif(NOT EXISTS ${VERSION_INPUT_FILE}) diff --git a/cmake/InstallVersionFile.cmake.in b/cmake/InstallVersionFile.cmake.in new file mode 100644 index 0000000..8121c25 --- /dev/null +++ b/cmake/InstallVersionFile.cmake.in @@ -0,0 +1,8 @@ +# +# AUTOGENERATED: DO NOT EDIT THIS FILE +# + +if(CPACK_SOURCE_INSTALLED_DIRECTORIES AND EXISTS "@INCLUDE_VERSION_HEADER_GENERATE@") + file(INSTALL "@INCLUDE_VERSION_HEADER_GENERATE@" + DESTINATION "@INCLUDE_VERSION_HEADER_GENERATE_PREFIX@") +endif(CPACK_SOURCE_INSTALLED_DIRECTORIES AND EXISTS "@INCLUDE_VERSION_HEADER_GENERATE@") diff --git a/cmake/Kernel.cmake b/cmake/Kernel.cmake new file mode 100644 index 0000000..9ecbbba --- /dev/null +++ b/cmake/Kernel.cmake @@ -0,0 +1,58 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# CMake macros to build and install Linux kernel modules +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +# macro to define kernel module targets +macro(add_kernel_module MODULE_NAME KERNEL_BUILD_DIR KERNEL_INSTALL_DIR MODULE_MACRO MODULE_SOURCE_FILES MODULE_HEADER_FILES BUILD_SOURCE_FILE) + # create directory for kernel module + file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}) + # copy build source file + get_filename_component(BUILD_SOURCE_FILENAME ${BUILD_SOURCE_FILE} NAME) + add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${BUILD_SOURCE_FILENAME} + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${BUILD_SOURCE_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME} + DEPENDS ${BUILD_SOURCE_FILE}) + set(BUILD_SOURCE_FILE_PREPARED ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${BUILD_SOURCE_FILENAME}) + # copy source files + foreach(MODULE_SOURCE_FILE ${MODULE_SOURCE_FILES}) + get_filename_component(MODULE_SOURCE_FILENAME ${MODULE_SOURCE_FILE} NAME) + add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_SOURCE_FILENAME} + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${MODULE_SOURCE_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME} + DEPENDS ${MODULE_SOURCE_FILE}) + set(MODULE_SOURCE_FILES_PREPARED ${MODULE_SOURCE_FILES_PREPARED} + ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_SOURCE_FILENAME}) + endforeach() + # copy header files + foreach(MODULE_HEADER_FILE ${MODULE_HEADER_FILES}) + get_filename_component(MODULE_HEADER_FILENAME ${MODULE_HEADER_FILE} NAME) + add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_HEADER_FILENAME} + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${MODULE_HEADER_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME} + DEPENDS ${MODULE_HEADER_FILE}) + set(MODULE_HEADER_FILES_PREPARED ${MODULE_HEADER_FILES_PREPARED} + ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_HEADER_FILENAME}) + endforeach() + # check if module depends on another module + if(NOT ${ARGV7} STREQUAL "") + set(MODULE_EXTRA_SYMBOLS ${CMAKE_CURRENT_BINARY_DIR}/${ARGV7}/Module.symvers) + endif() + # define build command + set(MODULE_BUILD_COMMAND ${CMAKE_MAKE_PROGRAM} ${MODULE_MACRO} + -C ${KERNEL_BUILD_DIR} + M=${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME} modules + EXTRA_CFLAGS=${KERNEL_C_FLAGS} + KBUILD_MODPOST_WARN=1 + KBUILD_EXTRA_SYMBOLS=${MODULE_EXTRA_SYMBOLS}) + add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_NAME}.ko + COMMAND ${MODULE_BUILD_COMMAND} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME} + COMMENT "Build kernel module ${MODULE_NAME}" + DEPENDS ${BUILD_SOURCE_FILE_PREPARED} ${MODULE_HEADER_FILES_PREPARED} ${MODULE_SOURCE_FILES_PREPARED} + VERBATIM) + add_custom_target(${MODULE_NAME} ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_NAME}.ko ${ARGV7}) + # install kernel module + install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${MODULE_NAME}/${MODULE_NAME}.ko + DESTINATION ${KERNEL_INSTALL_DIR} + PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ + COMPONENT kernel) +endmacro(add_kernel_module) diff --git a/cmake/Lint.cmake b/cmake/Lint.cmake new file mode 100644 index 0000000..4453fe3 --- /dev/null +++ b/cmake/Lint.cmake @@ -0,0 +1,70 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# CMake macros to check style of source code files +# Copyright (C) 2021 Manuel Bentele <development@manuel-bentele.de> +# + +find_package(ClangFormat) +find_package(CheckPatch) + +if(ClangFormat_FOUND OR CheckPatch_FOUND) + # add target to trigger all linter targets + add_custom_target(lint) +endif(ClangFormat_FOUND OR CheckPatch_FOUND) + +# macro to define lint targets +macro(add_linter LINT_NAME LINT_SOURCE_FILES) + if(ClangFormat_FOUND) + add_custom_target(${LINT_NAME} + COMMAND ${ClangFormat_EXECUTABLE} --Werror --dry-run ${LINT_SOURCE_FILES} ${ARGN} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + DEPENDS ${LINT_SOURCE_FILES} ${ARGN}) + add_dependencies(lint ${LINT_NAME}) + endif(ClangFormat_FOUND) +endmacro(add_linter) + +# macro to define lint targets for kernel source code files +macro(add_kernel_linter LINT_NAME LINT_IGNORE_OPTIONS LINT_SOURCE_FILES LINT_HEADER_FILES) + if(CheckPatch_FOUND) + set(LINT_IGNORE_ARGS "") + foreach(IGNORE_OPTION ${LINT_IGNORE_OPTIONS}) + list(APPEND LINT_IGNORE_ARGS "--ignore" "${IGNORE_OPTION}") + endforeach(IGNORE_OPTION ${LINT_IGNORE_OPTIONS}) + add_custom_target(${LINT_NAME} + COMMAND ${CheckPatch_EXECUTABLE} --no-tree --max-line-length=120 ${LINT_IGNORE_ARGS} -f ${LINT_SOURCE_FILES} ${LINT_HEADER_FILES} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + DEPENDS ${LINT_SOURCE_FILES} ${LINT_HEADER_FILES}) + add_dependencies(lint ${LINT_NAME}) + endif(CheckPatch_FOUND) +endmacro(add_kernel_linter) + +if(ClangFormat_FOUND OR CheckPatch_FOUND) + # add target to trigger all formatter targets + add_custom_target(lint-fix) +endif(ClangFormat_FOUND OR CheckPatch_FOUND) + +# macro to define formatter targets +macro(add_linter_fix LINT_FIX_NAME LINT_FIX_SOURCE_FILES) + if(ClangFormat_FOUND) + add_custom_target(${LINT_FIX_NAME} + COMMAND ${ClangFormat_EXECUTABLE} --Werror -i ${LINT_FIX_SOURCE_FILES} ${ARGN} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + DEPENDS ${LINT_FIX_SOURCE_FILES} ${ARGN}) + add_dependencies(lint-fix ${LINT_FIX_NAME}) + endif(ClangFormat_FOUND) +endmacro(add_linter_fix) + +# macro to define formatter targets for kernel source code files +macro(add_kernel_linter_fix LINT_FIX_NAME LINT_FIX_IGNORE_OPTIONS LINT_FIX_SOURCE_FILES LINT_FIX_HEADER_FILES) + if(CheckPatch_FOUND) + set(LINT_FIX_IGNORE_ARGS "") + foreach(IGNORE_OPTION ${LINT_FIX_IGNORE_OPTIONS}) + list(APPEND LINT_FIX_IGNORE_ARGS "--ignore" "${IGNORE_OPTION}") + endforeach(IGNORE_OPTION ${LINT_FIX_IGNORE_OPTIONS}) + add_custom_target(${LINT_FIX_NAME} + COMMAND ${CheckPatch_EXECUTABLE} --no-tree --max-line-length=120 ${LINT_FIX_IGNORE_ARGS} --fix-inplace -f ${LINT_FIX_SOURCE_FILES} ${LINT_FIX_HEADER_FILES} + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + DEPENDS ${LINT_FIX_SOURCE_FILES} ${LINT_FIX_HEADER_FILES}) + add_dependencies(lint-fix ${LINT_FIX_NAME}) + endif(CheckPatch_FOUND) +endmacro(add_kernel_linter_fix) diff --git a/cmake/PostVersionPackaging.cmake b/cmake/PostVersionPackaging.cmake new file mode 100644 index 0000000..877cd12 --- /dev/null +++ b/cmake/PostVersionPackaging.cmake @@ -0,0 +1,9 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +if(EXISTS ${VERSION_HEADER_INPUT_FILE}) + # remove version.h if generated version.h is available from a Git build + file(REMOVE ${VERSION_HEADER_OUTPUT_FILE}) +endif(EXISTS ${VERSION_HEADER_INPUT_FILE}) diff --git a/cmake/PreVersionPackaging.cmake b/cmake/PreVersionPackaging.cmake new file mode 100644 index 0000000..e960155 --- /dev/null +++ b/cmake/PreVersionPackaging.cmake @@ -0,0 +1,11 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +if(EXISTS ${VERSION_HEADER_INPUT_FILE}) + # copy generated version.h into the source repository for packaging purposes + get_filename_component(VERSION_HEADER_OUTPUT_FILE_PATH ${VERSION_HEADER_OUTPUT_FILE} PATH) + file(COPY ${VERSION_HEADER_INPUT_FILE} + DESTINATION ${VERSION_HEADER_OUTPUT_FILE_PATH}) +endif(EXISTS ${VERSION_HEADER_INPUT_FILE}) diff --git a/cmake/Version.cmake b/cmake/Version.cmake new file mode 100644 index 0000000..0f26944 --- /dev/null +++ b/cmake/Version.cmake @@ -0,0 +1,125 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +macro(gen_project_version VERSION_INPUT_FILE VERSION_INPUT_FILE_TEMPLATE VERSION_OUTPUT_FILE GIT_EXECUTABLE REPOSITORY_DIR) + get_filename_component(VERSION_OUTPUT_FILENAME ${VERSION_OUTPUT_FILE} NAME) + # command that will trigger a rebuild of version.h every time + add_custom_command(OUTPUT regenerate-version-file + COMMAND ${CMAKE_COMMAND} -E sleep 0 + COMMENT "Trigger generating ${VERSION_OUTPUT_FILENAME}") + + # call the GenerateVersion.cmake file to generate the version.c file + add_custom_command(OUTPUT ${VERSION_OUTPUT_FILE} + COMMAND ${CMAKE_COMMAND} -D VERSION_MODULE_PATH=${PROJECT_MODULES_DIR} + -D VERSION_INPUT_FILE=${VERSION_INPUT_FILE} + -D VERSION_INPUT_FILE_TEMPLATE=${VERSION_INPUT_FILE_TEMPLATE} + -D VERSION_OUTPUT_FILE=${VERSION_OUTPUT_FILE} + -D VERSION_BUILD_TYPE=${CMAKE_BUILD_TYPE} + -D GIT_EXECUTABLE=${GIT_EXECUTABLE} + -D REPOSITORY_DIR=${REPOSITORY_DIR} + -P ${PROJECT_MODULES_DIR}/GenerateVersion.cmake + COMMENT "Generating ${VERSION_OUTPUT_FILENAME}" + DEPENDS regenerate-version-file) + add_custom_target(dnbd3-generate-version DEPENDS ${VERSION_OUTPUT_FILE}) + + # create target to expose project version + add_library(dnbd3-version INTERFACE) + target_include_directories(dnbd3-version INTERFACE ${PROJECT_INCLUDE_GEN_DIR}) + add_dependencies(dnbd3-version dnbd3-generate-version) +endmacro(gen_project_version VERSION_INPUT_FILE VERSION_INPUT_FILE_TEMPLATE VERSION_OUTPUT_FILE) + +# macro to get Git version information +macro(get_repository_version REPOSITORY_VERSION REPOSITORY_VERSION_SHORT REPOSITORY_BRANCH VERSION_HEADER_FILE VERSION_BUILD_TYPE GIT_EXECUTABLE REPOSITORY_DIR) + # set empty Git version information + set(GIT_VERSION "") + # set empty Git branch information + set(GIT_BRANCH "") + + # check if generated version header from source package is available + if(EXISTS ${VERSION_HEADER_FILE}) + # get version information from the generated version header of the source package + file(READ ${VERSION_HEADER_FILE} GIT_VERSION_VERBOSE) + string(REGEX MATCH "DNBD3_VERSION[ \t]+\"([0-9][A-Za-z0-9.+~-]*)\"" GIT_VERSION ${GIT_VERSION_VERBOSE}) + set(GIT_VERSION "${CMAKE_MATCH_1}") + + # get branch information from the generated version header of the source package + file(READ ${VERSION_HEADER_FILE} GIT_BRANCH_VERBOSE) + string(REGEX MATCH "DNBD3_BRANCH[ \t]+\"([0-9][A-Za-z0-9.+~-]*)\"" GIT_BRANCH ${GIT_BRANCH_VERBOSE}) + set(GIT_BRANCH "${CMAKE_MATCH_1}") + else(EXISTS ${VERSION_HEADER_FILE}) + # get detailed Git version information from Git repository + execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags HEAD + WORKING_DIRECTORY ${REPOSITORY_DIR} + OUTPUT_VARIABLE GIT_VERSION_VERBOSE + RESULT_VARIABLE GIT_RETURN_CODE + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + + # parse version information from repository if Git command succeeds + if(GIT_RETURN_CODE EQUAL 0) + # remove the first letter of the version to satisfy packaging rules + string(REGEX MATCH "([0-9]+:)?[0-9][A-Za-z0-9.+~-]*" GIT_VERSION ${GIT_VERSION_VERBOSE}) + endif(GIT_RETURN_CODE EQUAL 0) + + # overwrite version from Git if version is unknown + if(GIT_VERSION STREQUAL "") + # overwrite version information with unknown version 'v0.0' + set(GIT_VERSION "0.0") + + # print a message in Release build configuration to warn about the unknown version + if(${VERSION_BUILD_TYPE} MATCHES "Release") + message(WARNING "The version information from Git tags in this dnbd3 Git repository is missing! Please fetch all Git tags of this repository for a ${VERSION_BUILD_TYPE} build!") + endif(${VERSION_BUILD_TYPE} MATCHES "Release") + endif(GIT_VERSION STREQUAL "") + + set(${REPOSITORY_VERSION_SHORT} ${GIT_VERSION}) + + # get current branch of Git repository + execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD + WORKING_DIRECTORY ${REPOSITORY_DIR} + OUTPUT_VARIABLE GIT_BRANCH_VERBOSE + RESULT_VARIABLE GIT_RETURN_CODE + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + + # check output to get branch information + if(GIT_RETURN_CODE EQUAL 0) + set(GIT_BRANCH ${GIT_BRANCH_VERBOSE}) + endif(GIT_RETURN_CODE EQUAL 0) + + if(GIT_BRANCH STREQUAL "") + # overwrite branch information with 'unknown' branch + set(GIT_BRANCH "unknown") + + # print a message in Release build configuration to warn about the unknown branch + if(${VERSION_BUILD_TYPE} MATCHES "Release") + message(WARNING "The current branch in the dnbd3 Git repository is unknown! Please check the branches of this repository for a ${VERSION_BUILD_TYPE} build!") + endif(${VERSION_BUILD_TYPE} MATCHES "Release") + endif(GIT_BRANCH STREQUAL "") + + # get status of Git repository + execute_process(COMMAND ${GIT_EXECUTABLE} status --porcelain + WORKING_DIRECTORY ${REPOSITORY_DIR} + OUTPUT_VARIABLE GIT_STATUS + RESULT_VARIABLE GIT_RETURN_CODE + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + + # check if Git repository is dirty + if(GIT_RETURN_CODE EQUAL 0 AND NOT GIT_STATUS STREQUAL "") + # the Git repository is dirty, thus extend the version information + set(GIT_VERSION "${GIT_VERSION}+MOD") + + # print a message in Release build configuration to warn about the dirty repository + if(${VERSION_BUILD_TYPE} MATCHES "Release") + message(WARNING "This dnbd3 Git repository is dirty! Please commit or revert all changes for a ${VERSION_BUILD_TYPE} build!") + endif(${VERSION_BUILD_TYPE} MATCHES "Release") + endif(GIT_RETURN_CODE EQUAL 0 AND NOT GIT_STATUS STREQUAL "") + endif(EXISTS ${VERSION_HEADER_FILE}) + + # return version and branch to caller + set(${REPOSITORY_VERSION} ${GIT_VERSION}) + set(${REPOSITORY_BRANCH} ${GIT_BRANCH}) +endmacro(get_repository_version) diff --git a/cmake/toolchain/Aarch64LinuxGnu.cmake b/cmake/toolchain/Aarch64LinuxGnu.cmake new file mode 100644 index 0000000..59c5f00 --- /dev/null +++ b/cmake/toolchain/Aarch64LinuxGnu.cmake @@ -0,0 +1,24 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# CMAKE toolchain file for cross compilation with aarch64-linux-gnu-gcc +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR aarch64) + +set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc) +set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++) +set(CMAKE_LINKER aarch64-linux-gnu-ld) +set(CMAKE_ASM_COMPILER aarch64-linux-gnu-as) +set(CMAKE_OBJCOPY aarch64-linux-gnu-objcopy) +set(CMAKE_STRIP aarch64-linux-gnu-strip) +set(CMAKE_CPP aarch64-linux-gnu-cpp) + +# path of headers and libraries for aarch64-linux-gnu target +set(CMAKE_FIND_ROOT_PATH "/usr/aarch64-linux-gnu") + +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/cmake/toolchain/PowerpcLinuxGnu.cmake b/cmake/toolchain/PowerpcLinuxGnu.cmake new file mode 100644 index 0000000..d3c1ca5 --- /dev/null +++ b/cmake/toolchain/PowerpcLinuxGnu.cmake @@ -0,0 +1,24 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# CMAKE toolchain file for cross compilation with powerpc-linux-gnu-gcc +# +# Copyright (C) 2020 Manuel Bentele <development@manuel-bentele.de> +# + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR ppc) + +set(CMAKE_C_COMPILER powerpc-linux-gnu-gcc) +set(CMAKE_CXX_COMPILER powerpc-linux-gnu-g++) +set(CMAKE_LINKER powerpc-linux-gnu-ld) +set(CMAKE_ASM_COMPILER powerpc-linux-gnu-as) +set(CMAKE_OBJCOPY powerpc-linux-gnu-objcopy) +set(CMAKE_STRIP powerpc-linux-gnu-strip) +set(CMAKE_CPP powerpc-linux-gnu-cpp) + +# path of headers and libraries for powerpc-linux-gnu target +set(CMAKE_FIND_ROOT_PATH "/usr/powerpc-linux-gnu") + +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) |