From ba088c7b1ec6e1ce360d62cfe1e1a3993319adf5 Mon Sep 17 00:00:00 2001 From: Nick Grifka Date: Wed, 17 Apr 2024 09:52:32 -0700 Subject: [PATCH] Initial structure (#1) Set up some initial structure to the project that includes the following: - empty public header per platform - empty static library per platform - prepare-machine.ps1 tool - build.ps1 tool - CI pipeline that builds the library for all platforms - dependabot All of this was taken from https://github.com/microsoft/msquic and trimmed down. There may still be some unnecessary stuff that is lingering (especially the cmake stuff which is foreign to me), but I think this is a reasonable start. --- .github/dependabot.yml | 9 + .github/workflows/build-reuse-unix.yml | 79 ++ .github/workflows/build-reuse-win.yml | 66 ++ .github/workflows/build-reuse-winkernel.yml | 65 ++ .github/workflows/build.yml | 115 +++ CMakeLists.txt | 340 +++++++ cmake/GitCommands.cmake | 87 ++ cmake/PdbAltPath.txt | 1 + cmake/rpath.txt | 0 cmake/toolchains/aarch64-linux.cmake | 68 ++ cmake/toolchains/arm-linux.cmake | 61 ++ .../arm-pi-gnueabihf.toolchain.cmake | 98 ++ cmake/toolchains/arm.toolchain.cmake | 97 ++ cmake/toolchains/gnu.toolchain.cmake | 134 +++ cmake/toolchains/ios.cmake | 927 ++++++++++++++++++ cxplat.kernel.sln | 35 + inc/cxplat.h | 22 + inc/cxplat_posix.h | 24 + inc/cxplat_winkernel.h | 24 + inc/cxplat_winuser.h | 24 + scripts/build.ps1 | 423 ++++++++ scripts/get-buildconfig.ps1 | 118 +++ scripts/prepare-machine.ps1 | 71 ++ src/lib/CMakeLists.txt | 12 + src/lib/cxplat.kernel.vcxproj | 102 ++ src/lib/cxplat_posix.c | 1 + src/lib/cxplat_winkernel.c | 1 + src/lib/cxplat_winuser.c | 1 + 28 files changed, 3005 insertions(+) create mode 100644 .github/dependabot.yml create mode 100644 .github/workflows/build-reuse-unix.yml create mode 100644 .github/workflows/build-reuse-win.yml create mode 100644 .github/workflows/build-reuse-winkernel.yml create mode 100644 .github/workflows/build.yml create mode 100644 CMakeLists.txt create mode 100644 cmake/GitCommands.cmake create mode 100644 cmake/PdbAltPath.txt create mode 100644 cmake/rpath.txt create mode 100644 cmake/toolchains/aarch64-linux.cmake create mode 100644 cmake/toolchains/arm-linux.cmake create mode 100644 cmake/toolchains/arm-pi-gnueabihf.toolchain.cmake create mode 100644 cmake/toolchains/arm.toolchain.cmake create mode 100644 cmake/toolchains/gnu.toolchain.cmake create mode 100644 cmake/toolchains/ios.cmake create mode 100644 cxplat.kernel.sln create mode 100644 inc/cxplat.h create mode 100644 inc/cxplat_posix.h create mode 100644 inc/cxplat_winkernel.h create mode 100644 inc/cxplat_winuser.h create mode 100644 scripts/build.ps1 create mode 100644 scripts/get-buildconfig.ps1 create mode 100644 scripts/prepare-machine.ps1 create mode 100644 src/lib/CMakeLists.txt create mode 100644 src/lib/cxplat.kernel.vcxproj create mode 100644 src/lib/cxplat_posix.c create mode 100644 src/lib/cxplat_winkernel.c create mode 100644 src/lib/cxplat_winuser.c diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..e56fa41 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,9 @@ + +version: 2 +updates: + + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "weekly" + day: "saturday" diff --git a/.github/workflows/build-reuse-unix.yml b/.github/workflows/build-reuse-unix.yml new file mode 100644 index 0000000..4ada37b --- /dev/null +++ b/.github/workflows/build-reuse-unix.yml @@ -0,0 +1,79 @@ +name: Build Unix + +# The caller is responsible for making sure all options passed to this workflow are valid and compatible with each other. + +on: + workflow_call: + inputs: + ref: + required: false + default: '' + type: string + config: + required: false + default: 'Release' + type: string + # options: + # - Debug + # - Release + plat: + required: false + type: string + default: 'linux' + # options: + # - linux + # - android + # - ios + # - macos + os: + required: false + type: string + default: 'ubuntu-20.04' + # options: + # - ubuntu-20.04 + # - ubuntu-22.04 + # - macos-12 + arch: + required: false + default: 'x64' + type: string + # options: + # - x86 + # - x64 + # - arm + # - arm64 + clang: + required: false + default: '' + type: string + +permissions: read-all + +jobs: + build-unix-reuse: + name: Build + runs-on: ${{ inputs.os }} + container: + image: ${{ inputs.plat == 'linux' && format('ghcr.io/microsoft/msquic/linux-build-xcomp:{0}', inputs.os) || '' }} + steps: + - name: Checkout repository + uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 + with: + repository: microsoft/cxplat + ref: ${{ inputs.ref }} + - name: Set ownership + if: inputs.plat == 'linux' + run: | + # this is to fix GIT not liking owner of the checkout dir + chown -R $(id -u):$(id -g) $PWD + - name: Prepare Machine + shell: pwsh + run: scripts/prepare-machine.ps1 -ForBuild + - name: Build + shell: pwsh + run: scripts/build.ps1 -Config ${{ inputs.config }} -Platform ${{ inputs.plat }} -Arch ${{ inputs.arch }} ${{ inputs.clang }} -OneBranch + - name: Upload build artifacts + uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 + with: + name: ${{ inputs.config }}-${{ inputs.plat }}-${{ inputs.os }}-${{ inputs.arch }}-${{ inputs.clang }} + path: artifacts diff --git a/.github/workflows/build-reuse-win.yml b/.github/workflows/build-reuse-win.yml new file mode 100644 index 0000000..6f28e35 --- /dev/null +++ b/.github/workflows/build-reuse-win.yml @@ -0,0 +1,66 @@ +name: Build WinUser + +# The caller is responsible for making sure all options passed to this workflow are valid and compatible with each other. + +on: + workflow_call: + inputs: + ref: + required: false + default: '' + type: string + config: + required: false + default: 'Release' + type: string + # options: + # - Debug + # - Release + plat: + required: false + type: string + default: 'windows' + # options: + # - windows + # - uwp + # - winkernel + os: + required: false + type: string + default: 'windows-2019' + # options: + # - windows-2019 + # - windows-2022 + arch: + required: false + default: 'x64' + type: string + # options: + # - x86 + # - x64 + # - arm64 + +permissions: read-all + +jobs: + build-windows-reuse: + if: inputs.plat == 'windows' || inputs.plat == 'uwp' + name: Build + runs-on: ${{ inputs.os }} + steps: + - name: Checkout repository + uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 + with: + repository: microsoft/cxplat + ref: ${{ inputs.ref }} + - name: Prepare Machine + shell: pwsh + run: scripts/prepare-machine.ps1 -ForBuild + - name: Build + shell: pwsh + run: scripts/build.ps1 -Config ${{ inputs.config }} -Platform ${{ inputs.plat }} -Arch ${{ inputs.arch }} + - name: Upload build artifacts + uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 + with: + name: ${{ inputs.config }}-${{ inputs.plat }}-${{ inputs.os }}-${{ inputs.arch }} + path: artifacts diff --git a/.github/workflows/build-reuse-winkernel.yml b/.github/workflows/build-reuse-winkernel.yml new file mode 100644 index 0000000..1400dcd --- /dev/null +++ b/.github/workflows/build-reuse-winkernel.yml @@ -0,0 +1,65 @@ +name: Build WinKernel + +# The caller is responsible for making sure all options passed to this workflow are valid and compatible with each other. + +on: + workflow_call: + inputs: + ref: + required: false + default: '' + type: string + config: + required: false + default: 'Release' + type: string + # options: + # - Debug + # - Release + plat: + required: false + type: string + default: 'winkernel' + # options: + # - winkernel + os: + required: false + type: string + default: 'windows-2019' + # options: + # - windows-2019 + # - windows-2022 + arch: + required: false + default: 'x64' + type: string + # options: + # - x86 + # - x64 + # - arm64 + +permissions: read-all + +jobs: + build-windows-kernel-reuse: + name: Build + runs-on: ${{ inputs.os }} + steps: + - name: Checkout repository + uses: actions/checkout@9bb56186c3b09b4f86b1c65136769dd318469633 + with: + repository: microsoft/cxplat + ref: ${{ inputs.ref }} + - name: Prepare Machine + shell: pwsh + run: scripts/prepare-machine.ps1 -ForBuild + - name: Add msbuild to PATH + uses: microsoft/setup-msbuild@6fb02220983dee41ce7ae257b6f4d8f9bf5ed4ce + - name: Build + shell: pwsh + run: scripts/build.ps1 -Config ${{ inputs.config }} -Platform ${{ inputs.plat }} -Arch ${{ inputs.arch }} + - name: Upload build artifacts + uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 + with: + name: ${{ inputs.config }}-${{ inputs.plat }}-${{ inputs.os }}-${{ inputs.arch }} + path: artifacts diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..2e2744b --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,115 @@ +name: Build + +on: + workflow_dispatch: + push: + branches: + - main + - release/* + pull_request: + branches: + - main + - release/* + +concurrency: + # Cancel any workflow currently in progress for the same PR. + # Allow running concurrently with any other commits. + group: build-${{ github.event.pull_request.number || github.sha }} + cancel-in-progress: true + +permissions: read-all + +jobs: + build-windows: + name: WinUser + needs: [] + strategy: + fail-fast: false + matrix: + config: ['Debug', 'Release'] + plat: [windows] # TODO: Support uwp, gamecore_console + os: ['windows-2022'] + arch: [x86, x64, arm64] + uses: ./.github/workflows/build-reuse-win.yml + with: + config: ${{ matrix.config }} + plat: ${{ matrix.plat }} + os: ${{ matrix.os }} + arch: ${{ matrix.arch }} + + build-windows-kernel: + name: WinKernel + needs: [] + strategy: + fail-fast: false + matrix: + config: ['Debug', 'Release'] + plat: [winkernel] + os: ['windows-2022'] + arch: [x64, arm64] + uses: ./.github/workflows/build-reuse-winkernel.yml + with: + config: ${{ matrix.config }} + plat: ${{ matrix.plat }} + os: ${{ matrix.os }} + arch: ${{ matrix.arch }} + + build-ubuntu-cross-compile: + name: UbuntuArm + needs: [] + strategy: + fail-fast: false + matrix: + config: ['Debug', 'Release'] + plat: [linux] + os: ['ubuntu-20.04', 'ubuntu-22.04'] + arch: [arm, arm64] + uses: ./.github/workflows/build-reuse-unix.yml + with: + config: ${{ matrix.config }} + plat: ${{ matrix.plat }} + os: ${{ matrix.os }} + arch: ${{ matrix.arch }} + + build-ubuntu: + name: Ubuntu + needs: [] + strategy: + fail-fast: false + matrix: + config: ['Debug', 'Release'] + plat: [linux, android] + os: ['ubuntu-20.04', 'ubuntu-22.04'] + arch: [x86, x64] + clang: ['', '-Clang'] + exclude: + # Android doesn't support x86 + - plat: android + arch: x86 + # Android doesn't use Clang + - plat: android + clang: '-Clang' + uses: ./.github/workflows/build-reuse-unix.yml + with: + config: ${{ matrix.config }} + plat: ${{ matrix.plat }} + os: ${{ matrix.os }} + arch: ${{ matrix.arch }} + clang: ${{ matrix.clang }} + + build-darwin: + name: MacOs + needs: [] + strategy: + fail-fast: false + matrix: + config: ['Debug', 'Release'] + plat: [macos, ios] + os: ['macos-12'] + arch: [x64, arm64] + uses: ./.github/workflows/build-reuse-unix.yml + with: + config: ${{ matrix.config }} + plat: ${{ matrix.plat }} + os: ${{ matrix.os }} + arch: ${{ matrix.arch }} diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..0affa08 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,340 @@ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. + +if ("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows") + cmake_minimum_required(VERSION 3.20) +else() + cmake_minimum_required(VERSION 3.16) +endif() + +# Disable in-source builds to prevent source tree corruption. +if("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}") + message(FATAL_ERROR " +FATAL: In-source builds are not allowed. + You should create a separate directory for build files. +") +endif() + +message(STATUS "CMAKE Version: ${CMAKE_VERSION}") + +set_property(GLOBAL PROPERTY USE_FOLDERS ON) + +message(STATUS "Source Dir: ${CMAKE_CURRENT_SOURCE_DIR}") +message(STATUS "Host System name: ${CMAKE_HOST_SYSTEM_NAME}") +if ("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows") + if (NOT DEFINED CMAKE_SYSTEM_VERSION) + set(CMAKE_SYSTEM_VERSION 10.0.22621.0 CACHE STRING INTERNAL FORCE) + endif() +endif() + +if(POLICY CMP0091) + cmake_policy(SET CMP0091 NEW) + message(STATUS "Setting policy 0091") +else() + message(WARNING "CMake version too old to support Policy 0091; CRT static linking won't work") +endif() + +if (POLICY CMP0111) + cmake_policy(SET CMP0111 NEW) +endif() + +project(cxplat) + +# Set a default build type if none was specified +set(default_build_type "Release") + +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE + STRING "Choose the type of build." FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Release" "MinSizeRel" "RelWithDebInfo") +endif() + +message(STATUS "System name: ${CMAKE_SYSTEM_NAME}") +message(STATUS "System version: ${CMAKE_SYSTEM_VERSION}") +message(STATUS "Platform version: ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}") +message(STATUS "Build type: ${CMAKE_BUILD_TYPE}") + +set(CXPLAT_MAJOR_VERSION 0) +set(CXPLAT_FULL_VERSION 0.1.0) + +if (WIN32) + set(CX_PLATFORM "winuser") +elseif (APPLE) + set(CX_PLATFORM "darwin") +elseif (UNIX) + set(CX_PLATFORM "linux") +endif() +message(STATUS "Platform: ${CX_PLATFORM}") + +set(FILENAME_DEP_REPLACE "get_filename_component(SELF_DIR \"$\{CMAKE_CURRENT_LIST_FILE\}\" PATH)") +set(SELF_DIR "$\{SELF_DIR\}") + +option(CXPLAT_UWP_BUILD "Build for UWP" OFF) +option(CXPLAT_GAMECORE_BUILD "Build for GameCore" OFF) +option(CXPLAT_EMBED_GIT_HASH "Embed git commit hash in the binary" ON) +option(CXPLAT_PDBALTPATH "Enable PDBALTPATH setting on MSVC" ON) +option(CXPLAT_OPTIMIZE_LOCAL "Optimize code for local machine architecture" OFF) +option(CXPLAT_CI "CI Specific build" OFF) +option(CXPLAT_SKIP_CI_CHECKS "Disable CI specific build checks" OFF) +option(CXPLAT_OFFICIAL_RELEASE "Configured the build for an official release" OFF) +set(CXPLAT_FOLDER_PREFIX "" CACHE STRING "Optional prefix for source group folders when using an IDE generator") +set(CXPLAT_LIBRARY_NAME "cxplat" CACHE STRING "Override the output library name") + +if (CXPLAT_GAMECORE_BUILD) + if(${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION} VERSION_LESS "10.0.20348.0") + message(FATAL_ERROR "gamecore builds require Windows 10 SDK version 20348 or later.") + endif() +endif() + +if (NOT CXPLAT_BUILD_SHARED) + cmake_minimum_required(VERSION 3.20) +endif() + +if (CXPLAT_PDBALTPATH AND MSVC) +# Disabled in all cases because generation is broken. +# file(READ ${CMAKE_CURRENT_LIST_DIR}/cmake/PdbAltPath.txt PDBALTPATH) +# set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${PDBALTPATH}") +# set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${PDBALTPATH}") +# message(STATUS ${CMAKE_EXE_LINKER_FLAGS}) +endif() + +include(${PROJECT_SOURCE_DIR}/cmake/GitCommands.cmake) +get_git_current_hash(${PROJECT_SOURCE_DIR} GIT_CURRENT_HASH) + +if(NOT GIT_CURRENT_HASH) + message("Failed to get git hash. Binary will not contain git hash") + set(CXPLAT_EMBED_GIT_HASH OFF) +endif() + +set(CXPLAT_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}) +set(CXPLAT_OUTPUT_DIR ${CXPLAT_BUILD_DIR}/bin/$,Debug,Release> CACHE STRING "Output directory for build artifacts") + +set(CXPLAT_VER_BUILD_ID "0" CACHE STRING "The version build ID") +set(CXPLAT_VER_SUFFIX "-private" CACHE STRING "The version suffix") + +message(STATUS "Version Build ID: ${CXPLAT_VER_BUILD_ID}") +message(STATUS "Version Suffix: ${CXPLAT_VER_SUFFIX}") + +set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CXPLAT_BUILD_DIR}/obj/$,Debug,Release>) + +set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CXPLAT_OUTPUT_DIR}) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CXPLAT_OUTPUT_DIR}) +set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${CXPLAT_OUTPUT_DIR}) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CXPLAT_OUTPUT_DIR}) +set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CXPLAT_OUTPUT_DIR}) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CXPLAT_OUTPUT_DIR}) + +if (WIN32) + set(CXPLAT_WARNING_FLAGS /WX /W4 /sdl /wd4206 CACHE INTERNAL "") + set(CXPLAT_COMMON_FLAGS "") + + include(CheckCCompilerFlag) + + if(NOT CXPLAT_ENABLE_SANITIZERS) + check_c_compiler_flag(/Qspectre HAS_SPECTRE) + endif() + if(HAS_SPECTRE) + list(APPEND CXPLAT_COMMON_FLAGS /Qspectre) + endif() + + check_c_compiler_flag(/guard:cf HAS_GUARDCF) + if(HAS_GUARDCF) + list(APPEND CXPLAT_COMMON_FLAGS /guard:cf) + endif() + + # Require /Qspectre and /guard:cf in CI builds + if(CXPLAT_CI AND NOT CXPLAT_SKIP_CI_CHECKS) + if(NOT HAS_GUARDCF) + message(FATAL_ERROR "/guard:cf must exist for CI builds") + endif() + if(NOT HAS_SPECTRE AND NOT CXPLAT_ENABLE_SANITIZERS AND NOT CXPLAT_UWP_BUILD) + message(FATAL_ERROR "/Qspectre must exist for CI builds") + endif() + endif() + + if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC") + list(APPEND CXPLAT_COMMON_FLAGS /MP) + endif() + set(CXPLAT_COMMON_DEFINES WIN32_LEAN_AND_MEAN SECURITY_WIN32) +else() + + include(CheckSymbolExists) + include(CheckFunctionExists) + include(CheckIncludeFile) + + if (CX_PLATFORM STREQUAL "linux") + include(CheckCCompilerFlag) + endif() + + set(CXPLAT_COMMON_FLAGS "") + set(CXPLAT_COMMON_DEFINES _GNU_SOURCE) + + set(CXPLAT_WARNING_FLAGS -Werror -Wall -Wextra -Wformat=2 -Wno-type-limits + -Wno-unknown-pragmas -Wno-multichar -Wno-missing-field-initializers + CACHE INTERNAL "") + if (CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0) + list(APPEND CXPLAT_WARNING_FLAGS -Wno-strict-aliasing) + elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + list(APPEND CXPLAT_WARNING_FLAGS -Wno-missing-braces -Wno-microsoft-anon-tag) + endif() +endif() + +list(APPEND CXPLAT_COMMON_DEFINES VER_BUILD_ID=${CXPLAT_VER_BUILD_ID}) +list(APPEND CXPLAT_COMMON_DEFINES VER_SUFFIX=${CXPLAT_VER_SUFFIX}) + +if (CXPLAT_EMBED_GIT_HASH) + list(APPEND CXPLAT_COMMON_DEFINES VER_GIT_HASH=${GIT_CURRENT_HASH}) +endif() + +if(CXPLAT_OFFICIAL_RELEASE) + list(APPEND CXPLAT_COMMON_DEFINES CXPLAT_OFFICIAL_RELEASE=1) + message(STATUS "Configured for official release build") +endif() + +if (NOT MSVC AND NOT APPLE AND NOT ANDROID) + find_library(ATOMIC NAMES atomic libatomic.so.1) + if (ATOMIC) + message(STATUS "Found libatomic: ${ATOMIC}") + else() + message(STATUS "libatomic not found. If build fails, install libatomic") + endif() + + find_library(NUMA NAMES NUMA libnuma.so.1) + if (NUMA) + message(STATUS "Found libnuma: ${NUMA}") + find_file(NUMA-HEADER NAMES "numa.h") + if (NUMA-HEADER) + message(STATUS "Found numa.h: ${NUMA-HEADER}") + list(APPEND CXPLAT_COMMON_DEFINES CXPLAT_NUMA_AWARE) + else() + message(STATUS "numa.h not found. If build fails, install libnuma-dev") + endif() + else() + message(STATUS "libnuma not found. If build fails, install libnuma") + endif() +endif() + +if(WIN32) + if (CMAKE_GENERATOR_PLATFORM STREQUAL "") + string(TOLOWER ${CMAKE_SYSTEM_PROCESSOR} SYSTEM_PROCESSOR) + else() + string(TOLOWER ${CMAKE_GENERATOR_PLATFORM} SYSTEM_PROCESSOR) + endif() + + if (CXPLAT_UWP_BUILD) + list(APPEND CXPLAT_COMMON_DEFINES CXPLAT_UWP_BUILD CXPLAT_RESTRICTED_BUILD) + set(CMAKE_CXX_STANDARD_LIBRARIES "") + set(CMAKE_CXX_STANDARD_LIBRARIES_INIT "") + set(CMAKE_C_STANDARD_LIBRARIES "") + set(CMAKE_C_STANDARD_LIBRARIES_INIT "") + endif() + + if (CXPLAT_GAMECORE_BUILD) + list(APPEND CXPLAT_COMMON_DEFINES WINAPI_FAMILY=WINAPI_FAMILY_GAMES CXPLAT_GAMECORE_BUILD CXPLAT_RESTRICTED_BUILD) + set(CMAKE_CXX_STANDARD_LIBRARIES "") + set(CMAKE_CXX_STANDARD_LIBRARIES_INIT "") + set(CMAKE_C_STANDARD_LIBRARIES "") + set(CMAKE_C_STANDARD_LIBRARIES_INIT "") + + set(UnsupportedLibs advapi32.lib comctl32.lib comsupp.lib dbghelp.lib gdi32.lib gdiplus.lib guardcfw.lib kernel32.lib mmc.lib msimg32.lib msvcole.lib msvcoled.lib mswsock.lib ntstrsafe.lib ole2.lib ole2autd.lib ole2auto.lib ole2d.lib ole2ui.lib ole2uid.lib ole32.lib oleacc.lib oleaut32.lib oledlg.lib oledlgd.lib oldnames.lib runtimeobject.lib shell32.lib shlwapi.lib strsafe.lib urlmon.lib user32.lib userenv.lib wlmole.lib wlmoled.lib onecore.lib) + set(Console_LinkOptions /DYNAMICBASE /NXCOMPAT) + foreach(arg ${UnsupportedLibs}) + list(APPEND Console_LinkOptions "/NODEFAULTLIB:${arg}") + endforeach() + + set(Console_ArchOptions /favor:AMD64) + + list(APPEND Console_ArchOptions /arch:AVX) + + # Locate Software Development Kits + get_filename_component(Console_SdkRoot "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\GDK;InstallPath]" ABSOLUTE CACHE) + + if(NOT EXISTS ${Console_SdkRoot}) + if (EXISTS "C:\\Program Files (x86)\\Microsoft GDK") + set(Console_SdkRoot "C:\\Program Files (x86)\\Microsoft GDK") + else() + message(FATAL_ERROR "Could not find GDK install") + endif() + endif() + + file(GLOB GdkFolders ${Console_SdkRoot}/*) + + set(XdkEditionTarget 5000000000) + + foreach(GdkFolder ${GdkFolders}) + if (IS_DIRECTORY ${GdkFolder}) + file(GLOB SubDirs ${GdkFolder}/*) + foreach(SubDir ${SubDirs}) + if (SubDir MATCHES "GXDK$") + # Make sure library exists + set(GxdkLibDirectory "${SubDir}/gameKit/Lib/amd64") + set(GxdkRuntimeLib "${GxdkLibDirectory}/xgameplatform.lib") + if (EXISTS ${GxdkRuntimeLib}) + get_filename_component(PotentialXdkEditionTarget ${GdkFolder} NAME) + # Always select lowest version equal or higher than 211000 + if (PotentialXdkEditionTarget LESS XdkEditionTarget AND + PotentialXdkEditionTarget GREATER_EQUAL 211000) + set(XdkEditionTarget ${PotentialXdkEditionTarget}) + set(Console_EndpointLibRoot "${GxdkLibDirectory}") + endif() + endif() + endif() + endforeach() + endif() + endforeach() + + if (XdkEditionTarget EQUAL 5000000000) + message(FATAL_ERROR "Gxdk Target Not Found") + endif() + + message(STATUS "Chosing ${XdkEditionTarget} with root ${Console_EndpointLibRoot}") + + endif() + + set(CXPLAT_C_FLAGS ${CXPLAT_COMMON_FLAGS}) + set(CXPLAT_CXX_FLAGS ${CXPLAT_COMMON_FLAGS} /EHsc /permissive-) + + # These cannot be updated until CMake 3.13 + set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /GL /Zi") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GL /Zi") + set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG /IGNORE:4075 /DEBUG /OPT:REF /OPT:ICF") + set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG /IGNORE:4075 /DEBUG /OPT:REF /OPT:ICF") + +else() #!WIN32 + # Custom build flags. + + if (CXPLAT_OPTIMIZE_LOCAL AND NOT CMAKE_SYSTEM_PROCESSOR STREQUAL arm) + set(MARCH -march=native) + endif() + + set(CMAKE_C_FLAGS_DEBUG "-Og -fno-omit-frame-pointer") + set(CMAKE_C_FLAGS_MINSIZEREL "-Os -DNDEBUG") + set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O3 -fno-omit-frame-pointer ${MARCH} -DNDEBUG") + set(CMAKE_C_FLAGS_RELEASE "-O3 ${MARCH} -DNDEBUG") + if (CX_PLATFORM STREQUAL "darwin") + set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf") + set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -gdwarf") + else() + set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -ggdb3") + set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -ggdb3") + endif() + set(CMAKE_CXX_FLAGS_DEBUG ${CMAKE_C_FLAGS_DEBUG}) + set(CMAKE_CXX_FLAGS_MINSIZEREL ${CMAKE_C_FLAGS_MINSIZEREL}) + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_C_FLAGS_RELWITHDEBINFO}) + set(CMAKE_CXX_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE}) + + list(APPEND CXPLAT_COMMON_FLAGS -fms-extensions -fPIC) + if (CX_PLATFORM STREQUAL "darwin") + list(APPEND CXPLAT_COMMON_DEFINES CX_PLATFORM_DARWIN) + list(APPEND CXPLAT_COMMON_FLAGS -Wno-microsoft-anon-tag -Wno-tautological-constant-out-of-range-compare -Wmissing-field-initializers) + else() + list(APPEND CXPLAT_COMMON_DEFINES CX_PLATFORM_LINUX) + endif() + + set(CXPLAT_C_FLAGS ${CXPLAT_COMMON_FLAGS}) + set(CXPLAT_CXX_FLAGS ${CXPLAT_COMMON_FLAGS}) +endif() + +# Product code +add_subdirectory(src/lib/) diff --git a/cmake/GitCommands.cmake b/cmake/GitCommands.cmake new file mode 100644 index 0000000..9e2fc72 --- /dev/null +++ b/cmake/GitCommands.cmake @@ -0,0 +1,87 @@ +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. + +find_package(Git QUIET) +if (NOT Git_FOUND) + message(STATUS "Unable to find git, which is needed for versioning") +endif() + +function(get_git_dir DIRECTORY OUTPUT_VAR) + execute_process( + COMMAND + ${GIT_EXECUTABLE} rev-parse --git-dir + WORKING_DIRECTORY + ${DIRECTORY} + RESULT_VARIABLE + GIT_DIR_RESULT + OUTPUT_VARIABLE + GIT_DIR_OUTPUT + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + # Allow to fail + set(${OUTPUT_VAR} ${GIT_DIR_OUTPUT} PARENT_SCOPE) +endfunction() + +function(get_git_current_hash DIRECTORY OUTPUT_VAR) + execute_process( + COMMAND + ${GIT_EXECUTABLE} rev-parse --verify HEAD + WORKING_DIRECTORY + ${DIRECTORY} + RESULT_VARIABLE + GIT_CURRENT_HASH_RESULT + OUTPUT_VARIABLE + GIT_CURRENT_HASH_OUTPUT + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + + if (NOT ("${GIT_CURRENT_HASH_RESULT}" STREQUAL "0")) + message(STATUS ${GIT_CURRENT_HASH_OUTPUT}) + message(STATUS "Failed to get ${DIRECTORY} git hash") + else() + set(${OUTPUT_VAR} ${GIT_CURRENT_HASH_OUTPUT} PARENT_SCOPE) + endif() +endfunction() + +function(get_git_remote_url DIRECTORY OUTPUT_VAR) + execute_process( + COMMAND + ${GIT_EXECUTABLE} config --get remote.origin.url + RESULT_VARIABLE + GIT_REMOTE_URL_RESULT + OUTPUT_VARIABLE + GIT_REMOTE_URL_OUTPUT + OUTPUT_STRIP_TRAILING_WHITESPACE + WORKING_DIRECTORY + ${DIRECTORY} + ) + + if (NOT ("${GIT_REMOTE_URL_RESULT}" STREQUAL "0")) + message(${GIT_REMOTE_URL_OUTPUT}) + message(FATAL_ERROR "Failed to get ${DIRECTORY} git remote") + endif() + + set(${OUTPUT_VAR} ${GIT_REMOTE_URL_OUTPUT} PARENT_SCOPE) +endfunction() + +function(run_git_submodule_foreach CMD DIRECTORY OUTPUT_VALUE) + execute_process( + COMMAND + ${GIT_EXECUTABLE} submodule foreach --quiet --recursive "${CMD}" + RESULT_VARIABLE + GIT_SUBMODULE_CMD_RESULT + OUTPUT_VARIABLE + GIT_SUBMODULE_CMD_OUTPUT + OUTPUT_STRIP_TRAILING_WHITESPACE + WORKING_DIRECTORY + ${DIRECTORY} + ) + + if (NOT ("${GIT_SUBMODULE_CMD_RESULT}" STREQUAL "0")) + message(${GIT_SUBMODULE_CMD_OUTPUT}) + message(FATAL_ERROR "Failed to run git submodule foreach command: ${CMD} in ${DIRECTORY}") + endif() + set(${OUTPUT_VALUE} ${GIT_SUBMODULE_CMD_OUTPUT} PARENT_SCOPE) +endfunction() diff --git a/cmake/PdbAltPath.txt b/cmake/PdbAltPath.txt new file mode 100644 index 0000000..0189450 --- /dev/null +++ b/cmake/PdbAltPath.txt @@ -0,0 +1 @@ +/PDBALTPATH:%_PDB% diff --git a/cmake/rpath.txt b/cmake/rpath.txt new file mode 100644 index 0000000..e69de29 diff --git a/cmake/toolchains/aarch64-linux.cmake b/cmake/toolchains/aarch64-linux.cmake new file mode 100644 index 0000000..82a050d --- /dev/null +++ b/cmake/toolchains/aarch64-linux.cmake @@ -0,0 +1,68 @@ +set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version") +set(GNU_MACHINE "aarch64-linux-gnu" CACHE STRING "GNU compiler triplet") + +if(COMMAND toolchain_save_config) + return() # prevent recursive call +endif() + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_VERSION 1) +if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR) + set(CMAKE_SYSTEM_PROCESSOR aarch64) +else() + #message("CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}") +endif() + +include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake") + +if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm AND NOT ARM_IGNORE_FP) + set(FLOAT_ABI_SUFFIX "") + if(NOT SOFTFP) + set(FLOAT_ABI_SUFFIX "hf") + endif() +endif() + +if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x") + set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}") +endif() + +find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX}) +if (NOT CMAKE_C_COMPILER) + message(FATAL_ERROR "${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX} not found") +endif() + +find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX}) +if (NOT CMAKE_CXX_COMPILER) + message(FATAL_ERROR "${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX} not found") +endif() + +find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld) +if(NOT CMAKE_LINKER) + message(FATAL_ERROR "CMAKE_LINKER=${CMAKE_LINKER} is defined") +endif() + +find_program(CMAKE_AR NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar) +if(NOT CMAKE_AR) + message(FATAL_ERROR "CMAKE_AR=${CMAKE_AR} is defined") +endif() + +if(NOT DEFINED ARM_LINUX_SYSROOT AND DEFINED GNU_MACHINE) + set(ARM_LINUX_SYSROOT /usr/${GNU_MACHINE}${FLOAT_ABI_SUFFIX}) +endif() + +if(USE_NEON) + message(WARNING "You use obsolete variable USE_NEON to enable NEON instruction set. Use -DENABLE_NEON=ON instead." ) + set(ENABLE_NEON TRUE) +elseif(USE_VFPV3) + message(WARNING "You use obsolete variable USE_VFPV3 to enable VFPV3 instruction set. Use -DENABLE_VFPV3=ON instead." ) + set(ENABLE_VFPV3 TRUE) +endif() + +set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${ARM_LINUX_SYSROOT}) + +set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS} + ARM_LINUX_SYSROOT + ENABLE_NEON + ENABLE_VFPV3 +) +toolchain_save_config() \ No newline at end of file diff --git a/cmake/toolchains/arm-linux.cmake b/cmake/toolchains/arm-linux.cmake new file mode 100644 index 0000000..4403f32 --- /dev/null +++ b/cmake/toolchains/arm-linux.cmake @@ -0,0 +1,61 @@ +set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version") +set(GNU_MACHINE "arm-linux-gnueabihf" CACHE STRING "GNU compiler triplet") + +if(COMMAND toolchain_save_config) + return() # prevent recursive call +endif() + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_VERSION 1) +if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR) + set(CMAKE_SYSTEM_PROCESSOR arm) +else() + #message("CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}") +endif() + +include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake") + +if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x") + set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}") +endif() + +find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX}) +if (NOT CMAKE_C_COMPILER) + message(FATAL_ERROR "${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX} not found") +endif() + +find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX}) +if (NOT CMAKE_CXX_COMPILER) + message(FATAL_ERROR "${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX} not found") +endif() + +find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld) +if(NOT CMAKE_LINKER) + message(FATAL_ERROR "CMAKE_LINKER=${CMAKE_LINKER} is defined") +endif() + +find_program(CMAKE_AR NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar) +if(NOT CMAKE_AR) + message(FATAL_ERROR "CMAKE_AR=${CMAKE_AR} is defined") +endif() + +if(NOT DEFINED ARM_LINUX_SYSROOT AND DEFINED GNU_MACHINE) + set(ARM_LINUX_SYSROOT /usr/${GNU_MACHINE}${FLOAT_ABI_SUFFIX}) +endif() + +if(USE_NEON) + message(WARNING "You use obsolete variable USE_NEON to enable NEON instruction set. Use -DENABLE_NEON=ON instead." ) + set(ENABLE_NEON TRUE) +elseif(USE_VFPV3) + message(WARNING "You use obsolete variable USE_VFPV3 to enable VFPV3 instruction set. Use -DENABLE_VFPV3=ON instead." ) + set(ENABLE_VFPV3 TRUE) +endif() + +set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${ARM_LINUX_SYSROOT}) + +set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS} + ARM_LINUX_SYSROOT + ENABLE_NEON + ENABLE_VFPV3 +) +toolchain_save_config() \ No newline at end of file diff --git a/cmake/toolchains/arm-pi-gnueabihf.toolchain.cmake b/cmake/toolchains/arm-pi-gnueabihf.toolchain.cmake new file mode 100644 index 0000000..fcc847c --- /dev/null +++ b/cmake/toolchains/arm-pi-gnueabihf.toolchain.cmake @@ -0,0 +1,98 @@ +set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version") +set(GNU_MACHINE "arm-raspbian10-linux-gnueabi" CACHE STRING "GNU compiler triple") + +if(COMMAND toolchain_save_config) + return() # prevent recursive call +endif() + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_VERSION 1) +if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR) + set(CMAKE_SYSTEM_PROCESSOR arm) +else() + #message("CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}") +endif() + +include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake") + +if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm AND NOT ARM_IGNORE_FP) + set(FLOAT_ABI_SUFFIX "") + if(NOT SOFTFP) + set(FLOAT_ABI_SUFFIX "hf") + endif() +endif() + +if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x") + set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}") +endif() + +if(NOT DEFINED CMAKE_C_COMPILER) + find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX}) +else() + message(WARNING "CMAKE_C_COMPILER=${CMAKE_C_COMPILER} is defined") +endif() +if(NOT DEFINED CMAKE_CXX_COMPILER) + find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX}) +else() + #message(WARNING "CMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} is defined") +endif() +if(NOT DEFINED CMAKE_LINKER) + find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld) +else() + #message(WARNING "CMAKE_LINKER=${CMAKE_LINKER} is defined") +endif() +if(NOT DEFINED CMAKE_AR) + find_program(CMAKE_AR NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar) +else() + #message(WARNING "CMAKE_AR=${CMAKE_AR} is defined") +endif() + +if(NOT DEFINED ARM_LINUX_SYSROOT AND DEFINED GNU_MACHINE) + set(ARM_LINUX_SYSROOT /usr/local/sys-root) +endif() + +if(NOT DEFINED CMAKE_CXX_FLAGS) + set(CMAKE_CXX_FLAGS "" CACHE INTERNAL "") + set(CMAKE_C_FLAGS "" CACHE INTERNAL "") + set(CMAKE_SHARED_LINKER_FLAGS "" CACHE INTERNAL "") + set(CMAKE_MODULE_LINKER_FLAGS "" CACHE INTERNAL "") + set(CMAKE_EXE_LINKER_FLAGS "" CACHE INTERNAL "") + + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi") + if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-z,nocopyreloc") + endif() + if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm) + set(ARM_LINKER_FLAGS "-Wl,--fix-cortex-a8 -Wl,--no-undefined -Wl,--gc-sections -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now") + elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64) + set(ARM_LINKER_FLAGS "-Wl,--no-undefined -Wl,--gc-sections -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now") + endif() + set(CMAKE_SHARED_LINKER_FLAGS "${ARM_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}") + set(CMAKE_MODULE_LINKER_FLAGS "${ARM_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}") + set(CMAKE_EXE_LINKER_FLAGS "${ARM_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}") +else() + #message(WARNING "CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}' is defined") +endif() + +if(USE_NEON) + message(WARNING "You use obsolete variable USE_NEON to enable NEON instruction set. Use -DENABLE_NEON=ON instead." ) + set(ENABLE_NEON TRUE) +elseif(USE_VFPV3) + message(WARNING "You use obsolete variable USE_VFPV3 to enable VFPV3 instruction set. Use -DENABLE_VFPV3=ON instead." ) + set(ENABLE_VFPV3 TRUE) +endif() + +set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${ARM_LINUX_SYSROOT}) + +if(EXISTS ${CUDA_TOOLKIT_ROOT_DIR}) + set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${CUDA_TOOLKIT_ROOT_DIR}) +endif() + +set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS} + ARM_LINUX_SYSROOT + ENABLE_NEON + ENABLE_VFPV3 + CUDA_TOOLKIT_ROOT_DIR +) +toolchain_save_config() diff --git a/cmake/toolchains/arm.toolchain.cmake b/cmake/toolchains/arm.toolchain.cmake new file mode 100644 index 0000000..4d63360 --- /dev/null +++ b/cmake/toolchains/arm.toolchain.cmake @@ -0,0 +1,97 @@ +if(COMMAND toolchain_save_config) + return() # prevent recursive call +endif() + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_VERSION 1) +if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR) + set(CMAKE_SYSTEM_PROCESSOR arm) +else() + #message("CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}") +endif() + +include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake") + +if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm AND NOT ARM_IGNORE_FP) + set(FLOAT_ABI_SUFFIX "") + if(NOT SOFTFP) + set(FLOAT_ABI_SUFFIX "hf") + endif() +endif() + +if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x") + set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}") +endif() + +if(NOT DEFINED CMAKE_C_COMPILER) + find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX}) +else() + #message(WARNING "CMAKE_C_COMPILER=${CMAKE_C_COMPILER} is defined") +endif() +if(NOT DEFINED CMAKE_CXX_COMPILER) + find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX}) +else() + #message(WARNING "CMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} is defined") +endif() +if(NOT DEFINED CMAKE_LINKER) + find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld) +else() + #message(WARNING "CMAKE_LINKER=${CMAKE_LINKER} is defined") +endif() +if(NOT DEFINED CMAKE_AR) + find_program(CMAKE_AR NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar) +else() + #message(WARNING "CMAKE_AR=${CMAKE_AR} is defined") +endif() + +if(NOT DEFINED ARM_LINUX_SYSROOT AND DEFINED GNU_MACHINE) + set(ARM_LINUX_SYSROOT /usr/${GNU_MACHINE}${FLOAT_ABI_SUFFIX}) +endif() + +if(NOT DEFINED CMAKE_CXX_FLAGS) + set(CMAKE_CXX_FLAGS "" CACHE INTERNAL "") + set(CMAKE_C_FLAGS "" CACHE INTERNAL "") + set(CMAKE_SHARED_LINKER_FLAGS "" CACHE INTERNAL "") + set(CMAKE_MODULE_LINKER_FLAGS "" CACHE INTERNAL "") + set(CMAKE_EXE_LINKER_FLAGS "" CACHE INTERNAL "") + + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi") + if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm) + set(CMAKE_CXX_FLAGS "-mthumb ${CMAKE_CXX_FLAGS}") + set(CMAKE_C_FLAGS "-mthumb ${CMAKE_C_FLAGS}") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-z,nocopyreloc") + endif() + if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm) + set(ARM_LINKER_FLAGS "-Wl,--fix-cortex-a8 -Wl,--no-undefined -Wl,--gc-sections -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now") + elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64) + set(ARM_LINKER_FLAGS "-Wl,--no-undefined -Wl,--gc-sections -Wl,-z,noexecstack -Wl,-z,relro -Wl,-z,now") + endif() + set(CMAKE_SHARED_LINKER_FLAGS "${ARM_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}") + set(CMAKE_MODULE_LINKER_FLAGS "${ARM_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}") + set(CMAKE_EXE_LINKER_FLAGS "${ARM_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}") +else() + #message(WARNING "CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}' is defined") +endif() + +if(USE_NEON) + message(WARNING "You use obsolete variable USE_NEON to enable NEON instruction set. Use -DENABLE_NEON=ON instead." ) + set(ENABLE_NEON TRUE) +elseif(USE_VFPV3) + message(WARNING "You use obsolete variable USE_VFPV3 to enable VFPV3 instruction set. Use -DENABLE_VFPV3=ON instead." ) + set(ENABLE_VFPV3 TRUE) +endif() + +set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${ARM_LINUX_SYSROOT}) + +if(EXISTS ${CUDA_TOOLKIT_ROOT_DIR}) + set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${CUDA_TOOLKIT_ROOT_DIR}) +endif() + +set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS} + ARM_LINUX_SYSROOT + ENABLE_NEON + ENABLE_VFPV3 + CUDA_TOOLKIT_ROOT_DIR +) +toolchain_save_config() diff --git a/cmake/toolchains/gnu.toolchain.cmake b/cmake/toolchains/gnu.toolchain.cmake new file mode 100644 index 0000000..c1bbcf4 --- /dev/null +++ b/cmake/toolchains/gnu.toolchain.cmake @@ -0,0 +1,134 @@ +cmake_minimum_required(VERSION 3.6) + +# load settings in case of "try compile" +set(TOOLCHAIN_CONFIG_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/toolchain.config.cmake") +get_property(__IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE) +if(__IN_TRY_COMPILE) + include("${CMAKE_CURRENT_SOURCE_DIR}/../toolchain.config.cmake" OPTIONAL) # CMAKE_BINARY_DIR is different + macro(toolchain_save_config) + # nothing + endmacro() +else() + macro(toolchain_save_config) + set(__config "#message(\"Load TOOLCHAIN config...\")\n") + get_cmake_property(__variableNames VARIABLES) + set(__vars_list ${ARGN}) + list(APPEND __vars_list + ${TOOLCHAIN_CONFIG_VARS} + CMAKE_SYSTEM_NAME + CMAKE_SYSTEM_VERSION + CMAKE_SYSTEM_PROCESSOR + CMAKE_C_COMPILER + CMAKE_CXX_COMPILER + CMAKE_C_FLAGS + CMAKE_CXX_FLAGS + CMAKE_SHARED_LINKER_FLAGS + CMAKE_MODULE_LINKER_FLAGS + CMAKE_EXE_LINKER_FLAGS + CMAKE_SKIP_RPATH + CMAKE_FIND_ROOT_PATH + GCC_COMPILER_VERSION + ) + foreach(__var ${__variableNames}) + foreach(_v ${__vars_list}) + if("x${__var}" STREQUAL "x${_v}") + if(${__var} MATCHES " ") + set(__config "${__config}set(${__var} \"${${__var}}\")\n") + else() + set(__config "${__config}set(${__var} ${${__var}})\n") + endif() + endif() + endforeach() + endforeach() + if(EXISTS "${TOOLCHAIN_CONFIG_FILE}") + file(READ "${TOOLCHAIN_CONFIG_FILE}" __config_old) + endif() + if("${__config_old}" STREQUAL "${__config}") + # nothing + else() + #message("Update TOOLCHAIN config: ${__config}") + file(WRITE "${TOOLCHAIN_CONFIG_FILE}" "${__config}") + endif() + unset(__config) + unset(__config_old) + unset(__vars_list) + unset(__variableNames) + endmacro() +endif() # IN_TRY_COMPILE + +if(NOT CMAKE_FIND_ROOT_PATH_MODE_LIBRARY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +endif() + +if(NOT CMAKE_FIND_ROOT_PATH_MODE_INCLUDE) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +endif() + +if(NOT CMAKE_FIND_ROOT_PATH_MODE_PACKAGE) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) +endif() + +if(NOT CMAKE_FIND_ROOT_PATH_MODE_PROGRAM) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +endif() + +macro(__cmake_find_root_save_and_reset) + foreach(v + CMAKE_FIND_ROOT_PATH_MODE_LIBRARY + CMAKE_FIND_ROOT_PATH_MODE_INCLUDE + CMAKE_FIND_ROOT_PATH_MODE_PACKAGE + CMAKE_FIND_ROOT_PATH_MODE_PROGRAM + ) + set(__save_${v} ${${v}}) + set(${v} NEVER) + endforeach() +endmacro() + +macro(__cmake_find_root_restore) + foreach(v + CMAKE_FIND_ROOT_PATH_MODE_LIBRARY + CMAKE_FIND_ROOT_PATH_MODE_INCLUDE + CMAKE_FIND_ROOT_PATH_MODE_PACKAGE + CMAKE_FIND_ROOT_PATH_MODE_PROGRAM + ) + set(${v} ${__save_${v}}) + unset(__save_${v}) + endforeach() +endmacro() + + +# macro to find programs on the host OS +macro(find_host_program) + __cmake_find_root_save_and_reset() + if(CMAKE_HOST_WIN32) + SET(WIN32 1) + SET(UNIX) + elseif(CMAKE_HOST_APPLE) + SET(APPLE 1) + SET(UNIX) + endif() + find_program(${ARGN}) + SET(WIN32) + SET(APPLE) + SET(UNIX 1) + __cmake_find_root_restore() +endmacro() + +# macro to find packages on the host OS +macro(find_host_package) + __cmake_find_root_save_and_reset() + if(CMAKE_HOST_WIN32) + SET(WIN32 1) + SET(UNIX) + elseif(CMAKE_HOST_APPLE) + SET(APPLE 1) + SET(UNIX) + endif() + find_package(${ARGN}) + SET(WIN32) + SET(APPLE) + SET(UNIX 1) + __cmake_find_root_restore() +endmacro() + +set(CMAKE_SKIP_RPATH TRUE CACHE BOOL "If set, runtime paths are not added when using shared libraries.") diff --git a/cmake/toolchains/ios.cmake b/cmake/toolchains/ios.cmake new file mode 100644 index 0000000..28d96b8 --- /dev/null +++ b/cmake/toolchains/ios.cmake @@ -0,0 +1,927 @@ +# This file is part of the ios-cmake project. It was retrieved from +# https://github.com/leetal/ios-cmake.git, which is a fork of +# https://github.com/gerstrong/ios-cmake.git, which is a fork of +# https://github.com/cristeab/ios-cmake.git, which is a fork of +# https://code.google.com/p/ios-cmake/. Which in turn is based off of +# the Platform/Darwin.cmake and Platform/UnixPaths.cmake files which +# are included with CMake 2.8.4 +# +# The ios-cmake project is licensed under the new BSD license. +# +# Copyright (c) 2014, Bogdan Cristea and LTE Engineering Software, +# Kitware, Inc., Insight Software Consortium. All rights reserved. +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. 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. +# +# 3. Neither the name of the copyright holder 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 HOLDER 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. +# +# This file is based off of the Platform/Darwin.cmake and +# Platform/UnixPaths.cmake files which are included with CMake 2.8.4 +# It has been altered for iOS development. +# +# Updated by Alex Stewart (alexs.mac@gmail.com) +# +# ***************************************************************************** +# Now maintained by Alexander Widerberg (widerbergaren [at] gmail.com) +# under the BSD-3-Clause license +# https://github.com/leetal/ios-cmake +# ***************************************************************************** +# +# INFORMATION / HELP +# +# The following options control the behaviour of this toolchain: +# +# PLATFORM: (default "OS64") +# OS = Build for iPhoneOS. +# OS64 = Build for arm64 iphoneOS. +# OS64COMBINED = Build for arm64 x86_64 iphoneOS. Combined into FAT STATIC lib (supported on 3.14+ of CMakewith "-G Xcode" argument ONLY) +# SIMULATOR = Build for x86 i386 iphoneOS Simulator. +# SIMULATOR64 = Build for x86_64 iphoneOS Simulator. +# SIMULATORARM64 = Build for arm64 iphoneOS Simulator. +# TVOS = Build for arm64 tvOS. +# TVOSCOMBINED = Build for arm64 x86_64 tvOS. Combined into FAT STATIC lib (supported on 3.14+ of CMake with "-G Xcode" argument ONLY) +# SIMULATOR_TVOS = Build for x86_64 tvOS Simulator. +# WATCHOS = Build for armv7k arm64_32 for watchOS. +# WATCHOSCOMBINED = Build for armv7k arm64_32 x86_64 watchOS. Combined into FAT STATIC lib (supported on 3.14+ of CMake with "-G Xcode" argument ONLY) +# SIMULATOR_WATCHOS = Build for x86_64 for watchOS Simulator. +# MAC = Build for x86_64 macOS. +# MAC_ARM64 = Build for Apple Silicon macOS. +# MAC_CATALYST = Build for x86_64 macOS with Catalyst support (iOS toolchain on macOS). +# Note: The build argument "MACOSX_DEPLOYMENT_TARGET" can be used to control min-version of macOS +# MAC_CATALYST_ARM64 = Build for Apple Silicon macOS with Catalyst support (iOS toolchain on macOS). +# Note: The build argument "MACOSX_DEPLOYMENT_TARGET" can be used to control min-version of macOS +# +# CMAKE_OSX_SYSROOT: Path to the SDK to use. By default this is +# automatically determined from PLATFORM and xcodebuild, but +# can also be manually specified (although this should not be required). +# +# CMAKE_DEVELOPER_ROOT: Path to the Developer directory for the platform +# being compiled for. By default this is automatically determined from +# CMAKE_OSX_SYSROOT, but can also be manually specified (although this should +# not be required). +# +# DEPLOYMENT_TARGET: Minimum SDK version to target. Default 2.0 on watchOS and 9.0 on tvOS+iOS +# +# ENABLE_BITCODE: (1|0) Enables or disables bitcode support. Default 1 (true) +# +# ENABLE_ARC: (1|0) Enables or disables ARC support. Default 1 (true, ARC enabled by default) +# +# ENABLE_VISIBILITY: (1|0) Enables or disables symbol visibility support. Default 0 (false, visibility hidden by default) +# +# ENABLE_STRICT_TRY_COMPILE: (1|0) Enables or disables strict try_compile() on all Check* directives (will run linker +# to actually check if linking is possible). Default 0 (false, will set CMAKE_TRY_COMPILE_TARGET_TYPE to STATIC_LIBRARY) +# +# ARCHS: (armv7 armv7s armv7k arm64 arm64_32 i386 x86_64) If specified, will override the default architectures for the given PLATFORM +# OS = armv7 armv7s arm64 (if applicable) +# OS64 = arm64 (if applicable) +# SIMULATOR = i386 +# SIMULATOR64 = x86_64 +# SIMULATORARM64 = arm64 +# TVOS = arm64 +# SIMULATOR_TVOS = x86_64 (i386 has since long been deprecated) +# WATCHOS = armv7k arm64_32 (if applicable) +# SIMULATOR_WATCHOS = x86_64 (i386 has since long been deprecated) +# MAC = x86_64 +# MAC_ARM64 = arm64 +# MAC_CATALYST = x86_64 +# MAC_CATALYST_ARM64 = arm64 +# +# This toolchain defines the following properties (available via get_property()) for use externally: +# +# PLATFORM: The currently targeted platform. +# XCODE_VERSION: Version number (not including Build version) of Xcode detected. +# SDK_VERSION: Version of SDK being used. +# OSX_ARCHITECTURES: Architectures being compiled for (generated from PLATFORM). +# APPLE_TARGET_TRIPLE: Used by autoconf build systems. NOTE: If "ARCHS" are overridden, this will *NOT* be set! +# +# This toolchain defines the following macros for use externally: +# +# set_xcode_property (TARGET XCODE_PROPERTY XCODE_VALUE XCODE_VARIANT) +# A convenience macro for setting xcode specific properties on targets. +# Available variants are: All, Release, RelWithDebInfo, Debug, MinSizeRel +# example: set_xcode_property (myioslib IPHONEOS_DEPLOYMENT_TARGET "3.1" "all"). +# +# find_host_package (PROGRAM ARGS) +# A macro used to find executable programs on the host system, not within the +# environment. Thanks to the android-cmake project for providing the +# command. +# + +cmake_minimum_required(VERSION 3.8.0) + +# CMake invokes the toolchain file twice during the first build, but only once during subsequent rebuilds. +if(IOS_TOOLCHAIN_HAS_RUN) + return() +endif(IOS_TOOLCHAIN_HAS_RUN) +set(IOS_TOOLCHAIN_HAS_RUN true) + +############################################################################### +# OPTIONS # +############################################################################### + +option(DROP_32_BIT "Drops the 32-bit targets universally." YES) + +############################################################################### +# END OPTIONS # +############################################################################### + +# List of supported platform values +list(APPEND _supported_platforms + "OS" "OS64" "OS64COMBINED" "SIMULATOR" "SIMULATOR64" "SIMULATORARM64" + "TVOS" "TVOSCOMBINED" "SIMULATOR_TVOS" + "WATCHOS" "WATCHOSCOMBINED" "SIMULATOR_WATCHOS" + "MAC" "MAC_ARM64" + "MAC_CATALYST" "MAC_CATALYST_ARM64") + +# Cache what generator is used +set(USED_CMAKE_GENERATOR "${CMAKE_GENERATOR}") + +# Check if using a CMake version capable of building combined FAT builds (simulator and target slices combined in one static lib) +if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.14") + set(MODERN_CMAKE YES) +endif() + +# Get the Xcode version being used. +# Problem: CMake runs toolchain files multiple times, but can't read cache variables on some runs. +# Workaround: On first run (in which cache variables are always accessible), set an intermediary environment variable. +# +# NOTE: This pattern is used i many places in this toolchain to speed up checks of all sorts +if(DEFINED XCODE_VERSION_INT) + # Environment variables are always preserved. + set(ENV{_XCODE_VERSION_INT} "${XCODE_VERSION_INT}") +elseif(DEFINED ENV{_XCODE_VERSION_INT}) + set(XCODE_VERSION_INT "$ENV{_XCODE_VERSION_INT}") +elseif(NOT DEFINED XCODE_VERSION_INT) + find_program(XCODEBUILD_EXECUTABLE xcodebuild) + if(NOT XCODEBUILD_EXECUTABLE) + message(FATAL_ERROR "xcodebuild not found. Please install either the standalone commandline tools or Xcode.") + endif() + execute_process(COMMAND ${XCODEBUILD_EXECUTABLE} -version + OUTPUT_VARIABLE XCODE_VERSION_INT + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + string(REGEX MATCH "Xcode [0-9\\.]+" XCODE_VERSION_INT "${XCODE_VERSION_INT}") + string(REGEX REPLACE "Xcode ([0-9\\.]+)" "\\1" XCODE_VERSION_INT "${XCODE_VERSION_INT}") + set(XCODE_VERSION_INT "${XCODE_VERSION_INT}" CACHE INTERNAL "") +endif() + +# Assuming that xcode 12.0 is installed you most probably have ios sdk 14.0 or later installed (tested on Big Sur) +# if you don't set a deployment target it will be set the way you only get 64-bit builds +if(NOT DEFINED DEPLOYMENT_TARGET AND XCODE_VERSION_INT VERSION_GREATER 12.0) + # Temporarily fix the arm64 issues in CMake install-combined by excluding arm64 for simulator builds (needed for Apple Silicon...) + set(CMAKE_XCODE_ATTRIBUTE_EXCLUDED_ARCHS[sdk=iphonesimulator*] "arm64") +endif() + +# Check if the platform variable is set +if(DEFINED PLATFORM) + # Environment variables are always preserved. + set(ENV{_PLATFORM} "${PLATFORM}") +elseif(DEFINED ENV{_PLATFORM}) + set(PLATFORM "$ENV{_PLATFORM}") +elseif(NOT DEFINED PLATFORM) + message(FATAL_ERROR "PLATFORM argument not set. Bailing configure since I don't know what target you want to build for!") +endif () + +# Safeguard that the platform value is set and is one of the supported values +list(FIND _supported_platforms ${PLATFORM} contains_PLATFORM) +if("${contains_PLATFORM}" EQUAL "-1") + string(REPLACE ";" "\n * " _supported_platforms_formatted "${_supported_platforms}") + message(FATAL_ERROR " Invalid PLATFORM specified! Current value: ${PLATFORM}.\n" + " Supported PLATFORM values: \n * ${_supported_platforms_formatted}") +endif() + +# Check if Apple Silicon is supported +if(PLATFORM MATCHES "^(MAC_ARM64)$|^(MAC_CATALYST_ARM64)$" AND ${CMAKE_VERSION} VERSION_LESS "3.19.5") + message(FATAL_ERROR "Apple Silicon builds requires a minimum of CMake 3.19.5") +endif() + +# Touch toolchain variable to suppress "unused variable" warning. +# This happens if CMake is invoked with the same command line the second time. +if(CMAKE_TOOLCHAIN_FILE) +endif() + +# Fix for PThread library not in path +set(CMAKE_THREAD_LIBS_INIT "-lpthread") +set(CMAKE_HAVE_THREADS_LIBRARY 1) +set(CMAKE_USE_WIN32_THREADS_INIT 0) +set(CMAKE_USE_PTHREADS_INIT 1) + +# Specify minimum version of deployment target. +if(NOT DEFINED DEPLOYMENT_TARGET) + if (PLATFORM MATCHES "WATCHOS") + # Unless specified, SDK version 4.0 is used by default as minimum target version (watchOS). + set(DEPLOYMENT_TARGET "4.0") + elseif(PLATFORM STREQUAL "MAC") + # Unless specified, SDK version 10.13 (High sierra) is used by default as minimum target version (macos). + set(DEPLOYMENT_TARGET "10.13") + elseif(PLATFORM STREQUAL "MAC_ARM64") + # Unless specified, SDK version 11.0 (Big Sur) is used by default as minimum target version (macos on arm). + set(DEPLOYMENT_TARGET "11.0") + elseif(PLATFORM STREQUAL "MAC_CATALYST" OR PLATFORM STREQUAL "MAC_CATALYST_ARM64") + # Unless specified, SDK version 13.0 is used by default as minimum target version (mac catalyst minimum requirement). + set(DEPLOYMENT_TARGET "13.0") + else() + # Unless specified, SDK version 11.0 is used by default as minimum target version (iOS, tvOS). + set(DEPLOYMENT_TARGET "11.0") + endif() + message(STATUS "[DEFAULTS] Using the default min-version since DEPLOYMENT_TARGET not provided!") +elseif(DEFINED DEPLOYMENT_TARGET AND PLATFORM STREQUAL "MAC_CATALYST" AND ${DEPLOYMENT_TARGET} VERSION_LESS "13.0") + message(FATAL_ERROR "Mac Catalyst builds requires a minimum deployment target of 13.0!") +endif() + +# Store the DEPLOYMENT_TARGET in the cache +set(DEPLOYMENT_TARGET "${DEPLOYMENT_TARGET}" CACHE INTERNAL "") + +# Handle the case where we are targeting iOS and a version above 10.3.4 (32-bit support dropped officially) +if(PLATFORM STREQUAL "OS" AND DEPLOYMENT_TARGET VERSION_GREATER_EQUAL 10.3.4) + set(PLATFORM "OS64") + message(STATUS "Targeting minimum SDK version ${DEPLOYMENT_TARGET}. Dropping 32-bit support.") +elseif(PLATFORM STREQUAL "SIMULATOR" AND DEPLOYMENT_TARGET VERSION_GREATER_EQUAL 10.3.4) + set(PLATFORM "SIMULATOR64") + message(STATUS "Targeting minimum SDK version ${DEPLOYMENT_TARGET}. Dropping 32-bit support.") +endif() + +set(PLATFORM_INT "${PLATFORM}") + +if(DEFINED ARCHS) + string(REPLACE ";" "-" ARCHS_SPLIT "${ARCHS}") +endif() + +# Determine the platform name and architectures for use in xcodebuild commands +# from the specified PLATFORM_INT name. +if(PLATFORM_INT STREQUAL "OS") + set(SDK_NAME iphoneos) + if(NOT ARCHS) + set(ARCHS armv7 armv7s arm64) + set(APPLE_TARGET_TRIPLE_INT arm-apple-ios) + endif() +elseif(PLATFORM_INT STREQUAL "OS64") + set(SDK_NAME iphoneos) + if(NOT ARCHS) + if (XCODE_VERSION_INT VERSION_GREATER 10.0) + set(ARCHS arm64) # Add arm64e when Apple have fixed the integration issues with it, libarclite_iphoneos.a is currently missung bitcode markers for example + else() + set(ARCHS arm64) + endif() + set(APPLE_TARGET_TRIPLE_INT aarch64-apple-ios) + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios) + endif() +elseif(PLATFORM_INT STREQUAL "OS64COMBINED") + set(SDK_NAME iphoneos) + if(MODERN_CMAKE) + if(NOT ARCHS) + if (XCODE_VERSION_INT VERSION_GREATER 10.0) + set(ARCHS arm64 x86_64) # Add arm64e when Apple have fixed the integration issues with it, libarclite_iphoneos.a is currently missung bitcode markers for example + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphoneos*] "arm64") + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphonesimulator*] "x86_64") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphoneos*] "arm64") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphonesimulator*] "x86_64") + else() + set(ARCHS arm64 x86_64) + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphoneos*] "arm64") + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=iphonesimulator*] "x86_64") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphoneos*] "arm64") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=iphonesimulator*] "x86_64") + endif() + set(APPLE_TARGET_TRIPLE_INT aarch64-x86_64-apple-ios) + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios) + endif() + else() + message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the OS64COMBINED setting work") + endif() +elseif(PLATFORM_INT STREQUAL "SIMULATOR") + set(SDK_NAME iphonesimulator) + if(NOT ARCHS) + set(ARCHS i386) + set(APPLE_TARGET_TRIPLE_INT i386-apple-ios) + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios) + endif() + message(DEPRECATION "SIMULATOR IS DEPRECATED. Consider using SIMULATOR64 instead.") +elseif(PLATFORM_INT STREQUAL "SIMULATOR64") + set(SDK_NAME iphonesimulator) + if(NOT ARCHS) + set(ARCHS x86_64) + set(APPLE_TARGET_TRIPLE_INT x86_64-apple-ios) + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios) + endif() +elseif(PLATFORM_INT STREQUAL "SIMULATORARM64") + set(SDK_NAME iphonesimulator) + if(NOT ARCHS) + set(ARCHS arm64) + set(APPLE_TARGET_TRIPLE_INT aarch64-apple-ios) + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios) + endif() +elseif(PLATFORM_INT STREQUAL "TVOS") + set(SDK_NAME appletvos) + if(NOT ARCHS) + set(ARCHS arm64) + set(APPLE_TARGET_TRIPLE_INT aarch64-apple-tvos) + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-tvos) + endif() +elseif (PLATFORM_INT STREQUAL "TVOSCOMBINED") + set(SDK_NAME appletvos) + if(MODERN_CMAKE) + if(NOT ARCHS) + set(ARCHS arm64 x86_64) + set(APPLE_TARGET_TRIPLE_INT aarch64-x86_64-apple-tvos) + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=appletvos*] "arm64") + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=appletvsimulator*] "x86_64") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=appletvos*] "arm64") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=appletvsimulator*] "x86_64") + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-tvos) + endif() + else() + message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the TVOSCOMBINED setting work") + endif() +elseif(PLATFORM_INT STREQUAL "SIMULATOR_TVOS") + set(SDK_NAME appletvsimulator) + if(NOT ARCHS) + set(ARCHS x86_64) + set(APPLE_TARGET_TRIPLE_INT x86_64-apple-tvos) + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-tvos) + endif() +elseif(PLATFORM_INT STREQUAL "WATCHOS") + set(SDK_NAME watchos) + if(NOT ARCHS) + if (XCODE_VERSION_INT VERSION_GREATER 10.0) + set(ARCHS armv7k arm64_32) + set(APPLE_TARGET_TRIPLE_INT aarch64_32-apple-watchos) + else() + set(ARCHS armv7k) + set(APPLE_TARGET_TRIPLE_INT arm-apple-watchos) + endif() + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-watchos) + endif() +elseif(PLATFORM_INT STREQUAL "WATCHOSCOMBINED") + set(SDK_NAME watchos) + if(MODERN_CMAKE) + if(NOT ARCHS) + if (XCODE_VERSION_INT VERSION_GREATER 10.0) + set(ARCHS armv7k arm64_32 i386) + set(APPLE_TARGET_TRIPLE_INT aarch64_32-i386-apple-watchos) + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchos*] "armv7k arm64_32") + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchsimulator*] "i386") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchos*] "armv7k arm64_32") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchsimulator*] "i386") + else() + set(ARCHS armv7k i386) + set(APPLE_TARGET_TRIPLE_INT arm-i386-apple-watchos) + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchos*] "armv7k") + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchsimulator*] "i386") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchos*] "armv7k") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchsimulator*] "i386") + endif() + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-watchos) + endif() + else() + message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the WATCHOSCOMBINED setting work") + endif() +elseif(PLATFORM_INT STREQUAL "SIMULATOR_WATCHOS") + set(SDK_NAME watchsimulator) + if(NOT ARCHS) + set(ARCHS i386) + set(APPLE_TARGET_TRIPLE_INT i386-apple-watchos) + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-watchos) + endif() +elseif(PLATFORM_INT STREQUAL "MAC" OR PLATFORM_INT STREQUAL "MAC_CATALYST") + set(SDK_NAME macosx) + if(NOT ARCHS) + set(ARCHS x86_64) + endif() + string(REPLACE ";" "-" ARCHS_SPLIT "${ARCHS}") + if(PLATFORM_INT STREQUAL "MAC") + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-macosx) + elseif(PLATFORM_INT STREQUAL "MAC_CATALYST") + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios${DEPLOYMENT_TARGET}-macabi) + endif() +elseif(PLATFORM_INT MATCHES "^(MAC_ARM64)$|^(MAC_CATALYST_ARM64)$") + set(SDK_NAME macosx) + if(NOT ARCHS) + set(ARCHS arm64) + endif() + string(REPLACE ";" "-" ARCHS_SPLIT "${ARCHS}") + if(PLATFORM_INT STREQUAL "MAC_ARM64") + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-macosx) + elseif(PLATFORM_INT STREQUAL "MAC_CATALYST_ARM64") + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-ios${DEPLOYMENT_TARGET}-macabi) + endif() +else() + message(FATAL_ERROR "Invalid PLATFORM: ${PLATFORM_INT}") +endif() + +if(MODERN_CMAKE AND PLATFORM_INT MATCHES ".*COMBINED" AND NOT CMAKE_GENERATOR MATCHES "Xcode") + message(FATAL_ERROR "The COMBINED options only work with Xcode generator, -G Xcode") +endif() + +if(CMAKE_GENERATOR MATCHES "Xcode" AND PLATFORM_INT MATCHES "MAC_CATALYST_.*") + set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") + set(CMAKE_XCODE_ATTRIBUTE_SUPPORTED_PLATFORMS "macosx") + set(CMAKE_XCODE_EFFECTIVE_PLATFORMS "-maccatalyst") + if(NOT DEFINED MACOSX_DEPLOYMENT_TARGET) + set(CMAKE_XCODE_ATTRIBUTE_MACOSX_DEPLOYMENT_TARGET "12") + else() + set(CMAKE_XCODE_ATTRIBUTE_MACOSX_DEPLOYMENT_TARGET "${MACOSX_DEPLOYMENT_TARGET}") + endif() +elseif(CMAKE_GENERATOR MATCHES "Xcode") + set(CMAKE_XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET "${DEPLOYMENT_TARGET}") + if(NOT PLATFORM_INT MATCHES ".*COMBINED") + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=${SDK_NAME}*] "${ARCHS}") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=${SDK_NAME}*] "${ARCHS}") + endif() +endif() + +# If user did not specify the SDK root to use, then query xcodebuild for it. +if(DEFINED CMAKE_OSX_SYSROOT_INT) + # Environment variables are always preserved. + set(ENV{_CMAKE_OSX_SYSROOT_INT} "${CMAKE_OSX_SYSROOT_INT}") +elseif(DEFINED ENV{_CMAKE_OSX_SYSROOT_INT}) + set(CMAKE_OSX_SYSROOT_INT "$ENV{_CMAKE_OSX_SYSROOT_INT}") +elseif(NOT DEFINED CMAKE_OSX_SYSROOT_INT) + execute_process(COMMAND ${XCODEBUILD_EXECUTABLE} -version -sdk ${SDK_NAME} Path + OUTPUT_VARIABLE CMAKE_OSX_SYSROOT_INT + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +endif() + +if (NOT DEFINED CMAKE_OSX_SYSROOT_INT AND NOT DEFINED CMAKE_OSX_SYSROOT) + message(SEND_ERROR "Please make sure that Xcode is installed and that the toolchain" + "is pointing to the correct path. Please run:" + "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer" + "and see if that fixes the problem for you.") + message(FATAL_ERROR "Invalid CMAKE_OSX_SYSROOT: ${CMAKE_OSX_SYSROOT} " + "does not exist.") +elseif(DEFINED CMAKE_OSX_SYSROOT_INT) + set(CMAKE_OSX_SYSROOT_INT "${CMAKE_OSX_SYSROOT_INT}" CACHE INTERNAL "") + # Specify the location or name of the platform SDK to be used in CMAKE_OSX_SYSROOT. + set(CMAKE_OSX_SYSROOT "${CMAKE_OSX_SYSROOT_INT}" CACHE INTERNAL "") +endif() + +# Use bitcode or not +if(NOT DEFINED ENABLE_BITCODE AND NOT ARCHS MATCHES "((^|;|, )(i386|x86_64))+") + # Unless specified, enable bitcode support by default + message(STATUS "[DEFAULTS] Enabling bitcode support by default. ENABLE_BITCODE not provided!") + set(ENABLE_BITCODE TRUE) +elseif(NOT DEFINED ENABLE_BITCODE) + message(STATUS "[DEFAULTS] Disabling bitcode support by default on simulators. ENABLE_BITCODE not provided for override!") + set(ENABLE_BITCODE FALSE) +endif() +set(ENABLE_BITCODE_INT ${ENABLE_BITCODE} CACHE BOOL + "Whether or not to enable bitcode" FORCE) +# Use ARC or not +if(NOT DEFINED ENABLE_ARC) + # Unless specified, enable ARC support by default + set(ENABLE_ARC TRUE) + message(STATUS "[DEFAULTS] Enabling ARC support by default. ENABLE_ARC not provided!") +endif() +set(ENABLE_ARC_INT ${ENABLE_ARC} CACHE BOOL "Whether or not to enable ARC" FORCE) +# Use hidden visibility or not +if(NOT DEFINED ENABLE_VISIBILITY) + # Unless specified, disable symbols visibility by default + set(ENABLE_VISIBILITY FALSE) + message(STATUS "[DEFAULTS] Hiding symbols visibility by default. ENABLE_VISIBILITY not provided!") +endif() +set(ENABLE_VISIBILITY_INT ${ENABLE_VISIBILITY} CACHE BOOL "Whether or not to hide symbols from the dynamic linker (-fvisibility=hidden)" FORCE) +# Set strict compiler checks or not +if(NOT DEFINED ENABLE_STRICT_TRY_COMPILE) + # Unless specified, disable strict try_compile() + set(ENABLE_STRICT_TRY_COMPILE FALSE) + message(STATUS "[DEFAULTS] Using NON-strict compiler checks by default. ENABLE_STRICT_TRY_COMPILE not provided!") +endif() +set(ENABLE_STRICT_TRY_COMPILE_INT ${ENABLE_STRICT_TRY_COMPILE} CACHE BOOL + "Whether or not to use strict compiler checks" FORCE) + +# Get the SDK version information. +if(DEFINED SDK_VERSION) + # Environment variables are always preserved. + set(ENV{_SDK_VERSION} "${SDK_VERSION}") +elseif(DEFINED ENV{_SDK_VERSION}) + set(SDK_VERSION "$ENV{_SDK_VERSION}") +elseif(NOT DEFINED SDK_VERSION) + execute_process(COMMAND ${XCODEBUILD_EXECUTABLE} -sdk ${CMAKE_OSX_SYSROOT_INT} -version SDKVersion + OUTPUT_VARIABLE SDK_VERSION + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +endif() + +# Find the Developer root for the specific iOS platform being compiled for +# from CMAKE_OSX_SYSROOT. Should be ../../ from SDK specified in +# CMAKE_OSX_SYSROOT. There does not appear to be a direct way to obtain +# this information from xcrun or xcodebuild. +if (NOT DEFINED CMAKE_DEVELOPER_ROOT AND NOT CMAKE_GENERATOR MATCHES "Xcode") + get_filename_component(PLATFORM_SDK_DIR ${CMAKE_OSX_SYSROOT_INT} PATH) + get_filename_component(CMAKE_DEVELOPER_ROOT ${PLATFORM_SDK_DIR} PATH) + if (NOT EXISTS "${CMAKE_DEVELOPER_ROOT}") + message(FATAL_ERROR "Invalid CMAKE_DEVELOPER_ROOT: ${CMAKE_DEVELOPER_ROOT} does not exist.") + endif() +endif() + +# Find the C & C++ compilers for the specified SDK. +if(DEFINED CMAKE_C_COMPILER) + # Environment variables are always preserved. + set(ENV{_CMAKE_C_COMPILER} "${CMAKE_C_COMPILER}") +elseif(DEFINED ENV{_CMAKE_C_COMPILER}) + set(CMAKE_C_COMPILER "$ENV{_CMAKE_C_COMPILER}") +elseif(NOT DEFINED CMAKE_C_COMPILER) + execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT_INT} -find clang + OUTPUT_VARIABLE CMAKE_C_COMPILER + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +endif() +if(DEFINED CMAKE_CXX_COMPILER) + # Environment variables are always preserved. + set(ENV{_CMAKE_CXX_COMPILER} "${CMAKE_CXX_COMPILER}") +elseif(DEFINED ENV{_CMAKE_CXX_COMPILER}) + set(CMAKE_CXX_COMPILER "$ENV{_CMAKE_CXX_COMPILER}") +elseif(NOT DEFINED CMAKE_CXX_COMPILER) + execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT_INT} -find clang++ + OUTPUT_VARIABLE CMAKE_CXX_COMPILER + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +endif() +# Find (Apple's) libtool. +if(DEFINED BUILD_LIBTOOL) + # Environment variables are always preserved. + set(ENV{_BUILD_LIBTOOL} "${BUILD_LIBTOOL}") +elseif(DEFINED ENV{_BUILD_LIBTOOL}) + set(BUILD_LIBTOOL "$ENV{_BUILD_LIBTOOL}") +elseif(NOT DEFINED BUILD_LIBTOOL) + execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT_INT} -find libtool + OUTPUT_VARIABLE BUILD_LIBTOOL + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) +endif() +# Find the toolchain's provided install_name_tool if none is found on the host +if(DEFINED CMAKE_INSTALL_NAME_TOOL) + # Environment variables are always preserved. + set(ENV{_CMAKE_INSTALL_NAME_TOOL} "${CMAKE_INSTALL_NAME_TOOL}") +elseif(DEFINED ENV{_CMAKE_INSTALL_NAME_TOOL}) + set(CMAKE_INSTALL_NAME_TOOL "$ENV{_CMAKE_INSTALL_NAME_TOOL}") +elseif(NOT DEFINED CMAKE_INSTALL_NAME_TOOL) + execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT_INT} -find install_name_tool + OUTPUT_VARIABLE CMAKE_INSTALL_NAME_TOOL_INT + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + set(CMAKE_INSTALL_NAME_TOOL ${CMAKE_INSTALL_NAME_TOOL_INT} CACHE INTERNAL "") +endif() + +# Configure libtool to be used instead of ar + ranlib to build static libraries. +# This is required on Xcode 7+, but should also work on previous versions of +# Xcode. +get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES) +foreach(lang ${languages}) + set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "${BUILD_LIBTOOL} -static -o " CACHE INTERNAL "") +endforeach() + +# CMake 3.14+ support building for iOS, watchOS and tvOS out of the box. +if(MODERN_CMAKE) + if(SDK_NAME MATCHES "iphone") + set(CMAKE_SYSTEM_NAME iOS) + elseif(SDK_NAME MATCHES "macosx") + set(CMAKE_SYSTEM_NAME Darwin) + elseif(SDK_NAME MATCHES "appletv") + set(CMAKE_SYSTEM_NAME tvOS) + elseif(SDK_NAME MATCHES "watch") + set(CMAKE_SYSTEM_NAME watchOS) + endif() + # Provide flags for a combined FAT library build on newer CMake versions + if(PLATFORM_INT MATCHES ".*COMBINED") + set(CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH "NO") + set(CMAKE_IOS_INSTALL_COMBINED YES) + message(STATUS "Will combine built (static) artifacts into FAT lib...") + endif() +elseif(NOT DEFINED CMAKE_SYSTEM_NAME AND ${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.10") + # Legacy code path prior to CMake 3.14 or fallback if no CMAKE_SYSTEM_NAME specified + set(CMAKE_SYSTEM_NAME iOS) +elseif(NOT DEFINED CMAKE_SYSTEM_NAME) + # Legacy code path prior to CMake 3.14 or fallback if no CMAKE_SYSTEM_NAME specified + set(CMAKE_SYSTEM_NAME Darwin) +endif() +# Standard settings. +set(CMAKE_SYSTEM_VERSION ${SDK_VERSION} CACHE INTERNAL "") +set(UNIX TRUE CACHE BOOL "") +set(APPLE TRUE CACHE BOOL "") +if(PLATFORM STREQUAL "MAC" OR PLATFORM STREQUAL "MAC_ARM64") + set(IOS FALSE CACHE BOOL "") + set(MACOS TRUE CACHE BOOL "") +elseif(PLATFORM STREQUAL "MAC_CATALYST" OR PLATFORM STREQUAL "MAC_CATALYST_ARM64") + set(IOS TRUE CACHE BOOL "") + set(MACOS TRUE CACHE BOOL "") +else() + set(IOS TRUE CACHE BOOL "") +endif() +set(CMAKE_AR ar CACHE FILEPATH "" FORCE) +set(CMAKE_RANLIB ranlib CACHE FILEPATH "" FORCE) +set(CMAKE_STRIP strip CACHE FILEPATH "" FORCE) +# Set the architectures for which to build. +set(CMAKE_OSX_ARCHITECTURES ${ARCHS} CACHE INTERNAL "") +# Change the type of target generated for try_compile() so it'll work when cross-compiling, weak compiler checks +if(NOT ENABLE_STRICT_TRY_COMPILE_INT) + set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) +endif() +# All iOS/Darwin specific settings - some may be redundant. +set(CMAKE_MACOSX_BUNDLE YES) +set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "NO") +set(CMAKE_SHARED_LIBRARY_PREFIX "lib") +set(CMAKE_SHARED_LIBRARY_SUFFIX ".dylib") +set(CMAKE_SHARED_MODULE_PREFIX "lib") +set(CMAKE_SHARED_MODULE_SUFFIX ".so") +set(CMAKE_C_COMPILER_ABI ELF) +set(CMAKE_CXX_COMPILER_ABI ELF) +set(CMAKE_C_HAS_ISYSROOT 1) +set(CMAKE_CXX_HAS_ISYSROOT 1) +set(CMAKE_MODULE_EXISTS 1) +set(CMAKE_DL_LIBS "") +set(CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ") +set(CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ") +set(CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}") +set(CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}") + +if(ARCHS MATCHES "((^|;|, )(arm64|arm64e|x86_64))+") + set(CMAKE_C_SIZEOF_DATA_PTR 8) + set(CMAKE_CXX_SIZEOF_DATA_PTR 8) + if(ARCHS MATCHES "((^|;|, )(arm64|arm64e))+") + set(CMAKE_SYSTEM_PROCESSOR "aarch64") + else() + set(CMAKE_SYSTEM_PROCESSOR "x86_64") + endif() +else() + set(CMAKE_C_SIZEOF_DATA_PTR 4) + set(CMAKE_CXX_SIZEOF_DATA_PTR 4) + set(CMAKE_SYSTEM_PROCESSOR "arm") +endif() + +# Note that only Xcode 7+ supports the newer more specific: +# -m${SDK_NAME}-version-min flags, older versions of Xcode use: +# -m(ios/ios-simulator)-version-min instead. +if(${CMAKE_VERSION} VERSION_LESS "3.11") + if(PLATFORM_INT STREQUAL "OS" OR PLATFORM_INT STREQUAL "OS64") + if(XCODE_VERSION_INT VERSION_LESS 7.0) + set(SDK_NAME_VERSION_FLAGS + "-mios-version-min=${DEPLOYMENT_TARGET}") + else() + # Xcode 7.0+ uses flags we can build directly from SDK_NAME. + set(SDK_NAME_VERSION_FLAGS + "-m${SDK_NAME}-version-min=${DEPLOYMENT_TARGET}") + endif() + elseif(PLATFORM_INT STREQUAL "TVOS") + set(SDK_NAME_VERSION_FLAGS + "-mtvos-version-min=${DEPLOYMENT_TARGET}") + elseif(PLATFORM_INT STREQUAL "SIMULATOR_TVOS") + set(SDK_NAME_VERSION_FLAGS + "-mtvos-simulator-version-min=${DEPLOYMENT_TARGET}") + elseif(PLATFORM_INT STREQUAL "WATCHOS") + set(SDK_NAME_VERSION_FLAGS + "-mwatchos-version-min=${DEPLOYMENT_TARGET}") + elseif(PLATFORM_INT STREQUAL "SIMULATOR_WATCHOS") + set(SDK_NAME_VERSION_FLAGS + "-mwatchos-simulator-version-min=${DEPLOYMENT_TARGET}") + elseif(PLATFORM_INT STREQUAL "MAC") + set(SDK_NAME_VERSION_FLAGS + "-mmacosx-version-min=${DEPLOYMENT_TARGET}") + else() + # SIMULATOR or SIMULATOR64 both use -mios-simulator-version-min. + set(SDK_NAME_VERSION_FLAGS + "-mios-simulator-version-min=${DEPLOYMENT_TARGET}") + endif() +elseif(NOT PLATFORM_INT STREQUAL "MAC_CATALYST") + # Newer versions of CMake sets the version min flags correctly, skip this for Mac Catalyst targets + set(CMAKE_OSX_DEPLOYMENT_TARGET ${DEPLOYMENT_TARGET}) +endif() + +if(DEFINED APPLE_TARGET_TRIPLE_INT) + set(APPLE_TARGET_TRIPLE ${APPLE_TARGET_TRIPLE_INT} CACHE INTERNAL "") +endif() + +if(PLATFORM_INT STREQUAL "MAC_CATALYST") + set(C_TARGET_FLAGS "-target ${APPLE_TARGET_TRIPLE_INT} -isystem ${CMAKE_OSX_SYSROOT_INT}/System/iOSSupport/usr/include") +endif() + +if(ENABLE_BITCODE_INT) + set(BITCODE "-fembed-bitcode") + set(CMAKE_XCODE_ATTRIBUTE_BITCODE_GENERATION_MODE "bitcode") + set(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE "YES") +else() + set(BITCODE "") + set(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE "NO") +endif() + +if(ENABLE_ARC_INT) + set(FOBJC_ARC "-fobjc-arc") + set(CMAKE_XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC "YES") +else() + set(FOBJC_ARC "-fno-objc-arc") + set(CMAKE_XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC "NO") +endif() + +if(NOT ENABLE_VISIBILITY_INT) + foreach(lang ${languages}) + set(CMAKE_${lang}_VISIBILITY_PRESET "hidden" CACHE INTERNAL "") + endforeach() + set(CMAKE_XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN "YES") + set(VISIBILITY "-fvisibility=hidden -fvisibility-inlines-hidden") +else() + foreach(lang ${languages}) + set(CMAKE_${lang}_VISIBILITY_PRESET "default" CACHE INTERNAL "") + endforeach() + set(CMAKE_XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN "NO") + set(VISIBILITY "-fvisibility=default") +endif() + +#Check if Xcode generator is used, since that will handle these flags automagically +if(CMAKE_GENERATOR MATCHES "Xcode") + message(STATUS "Not setting any manual command-line buildflags, since Xcode is selected as generator.") +else() + # Hidden visibility is required for C++ on iOS. + set(CMAKE_C_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} ${BITCODE} -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_C_FLAGS}") + set(CMAKE_CXX_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_CXX_FLAGS}") + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS} -O0 -g ${CMAKE_CXX_FLAGS_DEBUG}") + set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS} -DNDEBUG -Os -ffast-math ${CMAKE_CXX_FLAGS_MINSIZEREL}") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS} -DNDEBUG -O2 -g -ffast-math ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}") + set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -DNDEBUG -O3 -ffast-math ${CMAKE_CXX_FLAGS_RELEASE}") + set(CMAKE_C_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}") + set(CMAKE_CXX_LINK_FLAGS "${C_TARGET_FLAGS} ${SDK_NAME_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}") + set(CMAKE_ASM_FLAGS "${CMAKE_C_FLAGS} -x assembler-with-cpp -arch ${CMAKE_OSX_ARCHITECTURES}") +endif() + +## Print status messages to inform of the current state +message(STATUS "Configuring ${SDK_NAME} build for platform: ${PLATFORM_INT}, architecture(s): ${ARCHS}") +message(STATUS "Using SDK: ${CMAKE_OSX_SYSROOT_INT}") +message(STATUS "Using C compiler: ${CMAKE_C_COMPILER}") +message(STATUS "Using CXX compiler: ${CMAKE_CXX_COMPILER}") +message(STATUS "Using libtool: ${BUILD_LIBTOOL}") +message(STATUS "Using install name tool: ${CMAKE_INSTALL_NAME_TOOL}") +if(DEFINED APPLE_TARGET_TRIPLE) + message(STATUS "Autoconf target triple: ${APPLE_TARGET_TRIPLE}") +endif() +message(STATUS "Using minimum deployment version: ${DEPLOYMENT_TARGET}" + " (SDK version: ${SDK_VERSION})") +if(MODERN_CMAKE) + message(STATUS "Merging integrated CMake 3.14+ iOS,tvOS,watchOS,macOS toolchain(s) with this toolchain!") +endif() +if(CMAKE_GENERATOR MATCHES "Xcode") + message(STATUS "Using Xcode version: ${XCODE_VERSION_INT}") +endif() +message(STATUS "CMake version: ${CMAKE_VERSION}") +if(DEFINED SDK_NAME_VERSION_FLAGS) + message(STATUS "Using version flags: ${SDK_NAME_VERSION_FLAGS}") +endif() +message(STATUS "Using a data_ptr size of: ${CMAKE_CXX_SIZEOF_DATA_PTR}") +if(ENABLE_BITCODE_INT) + message(STATUS "Bitcode: Enabled") +else() + message(STATUS "Bitcode: Disabled") +endif() + +if(ENABLE_ARC_INT) + message(STATUS "ARC: Enabled") +else() + message(STATUS "ARC: Disabled") +endif() + +if(ENABLE_VISIBILITY_INT) + message(STATUS "Hiding symbols: Disabled") +else() + message(STATUS "Hiding symbols: Enabled") +endif() + +# Set global properties +set_property(GLOBAL PROPERTY PLATFORM "${PLATFORM}") +set_property(GLOBAL PROPERTY APPLE_TARGET_TRIPLE "${APPLE_TARGET_TRIPLE_INT}") +set_property(GLOBAL PROPERTY SDK_VERSION "${SDK_VERSION}") +set_property(GLOBAL PROPERTY XCODE_VERSION "${XCODE_VERSION_INT}") +set_property(GLOBAL PROPERTY OSX_ARCHITECTURES "${CMAKE_OSX_ARCHITECTURES}") + +# Export configurable variables for the try_compile() command. +set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES + PLATFORM + XCODE_VERSION_INT + SDK_VERSION + DEPLOYMENT_TARGET + CMAKE_DEVELOPER_ROOT + CMAKE_OSX_SYSROOT_INT + ENABLE_BITCODE + ENABLE_ARC + CMAKE_C_COMPILER + CMAKE_CXX_COMPILER + BUILD_LIBTOOL + CMAKE_INSTALL_NAME_TOOL + CMAKE_C_FLAGS + CMAKE_CXX_FLAGS + CMAKE_CXX_FLAGS_DEBUG + CMAKE_CXX_FLAGS_MINSIZEREL + CMAKE_CXX_FLAGS_RELWITHDEBINFO + CMAKE_CXX_FLAGS_RELEASE + CMAKE_C_LINK_FLAGS + CMAKE_CXX_LINK_FLAGS + CMAKE_ASM_FLAGS + ) + +set(CMAKE_PLATFORM_HAS_INSTALLNAME 1) +set(CMAKE_SHARED_LINKER_FLAGS "-rpath @executable_path/Frameworks -rpath @loader_path/Frameworks") +set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib -Wl,-headerpad_max_install_names") +set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle -Wl,-headerpad_max_install_names") +set(CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,") +set(CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,") +set(CMAKE_FIND_LIBRARY_SUFFIXES ".tbd" ".dylib" ".so" ".a") +set(CMAKE_SHARED_LIBRARY_SONAME_C_FLAG "-install_name") + +# Set the find root to the SDK developer roots. +# Note: CMAKE_FIND_ROOT_PATH is only useful when cross-compiling. Thus, do not set on macOS builds. +if(NOT PLATFORM_INT STREQUAL "MAC" AND NOT PLATFORM_INT STREQUAL "MAC_ARM64") + list(APPEND CMAKE_FIND_ROOT_PATH "${CMAKE_OSX_SYSROOT_INT}" CACHE INTERNAL "") + set(CMAKE_IGNORE_PATH "/System/Library/Frameworks;/usr/local/lib" CACHE INTERNAL "") +endif() + +# Default to searching for frameworks first. +set(CMAKE_FIND_FRAMEWORK FIRST) + +# Set up the default search directories for frameworks. +if(PLATFORM_INT MATCHES "MAC_CATALYST.*") + set(CMAKE_FRAMEWORK_PATH + ${CMAKE_DEVELOPER_ROOT}/Library/PrivateFrameworks + ${CMAKE_OSX_SYSROOT_INT}/System/Library/Frameworks + ${CMAKE_OSX_SYSROOT_INT}/System/iOSSupport/System/Library/Frameworks + ${CMAKE_FRAMEWORK_PATH} CACHE INTERNAL "") +else() + set(CMAKE_FRAMEWORK_PATH + ${CMAKE_DEVELOPER_ROOT}/Library/PrivateFrameworks + ${CMAKE_OSX_SYSROOT_INT}/System/Library/Frameworks + ${CMAKE_FRAMEWORK_PATH} CACHE INTERNAL "") +endif() + +# By default, search both the specified iOS SDK and the remainder of the host filesystem. +if(NOT CMAKE_FIND_ROOT_PATH_MODE_PROGRAM) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH CACHE INTERNAL "") +endif() +if(NOT CMAKE_FIND_ROOT_PATH_MODE_LIBRARY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH CACHE INTERNAL "") +endif() +if(NOT CMAKE_FIND_ROOT_PATH_MODE_INCLUDE) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH CACHE INTERNAL "") +endif() +if(NOT CMAKE_FIND_ROOT_PATH_MODE_PACKAGE) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH CACHE INTERNAL "") +endif() + +# +# Some helper-macros below to simplify and beautify the CMakeFile +# + +# This little macro lets you set any Xcode specific property. +macro(set_xcode_property TARGET XCODE_PROPERTY XCODE_VALUE XCODE_RELVERSION) + set(XCODE_RELVERSION_I "${XCODE_RELVERSION}") + if(XCODE_RELVERSION_I STREQUAL "All") + set_property(TARGET ${TARGET} PROPERTY XCODE_ATTRIBUTE_${XCODE_PROPERTY} "${XCODE_VALUE}") + else() + set_property(TARGET ${TARGET} PROPERTY XCODE_ATTRIBUTE_${XCODE_PROPERTY}[variant=${XCODE_RELVERSION_I}] "${XCODE_VALUE}") + endif() +endmacro(set_xcode_property) + +# This macro lets you find executable programs on the host system. +macro(find_host_package) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE NEVER) + set(_TOOLCHAIN_IOS ${IOS}) + set(IOS FALSE) + find_package(${ARGN}) + set(IOS ${_TOOLCHAIN_IOS}) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH) +endmacro(find_host_package) \ No newline at end of file diff --git a/cxplat.kernel.sln b/cxplat.kernel.sln new file mode 100644 index 0000000..3a6a728 --- /dev/null +++ b/cxplat.kernel.sln @@ -0,0 +1,35 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29728.190 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{BC8DFCC2-43CB-481C-988F-C39903116328}") = "cxplat.kernel", "src\lib\cxplat.kernel.vcxproj", "{E680F075-FEE8-421B-A9F1-DAD0A1C537D3}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|ARM64 = Debug|ARM64 + Debug|x64 = Debug|x64 + Release|ARM64 = Release|ARM64 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Debug|ARM64.ActiveCfg = Debug|ARM64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Debug|ARM64.Build.0 = Debug|ARM64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Debug|ARM64.Deploy.0 = Debug|ARM64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Debug|x64.ActiveCfg = Debug|x64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Debug|x64.Build.0 = Debug|x64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Debug|x64.Deploy.0 = Debug|x64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Release|ARM64.ActiveCfg = Release|ARM64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Release|ARM64.Build.0 = Release|ARM64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Release|ARM64.Deploy.0 = Release|ARM64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Release|x64.ActiveCfg = Release|x64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Release|x64.Build.0 = Release|x64 + {E680F075-FEE8-421B-A9F1-DAD0A1C537D3}.Release|x64.Deploy.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {F075D3C0-2C78-44DF-9CFF-F85789AE1205} + EndGlobalSection +EndGlobal diff --git a/inc/cxplat.h b/inc/cxplat.h new file mode 100644 index 0000000..252e0be --- /dev/null +++ b/inc/cxplat.h @@ -0,0 +1,22 @@ +/*++ + + Copyright (c) Microsoft Corporation. + Licensed under the MIT License. + +Abstract: + + Platform definitions. + +--*/ + +#ifdef CX_PLATFORM_WINKERNEL +#include "cxplat_winkernel.h" +#elif CX_PLATFORM_WINUSER +#include "cxplat_winuser.h" +#elif CX_PLATFORM_LINUX +#include "cxplat_posix.h" +#elif CX_PLATFORM_DARWIN +#include "cxplat_posix.h" +#else +#error "Unsupported Platform" +#endif diff --git a/inc/cxplat_posix.h b/inc/cxplat_posix.h new file mode 100644 index 0000000..4f63c2f --- /dev/null +++ b/inc/cxplat_posix.h @@ -0,0 +1,24 @@ +/*++ + + Copyright (c) Microsoft Corporation. + Licensed under the MIT License. + +Abstract: + + Posix platform definitions. + +--*/ + +#ifndef CXPLAT_POSIX_H +#define CXPLAT_POSIX_H + +#if defined(__cplusplus) +extern "C" { +#endif + + +#if defined(__cplusplus) +} +#endif + +#endif // CXPLAT_POSIX_H diff --git a/inc/cxplat_winkernel.h b/inc/cxplat_winkernel.h new file mode 100644 index 0000000..5d410e1 --- /dev/null +++ b/inc/cxplat_winkernel.h @@ -0,0 +1,24 @@ +/*++ + + Copyright (c) Microsoft Corporation. + Licensed under the MIT License. + +Abstract: + + Windows kernel-mode platform definitions. + +--*/ + +#ifndef CXPLAT_WINKERNEL_H +#define CXPLAT_WINKERNEL_H + +#if defined(__cplusplus) +extern "C" { +#endif + + +#if defined(__cplusplus) +} +#endif + +#endif // CXPLAT_WINKERNEL_H diff --git a/inc/cxplat_winuser.h b/inc/cxplat_winuser.h new file mode 100644 index 0000000..9213264 --- /dev/null +++ b/inc/cxplat_winuser.h @@ -0,0 +1,24 @@ +/*++ + + Copyright (c) Microsoft Corporation. + Licensed under the MIT License. + +Abstract: + + Windows user-mode platform definitions. + +--*/ + +#ifndef CXPLAT_WINUSER_H +#define CXPLAT_WINUSER_H + +#if defined(__cplusplus) +extern "C" { +#endif + + +#if defined(__cplusplus) +} +#endif + +#endif // CXPLAT_WINUSER_H diff --git a/scripts/build.ps1 b/scripts/build.ps1 new file mode 100644 index 0000000..8a5d79d --- /dev/null +++ b/scripts/build.ps1 @@ -0,0 +1,423 @@ +<# + +.SYNOPSIS +This script provides helpers for building cxplat. + +.PARAMETER Config + The debug or release configuration to build for. + +.PARAMETER Arch + The CPU architecture to build for. + +.PARAMETER Platform + Specify which platform to build for. + +.PARAMETER Clean + Deletes all previous build and configuration. + +.PARAMETER Parallel + Enables CMake to build in parallel, where possible. + +.PARAMETER Generator + Specifies a specific cmake generator (Only supported on unix) + +.PARAMETER SkipPdbAltPath + Skip setting PDBALTPATH into built binaries on Windows. Without this flag, the PDB must be in the same directory as the DLL or EXE. + +.PARAMETER Clang + Build with Clang if available + +.PARAMETER ConfigureOnly + Run configuration only. + +.PARAMETER CI + Build is occuring from CI + +.PARAMETER OfficialRelease + Build is for an official (tag) release. + +.PARAMETER ExtraArtifactDir + Add an extra classifier to the artifact directory to allow publishing alternate builds of same base library + +.PARAMETER LibraryName + Renames the library to whatever is passed in + +.PARAMETER SysRoot + Directory with cross-compilation tools + +.PARAMETER OneBranch + Build is occuring from Onebranch pipeline. + +.EXAMPLE + build.ps1 + +.EXAMPLE + build.ps1 -Config Release + +#> + +param ( + [Parameter(Mandatory = $false)] + [ValidateSet("Debug", "Release")] + [string]$Config = "Debug", + + [Parameter(Mandatory = $false)] + [ValidateSet("x86", "x64", "arm", "arm64", "arm64ec")] + [string]$Arch = "", + + [Parameter(Mandatory = $false)] + [ValidateSet("gamecore_console", "uwp", "windows", "linux", "macos", "android", "ios", "winkernel")] # For future expansion + [string]$Platform = "", + + [Parameter(Mandatory = $false)] + [switch]$Clean = $false, + + [Parameter(Mandatory = $false)] + [int32]$Parallel = -2, + + [Parameter(Mandatory = $false)] + [string]$Generator = "", + + [Parameter(Mandatory = $false)] + [switch]$SkipPdbAltPath = $false, + + [Parameter(Mandatory = $false)] + [switch]$Clang = $false, + + [Parameter(Mandatory = $false)] + [switch]$ConfigureOnly = $false, + + [Parameter(Mandatory = $false)] + [switch]$CI = $false, + + [Parameter(Mandatory = $false)] + [switch]$OfficialRelease = $false, + + [Parameter(Mandatory = $false)] + [string]$ExtraArtifactDir = "", + + [Parameter(Mandatory = $false)] + [string]$LibraryName = "cxplat", + + [Parameter(Mandatory = $false)] + [string]$SysRoot = "/", + + [Parameter(Mandatory = $false)] + [switch]$OneBranch = $false, + + [Parameter(Mandatory = $false)] + [string]$ToolchainFile = "" +) + +Set-StrictMode -Version 'Latest' +$PSDefaultParameterValues['*:ErrorAction'] = 'Stop' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + # For convenience of locally building winkernel (which is typically done from a Developer shell for VS), + # exclude winkernel from the PowerShell core requirement. + if ($Platform -ne "winkernel") { + Write-Error "[$(Get-Date)] PowerShell v7.x or greater is needed for this script to work." + } + + $IsWindows = $true + $IsLinux = $false + $IsMacOS = $false +} + +if ($Parallel -lt -1) { + if ($IsWindows) { + $Parallel = -1 + } else { + $Parallel = 0 + } +} + +$BuildConfig = & (Join-Path $PSScriptRoot get-buildconfig.ps1) -Platform $Platform -Arch $Arch -ExtraArtifactDir $ExtraArtifactDir -Config $Config + +$Platform = $BuildConfig.Platform +$Arch = $BuildConfig.Arch +$ArtifactsDir = $BuildConfig.ArtifactsDir + +if ($Generator -eq "") { + if (!$IsWindows) { + $Generator = "Unix Makefiles" + } else { + $Generator = "Visual Studio 17 2022" + } +} + +if (!$IsWindows -And $Platform -eq "uwp") { + Write-Error "[$(Get-Date)] Cannot build uwp on non windows platforms" +} + +if (!$IsWindows -And ($Platform -eq "gamecore_console")) { + Write-Error "[$(Get-Date)] Cannot build gamecore on non windows platforms" +} + +if ($Arch -ne "x64" -And ($Platform -eq "gamecore_console")) { + Write-Error "[$(Get-Date)] Cannot build gamecore for non-x64 platforms" +} + +if ($Arch -eq "arm64ec") { + if (!$IsWindows) { + Write-Error "[$(Get-Date)] Arm64EC is only supported on Windows" + } +} + +if ($OfficialRelease) { + # We only actually try to do official release if there is a matching git tag. + # Clear the flag and then only set it if we find a tag. + $OfficialRelease = $false + try { + $env:GIT_REDIRECT_STDERR = '2>&1' + # Thanks to https://stackoverflow.com/questions/3404936/show-which-git-tag-you-are-on + # for this magic git command! + $Output = git describe --exact-match --tags $(git log -n1 --pretty='%h') + if (!$Output.Contains("fatal: no tag exactly matches")) { + Log "Configuring OfficialRelease for tag build" + $OfficialRelease = $true + } + } catch { } + $global:LASTEXITCODE = 0 +} + +# Root directory of the project. +$RootDir = Split-Path $PSScriptRoot -Parent + +# Important directory paths. +$BaseArtifactsDir = Join-Path $RootDir "artifacts" +$BaseBuildDir = Join-Path $RootDir "build" + +$BuildDir = Join-Path $BaseBuildDir $Platform +$BuildDir = Join-Path $BuildDir "$($Arch)" + +if ($Clean) { + # Delete old build/config directories. + if (Test-Path $ArtifactsDir) { Remove-Item $ArtifactsDir -Recurse -Force | Out-Null } + if (Test-Path $BuildDir) { Remove-Item $BuildDir -Recurse -Force | Out-Null } +} + +# Initialize directories needed for building. +if (!(Test-Path $BaseArtifactsDir)) { + New-Item -Path $BaseArtifactsDir -ItemType Directory -Force | Out-Null +} +if (!(Test-Path $ArtifactsDir)) { + New-Item -Path $ArtifactsDir -ItemType Directory -Force | Out-Null +} +if (!(Test-Path $BuildDir)) { + New-Item -Path $BuildDir -ItemType Directory -Force | Out-Null +} + +if ($Clang) { + if ($IsWindows) { + Write-Error "[$(Get-Date)] Clang is not supported on windows currently" + } + $env:CC = 'clang' + $env:CXX = 'clang++' +} + +function Log($msg) { + Write-Host "[$(Get-Date)] $msg" +} + +# Executes cmake with the given arguments. +function CMake-Execute([String]$Arguments) { + Log "cmake $($Arguments)" + $process = Start-Process cmake $Arguments -PassThru -NoNewWindow -WorkingDirectory $BuildDir + $handle = $process.Handle # Magic work around. Don't remove this line. + $process.WaitForExit(); + + if ($process.ExitCode -ne 0) { + Write-Error "[$(Get-Date)] CMake exited with status code $($process.ExitCode)" + } +} + +# Uses cmake to generate the build configuration files. +function CMake-Generate { + $Arguments = "" + + if ($Generator.Contains(" ")) { + $Generator = """$Generator""" + } + + if ($IsWindows) { + if ($Generator.Contains("Visual Studio") -or [string]::IsNullOrWhiteSpace($Generator)) { + if ($Generator.Contains("Visual Studio")) { + $Arguments += " -G $Generator" + } + $Arguments += " -A " + switch ($Arch) { + "x86" { $Arguments += "Win32" } + "x64" { $Arguments += "x64" } + "arm" { $Arguments += "arm" } + "arm64" { $Arguments += "arm64" } + "arm64ec" { $Arguments += "arm64ec" } + } + } else { + Log "Non VS based generators must be run from a Visual Studio Developer Powershell Prompt matching the passed in architecture" + $Arguments += " -G $Generator" + } + } else { + $Arguments += "-G $Generator" + } + if ($Platform -eq "ios") { + $IosTCFile = Join-Path $RootDir cmake toolchains ios.cmake + $Arguments += " -DCMAKE_TOOLCHAIN_FILE=""$IosTCFile"" -DDEPLOYMENT_TARGET=""13.0"" -DENABLE_ARC=0 -DCMAKE_OSX_DEPLOYMENT_TARGET=""13.0""" + switch ($Arch) { + "x64" { $Arguments += " -DPLATFORM=SIMULATOR64"} + "arm64" { $Arguments += " -DPLATFORM=OS64"} + } + } + if ($Platform -eq "macos") { + switch ($Arch) { + "x64" { $Arguments += " -DCMAKE_OSX_ARCHITECTURES=x86_64 -DCMAKE_OSX_DEPLOYMENT_TARGET=""12"""} + "arm64" { $Arguments += " -DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_OSX_DEPLOYMENT_TARGET=""11.0"""} + } + } + if ($Platform -eq "linux") { + $Arguments += " $Generator" + $HostArch = "$([System.Runtime.InteropServices.RuntimeInformation]::ProcessArchitecture)".ToLower() + if ($HostArch -ne $Arch) { + if ($OneBranch) { + $Arguments += " -DONEBRANCH=1" + if ($ToolchainFile -eq "") { + switch ($Arch) { + "arm" { $ToolchainFile = "cmake/toolchains/arm-linux.cmake" } + "arm64" { $ToolchainFile = "cmake/toolchains/aarch64-linux.cmake" } + } + } + } + $Arguments += " -DCMAKE_FIND_ROOT_PATH_MODE_PROGRAM=NEVER -DCMAKE_CROSSCOMPILING=1 -DCMAKE_SYSROOT=$SysRoot" + switch ($Arch) { + "arm64" { $Arguments += " -DCMAKE_CXX_COMPILER_TARGET=aarch64-linux-gnu -DCMAKE_C_COMPILER_TARGET=aarch64-linux-gnu -DCMAKE_TARGET_ARCHITECTURE=arm64" } + "arm" { $Arguments += " -DCMAKE_CXX_COMPILER_TARGET=arm-linux-gnueabihf -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabihf -DCMAKE_TARGET_ARCHITECTURE=arm" } + } + + # to build with pkg-config + switch ($Arch) { + "arm" { $env:PKG_CONFIG_PATH="$SysRoot/usr/lib/arm-linux-gnueabihf/pkgconfig" } + "arm64" { $env:PKG_CONFIG_PATH="$SysRoot/usr/lib/aarch64-linux-gnu/pkgconfig" } + } + } + } + if ($ToolchainFile -ne "") { + $Arguments += " -DCMAKE_TOOLCHAIN_FILE=""$ToolchainFile""" + } + + $Arguments += " -DCXPLAT_OUTPUT_DIR=""$ArtifactsDir""" + + if (!$IsWindows) { + $ConfigToBuild = $Config; + if ($Config -eq "Release") { + $ConfigToBuild = "RelWithDebInfo" + } + $Arguments += " -DCMAKE_BUILD_TYPE=" + $ConfigToBuild + } + if ($Platform -eq "uwp") { + $Arguments += " -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0 -DCXPLAT_UWP_BUILD=on" + } + if ($Platform -eq "gamecore_console") { + $Arguments += " -DCMAKE_SYSTEM_VERSION=10.0 -DCXPLAT_GAMECORE_BUILD=on" + } + if ($SkipPdbAltPath) { + $Arguments += " -DCXPLAT_PDBALTPATH=OFF" + } + if ($CI) { + $Arguments += " -DCXPLAT_CI=ON" + if ($Platform -eq "android" -or $ToolchainFile -ne "") { + $Arguments += " -DCXPLAT_SKIP_CI_CHECKS=ON" + } + $Arguments += " -DCXPLAT_VER_BUILD_ID=$env:BUILD_BUILDID" + $Arguments += " -DCXPLAT_VER_SUFFIX=-official" + } + if ($OfficialRelease) { + $Arguments += " -DCXPLAT_OFFICIAL_RELEASE=ON" + } + if ($Platform -eq "android") { + $NDK = $env:ANDROID_NDK_LATEST_HOME -replace '26\.\d+\.\d+', '25.2.9519653' # Temporary work around. Use RegEx to replace newer version. + $env:PATH = "$NDK/toolchains/llvm/prebuilt/linux-x86_64/bin:$env:PATH" + switch ($Arch) { + "x86" { $Arguments += " -DANDROID_ABI=x86"} + "x64" { $Arguments += " -DANDROID_ABI=x86_64" } + "arm" { $Arguments += " -DANDROID_ABI=armeabi-v7a" } + "arm64" { $Arguments += " -DANDROID_ABI=arm64-v8a" } + } + $Arguments += " -DANDROID_PLATFORM=android-29" + $env:ANDROID_NDK_HOME = $NDK + $NdkToolchainFile = "$NDK/build/cmake/android.toolchain.cmake" + $Arguments += " -DANDROID_NDK=""$NDK""" + $Arguments += " -DCMAKE_TOOLCHAIN_FILE=""$NdkToolchainFile""" + } + + $Arguments += " -DCXPLAT_LIBRARY_NAME=$LibraryName" + $Arguments += " ../../.." + + Log "Executing: $Arguments" + CMake-Execute $Arguments +} + + +# Uses cmake to generate the build configuration files. +function CMake-Build { + $Arguments = "--build ." + if ($Parallel -gt 0) { + $Arguments += " --parallel $($Parallel)" + } elseif ($Parallel -eq 0) { + $Arguments += " --parallel" + } + if ($IsWindows) { + $Arguments += " --config " + $Config + } else { + $Arguments += " -- VERBOSE=1" + } + + Log "Running: $Arguments" + CMake-Execute $Arguments + + if ($IsWindows) { + Copy-Item (Join-Path $BuildDir "obj" $Config "$LibraryName.lib") $ArtifactsDir + } elseif ($IsLinux -and $OneBranch) { + # archive the build artifacts for packaging to persist symlinks and permissons. + $ArtifactsParentDir = Split-Path $ArtifactsDir -Parent + $ArtifactsLeafDir = Split-Path $ArtifactsDir -Leaf + tar -cvf "$ArtifactsDir.tar" -C $ArtifactsParentDir "./$ArtifactsLeafDir" + } + + # Package debug symbols on macos + if ($Platform -eq "macos") { + $BuiltArtifacts = Get-ChildItem $ArtifactsDir -File + foreach ($Artifact in $BuiltArtifacts) { + if (Test-Path $Artifact) { + dsymutil $Artifact + } + } + } +} + +############################################################## +# Main Execution # +############################################################## + +if ($Platform -eq "winkernel") { + # Restore Nuget packages. + Log "Restoring packages..." + msbuild cxplat.kernel.sln -t:restore /p:RestorePackagesConfig=true /p:Configuration=$Config /p:Platform=$Arch + + if (!$ConfigureOnly) { + # Build the code. + Log "Building..." + msbuild cxplat.kernel.sln /m /p:Configuration=$Config /p:Platform=$Arch + } +} else { + # Generate the build files. + Log "Generating files..." + CMake-Generate + + if (!$ConfigureOnly) { + # Build the code. + Log "Building..." + CMake-Build + } +} + +Log "Done." diff --git a/scripts/get-buildconfig.ps1 b/scripts/get-buildconfig.ps1 new file mode 100644 index 0000000..2e0b917 --- /dev/null +++ b/scripts/get-buildconfig.ps1 @@ -0,0 +1,118 @@ +<# + +.SYNOPSIS +This script provides a build config helper used by multiple build scripts. + +.PARAMETER Config + The debug or release configuration to build for. + +.PARAMETER Arch + The CPU architecture to build for. + +.PARAMETER Platform + Specify which platform to build for + +.PARAMETER ExtraArtifactDir + Add an extra classifier to the artifact directory to allow publishing alternate builds of same base library + +#> + +param ( + [Parameter(Mandatory = $false)] + [ValidateSet("Debug", "Release")] + [string]$Config = "Debug", + + [Parameter(Mandatory = $false)] + [ValidateSet("x86", "x64", "arm", "arm64", "arm64ec", "universal", "")] + [string]$Arch = "", + + [Parameter(Mandatory = $false)] + [ValidateSet("gamecore_console", "uwp", "windows", "linux", "macos", "android", "ios", "winkernel", "")] # For future expansion + [string]$Platform = "", + + [Parameter(Mandatory = $false)] + [string]$ExtraArtifactDir = "" +) + +Set-StrictMode -Version 'Latest' +$PSDefaultParameterValues['*:ErrorAction'] = 'Stop' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + # For convenience of locally building winkernel (which is typically done from a Developer shell for VS), + # exclude winkernel from the PowerShell core requirement. + if ($Platform -ne "winkernel") { + Write-Error "PowerShell v7.x or greater is needed for this script to work." + } + + $IsWindows = $true + $IsLinux = $false + $IsMacOS = $false +} + +if ($Platform -eq "android") { + if (!$IsLinux) { + Write-Error "Can only build android on linux" + } + if ($Arch -eq "") { + $Arch = "arm64" + } +} + +if ($Platform -eq "ios") { + if (!$IsMacOS) { + Write-Error "Can only build ios on macOS" + } + if ($Arch -eq "") { + $Arch = "arm64" + } +} + +if ("" -eq $Arch) { + if ($IsMacOS) { + $RunningArch = uname -m + if ("x86_64" -eq $RunningArch) { + $IsTranslated = sysctl -in sysctl.proc_translated + if ($IsTranslated) { + $Arch = "arm64" + } else { + $Arch = "x64" + } + } elseif ("arm64" -eq $RunningArch) { + $Arch = "arm64" + } else { + Write-Error "Unknown architecture" + } + } elseif ($IsLinux) { + $Arch = "$([System.Runtime.InteropServices.RuntimeInformation]::ProcessArchitecture)".ToLower() + } else { + $Arch = "x64" + } +} + +if ("" -eq $Platform) { + if ($IsWindows) { + $Platform = "windows" + } elseif ($IsLinux) { + $Platform = "linux" + } elseif ($IsMacOS) { + $Platform = "macos" + } else { + Write-Error "Unsupported platform type!" + } +} + +$RootDir = Split-Path $PSScriptRoot -Parent +$BaseArtifactsDir = Join-Path $RootDir "artifacts" +$ArtifactsDir = Join-Path $BaseArtifactsDir "bin" +$ArtifactsDir = Join-Path $ArtifactsDir $Platform +if ([string]::IsNullOrWhitespace($ExtraArtifactDir)) { + $ArtifactsDir = Join-Path $ArtifactsDir "$($Arch)_$($Config)" +} else { + $ArtifactsDir = Join-Path $ArtifactsDir "$($Arch)_$($Config)_$($ExtraArtifactDir)" +} + +return @{ + Platform = $Platform + Arch = $Arch + ArtifactsDir = $ArtifactsDir +} diff --git a/scripts/prepare-machine.ps1 b/scripts/prepare-machine.ps1 new file mode 100644 index 0000000..ef8243e --- /dev/null +++ b/scripts/prepare-machine.ps1 @@ -0,0 +1,71 @@ +<# + +.SYNOPSIS +This script installs all necessary dependencies on the machine, depending +on the provided configuration. + +.EXAMPLE + prepare-machine.ps1 + +.EXAMPLE + prepare-machine.ps1 -ForBuild + +#> + +param ( + [Parameter(Mandatory = $false)] + [switch]$ForBuild, + + [Parameter(Mandatory = $false)] + [switch]$InstallArm64Toolchain +) + +# Admin is required because a lot of things are installed to the local machine +# in the script. +#Requires -RunAsAdministrator + +Set-StrictMode -Version 'Latest' +$PSDefaultParameterValues['*:ErrorAction'] = 'Stop' +$ProgressPreference = 'SilentlyContinue' + +if ($PSVersionTable.PSVersion.Major -lt 7) { + # This script requires PowerShell core. + Write-Error "PowerShell v7.x or greater is needed for this script to work." +} + +$PrepConfig = & (Join-Path $PSScriptRoot get-buildconfig.ps1) + +if (!$ForBuild) { + # When no args are passed, assume we want to build and test everything + # locally (i.e. a dev environment). + Write-Host "No arguments passed, defaulting -ForBuild" + $ForBuild = $true +} + +# Root directory of the project. +$RootDir = Split-Path $PSScriptRoot -Parent +$ArtifactsPath = Join-Path $RootDir "artifacts" +if (!(Test-Path $ArtifactsPath)) { mkdir $ArtifactsPath | Out-Null } + +if ($IsLinux) { + if ($ForBuild) { + sudo apt-add-repository ppa:lttng/stable-2.13 -y + sudo apt-get update -y + sudo apt-get install -y cmake + sudo apt-get install -y build-essential + sudo apt-get install -y liblttng-ust-dev + sudo apt-get install -y libssl-dev + sudo apt-get install -y libnuma-dev + if ($InstallArm64Toolchain) { + sudo apt-get install -y gcc-aarch64-linux-gnu + sudo apt-get install -y binutils-aarch64-linux-gnu + sudo apt-get install -y g++-aarch64-linux-gnu + } + # only used for the codecheck CI run: + sudo apt-get install -y cppcheck clang-tidy + # used for packaging + sudo apt-get install -y ruby ruby-dev rpm + sudo gem install public_suffix -v 4.0.7 + sudo gem install fpm + } +} diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt new file mode 100644 index 0000000..4921a97 --- /dev/null +++ b/src/lib/CMakeLists.txt @@ -0,0 +1,12 @@ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. + +if("${CX_PLATFORM}" STREQUAL "winuser") + set(SOURCES ${SOURCES} cxplat_winuser.c) +else() + set(SOURCES ${SOURCES} cxplat_posix.c) +endif() + +add_library(cxplat STATIC ${SOURCES}) + +target_include_directories(cxplat PRIVATE ${PROJECT_SOURCE_DIR}/inc) diff --git a/src/lib/cxplat.kernel.vcxproj b/src/lib/cxplat.kernel.vcxproj new file mode 100644 index 0000000..9ab5b2e --- /dev/null +++ b/src/lib/cxplat.kernel.vcxproj @@ -0,0 +1,102 @@ + + + + + Debug + x64 + + + Release + x64 + + + Debug + ARM64 + + + Release + ARM64 + + + + + + + + + + {1e494654-9bfd-492f-bc31-36e2c73a782e} + {8a9e2f9b-135b-4281-ad25-ed1a4dadb967} + v4.5 + 12.0 + KMDF + true + true + + + + Windows10 + WindowsKernelModeDriver10.0 + StaticLibrary + <_NT_TARGET_VERSION>0x0A00000A + + + true + + + false + + + + + + + + + 0 + -private + 0 + + + true + true + + + cxplat + $(SolutionDir)build\winkernel\$(Platform)_$(Configuration)\obj\$(ProjectName)\ + $(SolutionDir)artifacts\bin\winkernel\$(Platform)_$(Configuration)\ + + + + + + false + + + + $(SolutionDir)inc;%(AdditionalIncludeDirectories) + Speed + true + /Gw /kernel /ZH:SHA_256 + /Gw /kernel /ZH:SHA_256 -d2jumptablerdata -d2epilogunwindrequirev2 + + + true + + + + + MultiThreadedDebugDLL + VER_BUILD_ID=$(CXPLAT_VER_BUILD_ID);VER_SUFFIX=$(CXPLAT_VER_SUFFIX);VER_GIT_HASH=$(CXPLAT_VER_GIT_HASH);SECURITY_KERNEL;SECURITY_WIN32;_DEBUG;%(PreprocessorDefinitions) + true + + + + + VER_BUILD_ID=$(CXPLAT_VER_BUILD_ID);VER_SUFFIX=$(CXPLAT_VER_SUFFIX);VER_GIT_HASH=$(CXPLAT_VER_GIT_HASH);SECURITY_KERNEL;SECURITY_WIN32;%(PreprocessorDefinitions) + true + + + + + diff --git a/src/lib/cxplat_posix.c b/src/lib/cxplat_posix.c new file mode 100644 index 0000000..85f53ec --- /dev/null +++ b/src/lib/cxplat_posix.c @@ -0,0 +1 @@ +#include "cxplat_posix.h" diff --git a/src/lib/cxplat_winkernel.c b/src/lib/cxplat_winkernel.c new file mode 100644 index 0000000..2f8eb86 --- /dev/null +++ b/src/lib/cxplat_winkernel.c @@ -0,0 +1 @@ +#include "cxplat_winkernel.h" diff --git a/src/lib/cxplat_winuser.c b/src/lib/cxplat_winuser.c new file mode 100644 index 0000000..ae9fc44 --- /dev/null +++ b/src/lib/cxplat_winuser.c @@ -0,0 +1 @@ +#include "cxplat_winuser.h"