FEX-Emu/FEX
1
0
Fork 0
mirror of https://github.com/FEX-Emu/FEX.git synced 2024-12-11 00:03:55 +00:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity
e84848b16b
FEX/CMakeLists.txt

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

596 lines
20 KiB
CMake
Raw Normal View History

Actually unconditionally enable PIE through cmake behaviour around enabling PIC it was only working on one platform. This follows through with the NEW cmake behaviour required to enable PIE. Very specifically you have to set the cmake variable, you have to set the new policy, AND you have to have an explicit check for pie support. With any of those three things missing then PIE won't be enabled
2020-04-08 20:06:35 +00:00
cmake_minimum_required(VERSION 3.14)
CMake: Enable assembly source file support
2024-01-06 23:08:22 +00:00
project(FEX C CXX ASM)
Initial Commit
2019-07-13 09:41:34 +00:00
GDBSymbols: Add gdb reader for fex, GDBSymbols option to enable
2022-06-17 18:09:54 +00:00
INCLUDE (CheckIncludeFiles)
CHECK_INCLUDE_FILES ("gdb/jit-reader.h" HAVE_GDB_JIT_READER_H)
Initial Commit
2019-07-13 09:41:34 +00:00
option(BUILD_TESTS "Build unit tests to ensure sanity" TRUE)
CMake: Use toolchain files to set up x86 cross compilation
2022-06-24 15:30:49 +00:00
option(BUILD_FEX_LINUX_TESTS "Build FEXLinuxTests, requires x86 compiler" FALSE)
Don't build thunks by default Allow people to build fex without a cross-compiler installed
2021-01-30 11:28:15 +00:00
option(BUILD_THUNKS "Build thunks" FALSE)
CMake: Allow for disabling FEXConfig building It's useful even in non-termux builds to be able to disable FEXConfig due to its build-time dependencies.
2023-07-01 21:09:41 +00:00
option(BUILD_FEXCONFIG "Build FEXConfig, requires SDL2 and X11" TRUE)
CMake: Fix typo in clang thunks option.
2022-11-22 05:11:01 +00:00
option(ENABLE_CLANG_THUNKS "Build thunks with clang" FALSE)
Adds support for cmake IWYU option Only adds the option to enable the Include-What-You-Use program. This will be useful for cleaning up includes
2020-10-14 00:38:40 +00:00
option(ENABLE_IWYU "Enables include what you use program" FALSE)
Initial Commit
2019-07-13 09:41:34 +00:00
option(ENABLE_LTO "Enable LTO with compilation" TRUE)
option(ENABLE_XRAY "Enable building with LLVM X-Ray" FALSE)
CMake: Allow overriding linker While the ENABLE_LLD and ENABLE_MOLD options are nice, they don't handle the case when the linker of `lld` or `mold` doesn't match the compiler. This particularly crops up when overriding the C compiler to a new version of clang but the globally installed `ld.lld` is still the old clang version. This then causes clang to fail with unusual errors when upstream breaks compatibility with itself. Easy enough to use by passing the linker to cmake: `-DUSE_LINKER=/usr/bin/ld.lld-15` This also removes the ENABLE_LLD and ENABLE_MOLD options to use USE_LINKER directly. - ldd: `-DUSE_LINKER=lld` - mold: `-DUSE_LINKER=mold` Example of compiler failure when built with clang-15 but attempting to link with ld.lld 14: ```bash ld.lld-14: error: unittests/APITests/CMakeFiles/Filesystem.dir/Filesystem.cpp.o: Opaque pointers are only supported in -opaque-pointers mode (Producer: 'LLVM15.0.7' Reader: 'LLVM 14.0.6') ```
2023-08-03 20:58:20 +00:00
set(USE_LINKER "" CACHE STRING "Allow overriding the linker path directly")
Initial Commit
2019-07-13 09:41:34 +00:00
option(ENABLE_ASAN "Enables Clang ASAN" FALSE)
option(ENABLE_TSAN "Enables Clang TSAN" FALSE)
Enable coverage configuration for FEX
2024-07-01 13:02:16 +00:00
option(ENABLE_COVERAGE "Enables Coverage" FALSE)
Enables assertions option from cmake
2020-08-30 06:31:38 +00:00
option(ENABLE_ASSERTIONS "Enables assertions in build" FALSE)
GDBSymbols: Add gdb reader for fex, GDBSymbols option to enable
2022-06-17 18:09:54 +00:00
option(ENABLE_GDB_SYMBOLS "Enables GDBSymbols integration support" ${HAVE_GDB_JIT_READER_H})
Adds CMake option to enable -Werror We aren't error free so can't be default enabled
2021-03-13 03:16:38 +00:00
option(ENABLE_STRICT_WERROR "Enables stricter -Werror for CI" FALSE)
option(ENABLE_WERROR "Enables -Werror" FALSE)
Adds an option to disable jemalloc from cmake While not recommended. It is necessary to allow disabling jemalloc if you want to run asan or tsan
2021-07-23 01:16:24 +00:00
option(ENABLE_JEMALLOC "Enables jemalloc allocator" TRUE)
Add in jemalloc glibc hooking again We still need to hook glibc for thunks to work with `IsHostHeapAllocation`. So now we link in two jemalloc allocators in different namespaces. As usual we have multiple heap allocators that we need to be careful about. 1. jemalloc with `je_` namespace. - This is FEX's regular heap allocator and what gets used for all the fextl objects. - This allocator is the one that the FEX mmap/munmap hooks hook in to - This mmap hooking gives this allocator the full 48-bit VA even in 32-bit space. 2. jemalloc with `glibc_je_` namespace. - This is the allocator that overrides the glibc allocator routines - This is the allocator that thunks will use. - This is what `IsHostHeapAllocation` will check for. 3. Guest glibc allocator - We don't touch this one. But it is distinct from the host side allocators. - The guest side of thunks will use this heap allocator. 4. Host glibc allocator - #2 replaces this one unless explicitly disabled. - Always expected to override the allocator, so this configuration isn't expected. Already tested this with Dota Underlords to ensure this works with thunks.
2023-04-11 00:07:08 +00:00
option(ENABLE_JEMALLOC_GLIBC_ALLOC "Enables jemalloc glibc allocator" TRUE)
Implements support for offline *only* telemetry This information is only ever going to be offline. Will be useful for multiple reasons. 1) Searching for split lock usage in applications, which can be a programming bug. a) This isn't visible on AMD systems and on Intel is a fairly new linux feature 2) Having more information about when an application breaks. 3) Useful for some minor profiling for devs looking for statistical data
2021-08-07 05:40:19 +00:00
option(ENABLE_OFFLINE_TELEMETRY "Enables FEX offline telemetry" TRUE)
CMake: Adds option to enable time-trace compile option Useful for running something like aras-p/ClangBuildAnalyzer on the source and finding compile bottlenecks
2021-11-26 22:41:26 +00:00
option(ENABLE_COMPILE_TIME_TRACE "Enables time trace compile option" FALSE)
CMake: Adds experimental libc++ option FEX currently doesn't compile with it mainly because libc++ doesn't support c++ pmr at all.
2021-12-24 23:46:58 +00:00
option(ENABLE_LIBCXX "Enables LLVM libc++" FALSE)
Adds option to disable ccache Can be useful when running static analysis tools
2022-02-17 03:24:24 +00:00
option(ENABLE_CCACHE "Enables ccache for compile caching" TRUE)
Add support for the vixl simulator This will allow CI to test ARM features before we have any hardware that supports it.
2022-09-08 02:12:46 +00:00
option(ENABLE_VIXL_SIMULATOR "Forces the FEX JIT to use the VIXL simulator" FALSE)
Arm64: Enables debug option for disassembling the JIT code This is useful as a debug option and will be useful to have in upstream while comparing output between current vixl emitter and the new emitter. With this in place I can easily do binary comparisons to see where I have mistakes in the new emitter. We don't want this enabled in release builds as it is a debug feature. This has already caught a bunch of mistakes, so make it easier by upstreaming. It'll likely be useful in the future as well when we are inspecting code running in the vixl simulator.
2022-12-18 22:56:40 +00:00
option(ENABLE_VIXL_DISASSEMBLER "Enables debug disassembler output with VIXL" FALSE)
CMake: Add an option for compiling vixl disassembler
2023-01-12 21:55:00 +00:00
option(COMPILE_VIXL_DISASSEMBLER "Compiles the vixl disassembler in to vixl" FALSE)
FEXCore: Adds support for a timeline profiler interface This creates a generic interface that FEXCore can use for timeline profiling. This allows us to create a generic interface which the backend details are hidden so we can support multiple timeline profile APIs. The only API supported right now is ftrace/gpuvis. Which is extremely lightweight of an interface with minimal overhead. We must be careful here since in most cases will will have dozens of FEX instances running at any given time. So a timeline profiler like Microprofiler can have major issues since that only ever expects a single process at a time. Not enabled by default but just needs the `ENABLE_FEXCORE_PROFILER` cmake option set to enable.
2022-10-14 01:16:06 +00:00
option(ENABLE_FEXCORE_PROFILER "Enables use of the FEXCore timeline profiling capabilities" FALSE)
set (FEXCORE_PROFILER_BACKEND "gpuvis" CACHE STRING "Set which backend you want to use for the FEXCore profiler")
CMake: Adds glibc allocator fault option This will be used for CI to ensure FEX doesn't use the glibc allocator
2023-03-18 03:02:10 +00:00
option(ENABLE_GLIBC_ALLOCATOR_HOOK_FAULT "Enables glibc memory allocation hooking with fault for CI testing")
CMake: Add option to build PDB debug info instead of DWARF
2024-07-19 19:09:59 +00:00
option(USE_PDB_DEBUGINFO "Builds debug info in PDB format" FALSE)
Initial Commit
2019-07-13 09:41:34 +00:00
CMake: Add toolchain file for 32-bit cross-compiler
2022-09-19 07:19:22 +00:00
set (X86_32_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/toolchain_x86_32.cmake" CACHE FILEPATH "Toolchain file for the (cross-)compiler targeting i686")
set (X86_64_TOOLCHAIN_FILE "${CMAKE_CURRENT_SOURCE_DIR}/toolchain_x86_64.cmake" CACHE FILEPATH "Toolchain file for the (cross-)compiler targeting x86_64")
Adds an environment variable for installation directly This will allow us to look for a global application profile in our install location. Once we have things to install there.
2020-12-06 05:17:07 +00:00
set (DATA_DIRECTORY "${CMAKE_INSTALL_PREFIX}/share/fex-emu" CACHE PATH "global data directory")
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
CMake: Get past configuration when mingw is used Right now cmake doesn't even get past the configuration stage when mingw is used. If mingw is detected, setup cmake so it can at least configure itself. Will be necessary for cleaning up the rest of the codebase.
2023-03-12 23:37:35 +00:00
string(FIND ${CMAKE_BASE_NAME} mingw CONTAINS_MINGW)
if (NOT CONTAINS_MINGW EQUAL -1)
message (STATUS "Mingw build")
set (MINGW_BUILD TRUE)
set (ENABLE_JEMALLOC FALSE)
CMake: Disable glibc jemalloc for MinGW builds
2024-06-26 14:53:49 +00:00
set (ENABLE_JEMALLOC_GLIBC_ALLOC FALSE)
CMake: Get past configuration when mingw is used Right now cmake doesn't even get past the configuration stage when mingw is used. If mingw is detected, setup cmake so it can at least configure itself. Will be necessary for cleaning up the rest of the codebase.
2023-03-12 23:37:35 +00:00
endif()
CMake: Add a clang version check Currently our minimum clang version requirement is 12.0 but soon will require at least 13 or 14. Add a new version check in cmake to ensure minimum version requirements. Makes it easier to determine why a build is failing due to old compiler.
2024-06-16 01:41:19 +00:00
if (NOT MINGW_BUILD)
message (STATUS "Clang version ${CMAKE_CXX_COMPILER_VERSION}")
set (CLANG_MINIMUM_VERSION 12.0)
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${CLANG_MINIMUM_VERSION})
message (FATAL_ERROR "Clang version too old for FEX. Need at least ${CLANG_MINIMUM_VERSION} but has ${CMAKE_CXX_COMPILER_VERSION}")
endif()
endif()
FEXCore: Adds support for a timeline profiler interface This creates a generic interface that FEXCore can use for timeline profiling. This allows us to create a generic interface which the backend details are hidden so we can support multiple timeline profile APIs. The only API supported right now is ftrace/gpuvis. Which is extremely lightweight of an interface with minimal overhead. We must be careful here since in most cases will will have dozens of FEX instances running at any given time. So a timeline profiler like Microprofiler can have major issues since that only ever expects a single process at a time. Not enabled by default but just needs the `ENABLE_FEXCORE_PROFILER` cmake option set to enable.
2022-10-14 01:16:06 +00:00
if (ENABLE_FEXCORE_PROFILER)
add_definitions(-DENABLE_FEXCORE_PROFILER=1)
string(TOUPPER "${FEXCORE_PROFILER_BACKEND}" FEXCORE_PROFILER_BACKEND)
if (FEXCORE_PROFILER_BACKEND STREQUAL "GPUVIS")
add_definitions(-DFEXCORE_PROFILER_BACKEND=1)
else()
message(FATAL_ERROR "Unknown FEXCore profiler backend ${FEXCORE_PROFILER_BACKEND}")
endif()
endif()
Add in jemalloc glibc hooking again We still need to hook glibc for thunks to work with `IsHostHeapAllocation`. So now we link in two jemalloc allocators in different namespaces. As usual we have multiple heap allocators that we need to be careful about. 1. jemalloc with `je_` namespace. - This is FEX's regular heap allocator and what gets used for all the fextl objects. - This allocator is the one that the FEX mmap/munmap hooks hook in to - This mmap hooking gives this allocator the full 48-bit VA even in 32-bit space. 2. jemalloc with `glibc_je_` namespace. - This is the allocator that overrides the glibc allocator routines - This is the allocator that thunks will use. - This is what `IsHostHeapAllocation` will check for. 3. Guest glibc allocator - We don't touch this one. But it is distinct from the host side allocators. - The guest side of thunks will use this heap allocator. 4. Host glibc allocator - #2 replaces this one unless explicitly disabled. - Always expected to override the allocator, so this configuration isn't expected. Already tested this with Dota Underlords to ensure this works with thunks.
2023-04-11 00:07:08 +00:00
if (ENABLE_JEMALLOC_GLIBC_ALLOC AND ENABLE_GLIBC_ALLOCATOR_HOOK_FAULT)
message(FATAL_ERROR "Can't have both glibc fault allocator and jemalloc glibc allocator enabled at the same time")
endif()
CMake: Adds glibc allocator fault option This will be used for CI to ensure FEX doesn't use the glibc allocator
2023-03-18 03:02:10 +00:00
if (ENABLE_GLIBC_ALLOCATOR_HOOK_FAULT)
add_definitions(-DGLIBC_ALLOCATOR_FAULT=1)
endif()
cmake: Adds uninstall target Following guidance from cmake's FAQ: https://gitlab.kitware.com/cmake/community/-/wikis/FAQ#can-i-do-make-uninstall-with-cmake Due to some of the special handling that we do with installs, we need to do additional uninstall handling that the install manifest doesn't cover. Specifically we need to add additional uninstall targets for: - FEXInterpreter - binfmt_misc - guest_thunks (Doing its own uninstall target, so passthrough) While it isn't generally advised to install and uninstall through source systems, this is something that users want to do all the time. This has been asked for a couple of times now. Fixes #1592
2022-09-15 01:16:16 +00:00
# uninstall target
if(NOT TARGET uninstall)
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/CMakeFiles/cmake_uninstall.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/cmake_uninstall.cmake"
IMMEDIATE @ONLY)
add_custom_target(uninstall
COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/cmake_uninstall.cmake)
endif()
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
# These options are meant for package management
CMake: Adds a TUNE_CPU option By default we tune to the native CPU, using some heuristics to determine the true native CPU since Apple doesn't expose an MIDR. Adds an option that allows the user to pass in the CPU to tune for. This will be useful for debugging and also for package building.
2021-12-30 01:14:40 +00:00
set (TUNE_CPU "native" CACHE STRING "Override the CPU the build is tuned for")
CMake: Adds TUNE_ARCH option I forgot about this option working for tuning arch on AArch64. This will be used in PPA releases in the future. Will leave the previous option since it can be used in testing.
2022-01-05 21:48:35 +00:00
set (TUNE_ARCH "generic" CACHE STRING "Override the Arch the build is tuned for")
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
set (OVERRIDE_VERSION "detect" CACHE STRING "Override the FEX version in the format of <MMYY>{.<REV>}")
GuestLibs: Allow configuring compiler via cmake
2020-08-20 12:38:25 +00:00
Enables assertions option from cmake
2020-08-30 06:31:38 +00:00
string(TOUPPER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE)
if (CMAKE_BUILD_TYPE MATCHES "DEBUG")
set(ENABLE_ASSERTIONS TRUE)
endif()
if (ENABLE_ASSERTIONS)
message(STATUS "Assertions enabled")
add_definitions(-DASSERTIONS_ENABLED=1)
endif()
GDBSymbols: Add gdb reader for fex, GDBSymbols option to enable
2022-06-17 18:09:54 +00:00
if (ENABLE_GDB_SYMBOLS)
message(STATUS "GDBSymbols support enabled")
add_definitions(-DGDB_SYMBOLS_ENABLED=1)
endif()
Enables C++20 feature level There are a few nice features in C++20 that can make our life easier. This isn't requiring the full C++20 suite of features, but instead should allow us to start bringing in features that were at least in Clang 10. LLVM 11 came out yesterday (2020-10-12) so it would be a shame to have that as a minimum requirement.
2020-10-14 00:51:28 +00:00
set(CMAKE_CXX_STANDARD 20)
Initial Commit
2019-07-13 09:41:34 +00:00
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Bin)
set(CMAKE_INCLUDE_CURRENT_DIR ON)
Enables PIC We don't require non-pie and this can also solve some linking problems I saw on Arch64 hosts
2020-03-12 23:26:13 +00:00
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
Actually unconditionally enable PIE through cmake behaviour around enabling PIC it was only working on one platform. This follows through with the NEW cmake behaviour required to enable PIE. Very specifically you have to set the cmake variable, you have to set the new policy, AND you have to have an explicit check for pie support. With any of those three things missing then PIE won't be enabled
2020-04-08 20:06:35 +00:00
cmake_policy(SET CMP0083 NEW) # Follow new PIE policy
include(CheckPIESupported)
check_pie_supported()
Initial Commit
2019-07-13 09:41:34 +00:00
if (ENABLE_LTO)
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
Ensure if ENABLE_LTO is set to false to disable LTO
2020-02-18 23:48:53 +00:00
else()
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION FALSE)
Initial Commit
2019-07-13 09:41:34 +00:00
endif()
AArch64: Workaround static-pie crashing Static-pie can only work with GNU ld instead of lld on AArch64 hosts. This is a known problem on the llvm side: https://bugs.llvm.org/show_bug.cgi?id=49672
2021-08-03 00:04:39 +00:00
if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
Adds back cmake error on x86-64 hosts
2024-06-23 15:21:14 +00:00
option(ENABLE_X86_HOST_DEBUG "Enables compiling on x86_64 host" FALSE)
if (NOT ENABLE_X86_HOST_DEBUG)
message(FATAL_ERROR
" FEX-Emu doesn't support compiling for x86-64 hosts!"
" This is /only/ a supported configuration for FEX CI and nothing else!")
endif()
AArch64: Workaround static-pie crashing Static-pie can only work with GNU ld instead of lld on AArch64 hosts. This is a known problem on the llvm side: https://bugs.llvm.org/show_bug.cgi?id=49672
2021-08-03 00:04:39 +00:00
set(_M_X86_64 1)
add_definitions(-D_M_X86_64=1)
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mcx16")
endif()
CMake: Extend AArch64 check to include arm64 This has been seen in some build environments, forgot to commit this a while ago.
2022-09-08 22:17:40 +00:00
if (CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64|^arm64|^armv8\.*")
AArch64: Workaround static-pie crashing Static-pie can only work with GNU ld instead of lld on AArch64 hosts. This is a known problem on the llvm side: https://bugs.llvm.org/show_bug.cgi?id=49672
2021-08-03 00:04:39 +00:00
set(_M_ARM_64 1)
add_definitions(-D_M_ARM_64=1)
endif()
CMake: Define _M_ARM_64EC when building for ARM64EC
2024-01-24 00:28:44 +00:00
if (CMAKE_SYSTEM_PROCESSOR MATCHES "^arm64ec")
set(_M_ARM_64EC 1)
add_definitions(-D_M_ARM_64EC=1)
CMake: Force enable jemalloc when targetting ARM64EC
2024-02-21 11:19:30 +00:00
# Required as FEX is not allowed to lock the CRT heap lock during compilation or callbacks
set(ENABLE_JEMALLOC TRUE)
CMake: Define _M_ARM_64EC when building for ARM64EC
2024-01-24 00:28:44 +00:00
endif()
FEX: Moves HostFeatures querying to the frontend This moves the CPU feature querying to the frontend. The primary purpose here is for the wow64 frontend to not require linux-isms for querying these features. This is required since non-Linux environments don't have the "CPUID" feature for reading EL1 MSRs in EL0. Wiring up the remaining wow64 registry querying is left for a future exercise. This also technically removes an xbyak requirement from FEXCore for when building the x86 Test harness runner, but that doesn't really matter for regular use cases.
2024-08-04 01:24:50 +00:00
include(CheckCXXSourceCompiles)
set(CMAKE_REQUIRED_FLAGS "-std=c++11 -Wattributes -Werror=attributes")
check_cxx_source_compiles(
"
__attribute__((preserve_all))
int Testy(int a, int b, int c, int d, int e, int f) {
return a + b + c + d + e + f;
}
int main() {
return Testy(0, 1, 2, 3, 4, 5);
}"
HAS_CLANG_PRESERVE_ALL)
unset(CMAKE_REQUIRED_FLAGS)
if (HAS_CLANG_PRESERVE_ALL)
if (MINGW_BUILD)
message(STATUS "Ignoring broken clang::preserve_all support")
set(HAS_CLANG_PRESERVE_ALL FALSE)
else()
message(STATUS "Has clang::preserve_all")
endif()
endif ()
if (_M_ARM_64 AND HAS_CLANG_PRESERVE_ALL)
add_definitions("-DFEX_PRESERVE_ALL_ATTR=__attribute__((preserve_all))" "-DFEX_HAS_PRESERVE_ALL_ATTR=1")
else()
add_definitions("-DFEX_PRESERVE_ALL_ATTR=" "-DFEX_HAS_PRESERVE_ALL_ATTR=0")
endif()
if (ENABLE_VIXL_SIMULATOR)
# We can run the simulator on both x86-64 or AArch64 hosts
add_definitions(-DVIXL_SIMULATOR=1 -DVIXL_INCLUDE_SIMULATOR_AARCH64=1)
endif()
Adds option to disable ccache Can be useful when running static analysis tools
2022-02-17 03:24:24 +00:00
if (ENABLE_CCACHE)
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
message(STATUS "CCache enabled")
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
endif()
Automatically enables ccache if the program is found This makes it easier to not forget to use this
2020-08-10 18:31:36 +00:00
endif()
Initial Commit
2019-07-13 09:41:34 +00:00
if (ENABLE_XRAY)
add_compile_options(-fxray-instrument)
link_libraries(-fxray-instrument)
endif()
CMake: Adds option to enable time-trace compile option Useful for running something like aras-p/ClangBuildAnalyzer on the source and finding compile bottlenecks
2021-11-26 22:41:26 +00:00
if (ENABLE_COMPILE_TIME_TRACE)
add_compile_options(-ftime-trace)
link_libraries(-ftime-trace)
endif()
Works around static-pie crashing static-pie is crashing early due to an issue with pthread symbols being exposed as weak. For some reason the weak symbols never get resolved and jump to zero or ELF base. When linking static-pie, force search for the pthread symbols using an undefined glob. With this, static-pie works as long as you link with a new enough version of lld (version 13.0)
2021-07-20 12:22:09 +00:00
set (PTHREAD_LIB pthread)
CMake: Add option to use the mold linker
2022-03-09 18:53:40 +00:00
CMake: Allow overriding linker While the ENABLE_LLD and ENABLE_MOLD options are nice, they don't handle the case when the linker of `lld` or `mold` doesn't match the compiler. This particularly crops up when overriding the C compiler to a new version of clang but the globally installed `ld.lld` is still the old clang version. This then causes clang to fail with unusual errors when upstream breaks compatibility with itself. Easy enough to use by passing the linker to cmake: `-DUSE_LINKER=/usr/bin/ld.lld-15` This also removes the ENABLE_LLD and ENABLE_MOLD options to use USE_LINKER directly. - ldd: `-DUSE_LINKER=lld` - mold: `-DUSE_LINKER=mold` Example of compiler failure when built with clang-15 but attempting to link with ld.lld 14: ```bash ld.lld-14: error: unittests/APITests/CMakeFiles/Filesystem.dir/Filesystem.cpp.o: Opaque pointers are only supported in -opaque-pointers mode (Producer: 'LLVM15.0.7' Reader: 'LLVM 14.0.6') ```
2023-08-03 20:58:20 +00:00
if (USE_LINKER)
message(STATUS "Overriding linker to: ${USE_LINKER}")
add_link_options("-fuse-ld=${USE_LINKER}")
Adds cmake option `ENABLE_STATIC_PIE` This option does cmake checks to determine if your system can handle static-pie. With upstream projects static-pie only works if you use the binutils linker. Using lld doesn't currently work because it defines __rela_iplt_{start,end} symbols. Our cmake file will now compile a test application and check for these symbols. Either the symbols will not exist at all or they will exist but be a null address Once your system passes the checks then it will allow you to enable static-pie
2021-07-14 15:22:07 +00:00
endif()
CMake: Adds experimental libc++ option FEX currently doesn't compile with it mainly because libc++ doesn't support c++ pmr at all.
2021-12-24 23:46:58 +00:00
if (ENABLE_LIBCXX)
message(WARNING "This is an unsupported configuration and should only be used for testing")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -lc++abi")
endif()
Implements support for offline *only* telemetry This information is only ever going to be offline. Will be useful for multiple reasons. 1) Searching for split lock usage in applications, which can be a programming bug. a) This isn't visible on AMD systems and on Intel is a fairly new linux feature 2) Having more information about when an application breaks. 3) Useful for some minor profiling for devs looking for statistical data
2021-08-07 05:40:19 +00:00
if (NOT ENABLE_OFFLINE_TELEMETRY)
# Disable FEX offline telemetry entirely if asked
add_definitions(-DFEX_DISABLE_TELEMETRY=1)
endif()
Initial Commit
2019-07-13 09:41:34 +00:00
if (ENABLE_ASAN)
Disables lower 32bit mapping check when ASAN is compiled in LLVM ASAN sticks some things in the upper range of the 32bit memory range. So we have to just allow it when using LLVM asan
2020-12-14 11:59:04 +00:00
add_definitions(-DENABLE_ASAN=1)
Adds use-after-scope to the ASAN options Useful for seeing stack scoping problems that can crop up
2021-04-05 05:07:40 +00:00
add_compile_options(-fno-omit-frame-pointer -fsanitize=address -fsanitize-address-use-after-scope)
link_libraries(-fno-omit-frame-pointer -fsanitize=address -fsanitize-address-use-after-scope)
Initial Commit
2019-07-13 09:41:34 +00:00
endif()
if (ENABLE_TSAN)
add_compile_options(-fno-omit-frame-pointer -fsanitize=thread)
link_libraries(-fno-omit-frame-pointer -fsanitize=thread)
endif()
Enable coverage configuration for FEX
2024-07-01 13:02:16 +00:00
if (ENABLE_COVERAGE)
add_compile_options(-fprofile-instr-generate -fcoverage-mapping)
link_libraries(-fprofile-instr-generate -fcoverage-mapping)
endif()
Add in jemalloc glibc hooking again We still need to hook glibc for thunks to work with `IsHostHeapAllocation`. So now we link in two jemalloc allocators in different namespaces. As usual we have multiple heap allocators that we need to be careful about. 1. jemalloc with `je_` namespace. - This is FEX's regular heap allocator and what gets used for all the fextl objects. - This allocator is the one that the FEX mmap/munmap hooks hook in to - This mmap hooking gives this allocator the full 48-bit VA even in 32-bit space. 2. jemalloc with `glibc_je_` namespace. - This is the allocator that overrides the glibc allocator routines - This is the allocator that thunks will use. - This is what `IsHostHeapAllocation` will check for. 3. Guest glibc allocator - We don't touch this one. But it is distinct from the host side allocators. - The guest side of thunks will use this heap allocator. 4. Host glibc allocator - #2 replaces this one unless explicitly disabled. - Always expected to override the allocator, so this configuration isn't expected. Already tested this with Dota Underlords to ensure this works with thunks.
2023-04-11 00:07:08 +00:00
if (ENABLE_JEMALLOC_GLIBC_ALLOC)
# The glibc jemalloc subproject which hooks the glibc allocator.
# Required for thunks to work.
# All host native libraries will use this allocator, while *most* other FEX internal allocations will use the other jemalloc allocator.
add_definitions(-DENABLE_JEMALLOC_GLIBC=1)
add_subdirectory(External/jemalloc_glibc/)
CMake: Disable glibc jemalloc for MinGW builds
2024-06-26 14:53:49 +00:00
elseif (NOT MINGW_BUILD)
Add in jemalloc glibc hooking again We still need to hook glibc for thunks to work with `IsHostHeapAllocation`. So now we link in two jemalloc allocators in different namespaces. As usual we have multiple heap allocators that we need to be careful about. 1. jemalloc with `je_` namespace. - This is FEX's regular heap allocator and what gets used for all the fextl objects. - This allocator is the one that the FEX mmap/munmap hooks hook in to - This mmap hooking gives this allocator the full 48-bit VA even in 32-bit space. 2. jemalloc with `glibc_je_` namespace. - This is the allocator that overrides the glibc allocator routines - This is the allocator that thunks will use. - This is what `IsHostHeapAllocation` will check for. 3. Guest glibc allocator - We don't touch this one. But it is distinct from the host side allocators. - The guest side of thunks will use this heap allocator. 4. Host glibc allocator - #2 replaces this one unless explicitly disabled. - Always expected to override the allocator, so this configuration isn't expected. Already tested this with Dota Underlords to ensure this works with thunks.
2023-04-11 00:07:08 +00:00
message (STATUS
" jemalloc glibc allocator disabled!\n"
" This is not a recommended configuration!\n"
" This will very explicitly break thunk execution!\n"
" Use at your own risk!")
endif()
Adds an option to disable jemalloc from cmake While not recommended. It is necessary to allow disabling jemalloc if you want to run asan or tsan
2021-07-23 01:16:24 +00:00
if (ENABLE_JEMALLOC)
Add in jemalloc glibc hooking again We still need to hook glibc for thunks to work with `IsHostHeapAllocation`. So now we link in two jemalloc allocators in different namespaces. As usual we have multiple heap allocators that we need to be careful about. 1. jemalloc with `je_` namespace. - This is FEX's regular heap allocator and what gets used for all the fextl objects. - This allocator is the one that the FEX mmap/munmap hooks hook in to - This mmap hooking gives this allocator the full 48-bit VA even in 32-bit space. 2. jemalloc with `glibc_je_` namespace. - This is the allocator that overrides the glibc allocator routines - This is the allocator that thunks will use. - This is what `IsHostHeapAllocation` will check for. 3. Guest glibc allocator - We don't touch this one. But it is distinct from the host side allocators. - The guest side of thunks will use this heap allocator. 4. Host glibc allocator - #2 replaces this one unless explicitly disabled. - Always expected to override the allocator, so this configuration isn't expected. Already tested this with Dota Underlords to ensure this works with thunks.
2023-04-11 00:07:08 +00:00
# The jemalloc subproject that all FEXCore fextl objects allocate through.
Adds an option to disable jemalloc from cmake While not recommended. It is necessary to allow disabling jemalloc if you want to run asan or tsan
2021-07-23 01:16:24 +00:00
add_definitions(-DENABLE_JEMALLOC=1)
Fixes jemalloc library ordering FEXCore relies on jemalloc symbols if compiled with it. Have FEXCore link to jemalloc instead of the frontend. Fixes a missing symbol if someone loads libFEXCore Additionally, stop trying to compile JEMalloc if not enabled
2021-08-26 08:20:54 +00:00
add_subdirectory(External/jemalloc/)
include_directories(External/jemalloc/pregen/include/)
CMake: Disable glibc jemalloc for MinGW builds
2024-06-26 14:53:49 +00:00
elseif (NOT MINGW_BUILD)
Adds an option to disable jemalloc from cmake While not recommended. It is necessary to allow disabling jemalloc if you want to run asan or tsan
2021-07-23 01:16:24 +00:00
message (STATUS
" jemalloc disabled!\n"
" This is not a recommended configuration!\n"
" This will very explicitly break 32-bit application execution!\n"
" Use at your own risk!")
endif()
CMake: Add option to build PDB debug info instead of DWARF
2024-07-19 19:09:59 +00:00
if (USE_PDB_DEBUGINFO)
add_compile_options(-g -gcodeview)
add_link_options(-g -Wl,--pdb=)
endif()
Initial Commit
2019-07-13 09:41:34 +00:00
set (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -fno-omit-frame-pointer")
set (CMAKE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_LINKER_FLAGS_RELWITHDEBINFO} -fno-omit-frame-pointer")
set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer")
set (CMAKE_LINKER_FLAGS_RELEASE "${CMAKE_LINKER_FLAGS_RELEASE} -fomit-frame-pointer")
Adds tsl::robin_map This will be used with the code serialization service soon
2022-02-26 08:37:32 +00:00
include_directories(External/robin-map/include/)
CMake: Add an option for compiling vixl disassembler
2023-01-12 21:55:00 +00:00
if (BUILD_TESTS)
# Enable vixl disassembler if tests are enabled.
set(COMPILE_VIXL_DISASSEMBLER TRUE)
endif()
Cmake: allow independant control of both jits
2021-03-05 02:07:10 +00:00
add_subdirectory(External/vixl/)
Include VIXL as a system library This suppresses warnings from VIXL headers.
2023-08-10 16:45:14 +00:00
include_directories(SYSTEM External/vixl/src/)
Cmake: allow independant control of both jits
2021-03-05 02:07:10 +00:00
Throw an error in CMake if someone attempts to compile with GCC FEX doesn't support GCC.
2020-08-20 06:25:29 +00:00
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
# This means we were attempted to get compiled with GCC
message(FATAL_ERROR "FEX doesn't support getting compiled with GCC!")
endif()
Switch from fasthash64 to xxhash's XXH3 Fixes #797
2021-04-19 01:11:24 +00:00
find_package(PkgConfig REQUIRED)
Disabled cmake check for python development We only need the interpreter
2021-03-06 14:06:59 +00:00
find_package(Python 3.0 REQUIRED COMPONENTS Interpreter)
Use externals xxhash if not found installed Also in the case that you don't have v0.8.0 minimum installed
2021-07-06 00:40:09 +00:00
Update xxhash to v0.8.2 Switches to using upstream cmake files.
2024-02-27 07:29:14 +00:00
set(XXHASH_BUNDLED_MODE TRUE)
set(XXHASH_BUILD_XXHSUM FALSE)
set(BUILD_SHARED_LIBS OFF)
add_subdirectory(External/xxhash/cmake_unofficial/)
Adds python version check
2021-02-05 18:36:52 +00:00
Initial Commit
2019-07-13 09:41:34 +00:00
add_definitions(-Wno-trigraphs)
Adds an environment variable for installation directly This will allow us to look for a global application profile in our install location. Once we have things to install there.
2020-12-06 05:17:07 +00:00
add_definitions(-DGLOBAL_DATA_DIRECTORY="${DATA_DIRECTORY}/")
Initial Commit
2019-07-13 09:41:34 +00:00
CMake: Adds Catch build when tests are enabled
2021-11-29 21:02:14 +00:00
if (BUILD_TESTS)
add_subdirectory(External/Catch2/)
# Pull in catch_discover_tests definition
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/External/Catch2/contrib/")
include(Catch)
endif()
CMake: Stop installing fmt Fixes #2751 Luckily fmt provides an option to disable this.
2023-07-10 19:26:39 +00:00
# Disable fmt install
set(FMT_INSTALL OFF)
Externals: Add fmt as an external Begins the process of addressing issue #146. This is separated off, so that others can make use of fmt for other purposes (general localized non-sucky string formatting), while the logging rework is being tackled.
2021-05-20 17:18:36 +00:00
add_subdirectory(External/fmt/)
Initial Commit
2019-07-13 09:41:34 +00:00
add_subdirectory(External/imgui/)
include_directories(External/imgui/)
add_subdirectory(External/json-maker/)
include_directories(External/json-maker/)
add_subdirectory(External/tiny-json/)
include_directories(External/tiny-json/)
Adds xbyak to externals Removes cmake check to see if it exists
2020-03-06 07:41:29 +00:00
Initial Commit
2019-07-13 09:41:34 +00:00
include_directories(Source/)
include_directories("${CMAKE_BINARY_DIR}/Source/")
include(CheckCXXCompilerFlag)
# Add in diagnostic colours if the option is available.
# Ninja code generator will kill colours if this isn't here
check_cxx_compiler_flag(-fdiagnostics-color=always GCC_COLOR)
check_cxx_compiler_flag(-fcolor-diagnostics CLANG_COLOR)
Remove annoying vixl warnings
2020-11-20 09:58:58 +00:00
check_cxx_compiler_flag(-Wno-deprecated-enum-enum-conversion ENUM_ENUM_WARNING)
Initial Commit
2019-07-13 09:41:34 +00:00
if (GCC_COLOR)
add_compile_options(-fdiagnostics-color=always)
endif()
if (CLANG_COLOR)
add_compile_options(-fcolor-diagnostics)
endif()
Remove annoying vixl warnings
2020-11-20 09:58:58 +00:00
if(ENUM_ENUM_WARNING)
add_compile_options(-Wno-deprecated-enum-enum-conversion)
endif()
Adds CMake option to enable -Werror We aren't error free so can't be default enabled
2021-03-13 03:16:38 +00:00
if(ENABLE_WERROR OR ENABLE_STRICT_WERROR)
add_compile_options(-Werror)
if (NOT ENABLE_STRICT_WERROR)
# Disable some Werror that can add frustration when developing
add_compile_options(-Wno-error=unused-variable)
endif()
endif()
FEX: Only pass CPU tunables to FEXCore and FEXLoader This fixes an issue where CPU tunables were ending up in the thunk generator which means if your CPU doesn't support all the features on the *Builder* then it would crash with SIGILL. This was happening with Canonical's runners because they typically only support ARMv8.2 but we are compiling packages to run on ARMv8.4 devices. cc: FEX-2311.1
2023-11-08 13:50:33 +00:00
set(FEX_TUNE_COMPILE_FLAGS)
CMake: Adds TUNE_ARCH option I forgot about this option working for tuning arch on AArch64. This will be used in PPA releases in the future. Will leave the previous option since it can be used in testing.
2022-01-05 21:48:35 +00:00
if (NOT TUNE_ARCH STREQUAL "generic")
check_cxx_compiler_flag("-march=${TUNE_ARCH}" COMPILER_SUPPORTS_ARCH_TYPE)
if(COMPILER_SUPPORTS_ARCH_TYPE)
FEX: Only pass CPU tunables to FEXCore and FEXLoader This fixes an issue where CPU tunables were ending up in the thunk generator which means if your CPU doesn't support all the features on the *Builder* then it would crash with SIGILL. This was happening with Canonical's runners because they typically only support ARMv8.2 but we are compiling packages to run on ARMv8.4 devices. cc: FEX-2311.1
2023-11-08 13:50:33 +00:00
list(APPEND FEX_TUNE_COMPILE_FLAGS "-march=${TUNE_ARCH}")
CMake: Adds TUNE_ARCH option I forgot about this option working for tuning arch on AArch64. This will be used in PPA releases in the future. Will leave the previous option since it can be used in testing.
2022-01-05 21:48:35 +00:00
else()
message(FATAL_ERROR "Trying to compile arch type '${TUNE_ARCH}' but the compiler doesn't support this")
endif()
endif()
CMake: Adds a TUNE_CPU option By default we tune to the native CPU, using some heuristics to determine the true native CPU since Apple doesn't expose an MIDR. Adds an option that allows the user to pass in the CPU to tune for. This will be useful for debugging and also for package building.
2021-12-30 01:14:40 +00:00
if (TUNE_CPU STREQUAL "native")
if(_M_ARM_64)
if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 999999.0)
# Clang 12.0 fixed the -mcpu=native bug with mixed big.little implementers
# Clang can not currently check for native Apple M1 type in hypervisor. Currently disabled
check_cxx_compiler_flag("-mcpu=native" COMPILER_SUPPORTS_CPU_TYPE)
if(COMPILER_SUPPORTS_CPU_TYPE)
FEX: Only pass CPU tunables to FEXCore and FEXLoader This fixes an issue where CPU tunables were ending up in the thunk generator which means if your CPU doesn't support all the features on the *Builder* then it would crash with SIGILL. This was happening with Canonical's runners because they typically only support ARMv8.2 but we are compiling packages to run on ARMv8.4 devices. cc: FEX-2311.1
2023-11-08 13:50:33 +00:00
list(APPEND FEX_TUNE_COMPILE_FLAGS "-mcpu=native")
CMake: Adds a TUNE_CPU option By default we tune to the native CPU, using some heuristics to determine the true native CPU since Apple doesn't expose an MIDR. Adds an option that allows the user to pass in the CPU to tune for. This will be useful for debugging and also for package building.
2021-12-30 01:14:40 +00:00
endif()
else()
# Due to an oversight in llvm, it declares any reasonably new Kryo CPU to only be ARMv8.0
# Manually detect newer CPU revisions until clang and llvm fixes their bug
# This script will either provide a supported CPU or 'native'
# Additionally -march doesn't work under AArch64+Clang, so you have to use -mcpu or -mtune
execute_process(COMMAND python3 "${PROJECT_SOURCE_DIR}/Scripts/aarch64_fit_native.py" "/proc/cpuinfo" "${CMAKE_CXX_COMPILER_VERSION}"
OUTPUT_VARIABLE AARCH64_CPU)
string(STRIP ${AARCH64_CPU} AARCH64_CPU)
check_cxx_compiler_flag("-mcpu=${AARCH64_CPU}" COMPILER_SUPPORTS_CPU_TYPE)
if(COMPILER_SUPPORTS_CPU_TYPE)
FEX: Only pass CPU tunables to FEXCore and FEXLoader This fixes an issue where CPU tunables were ending up in the thunk generator which means if your CPU doesn't support all the features on the *Builder* then it would crash with SIGILL. This was happening with Canonical's runners because they typically only support ARMv8.2 but we are compiling packages to run on ARMv8.4 devices. cc: FEX-2311.1
2023-11-08 13:50:33 +00:00
list(APPEND FEX_TUNE_COMPILE_FLAGS "-mcpu=${AARCH64_CPU}")
CMake: Adds a TUNE_CPU option By default we tune to the native CPU, using some heuristics to determine the true native CPU since Apple doesn't expose an MIDR. Adds an option that allows the user to pass in the CPU to tune for. This will be useful for debugging and also for package building.
2021-12-30 01:14:40 +00:00
endif()
Use mcpu=native with Clang 12 Clang 12 fixes the bug with big.little configurations so we can keep using mcpu=native past this point
2021-04-17 01:39:06 +00:00
endif()
else()
CMake: Adds a TUNE_CPU option By default we tune to the native CPU, using some heuristics to determine the true native CPU since Apple doesn't expose an MIDR. Adds an option that allows the user to pass in the CPU to tune for. This will be useful for debugging and also for package building.
2021-12-30 01:14:40 +00:00
check_cxx_compiler_flag("-march=native" COMPILER_SUPPORTS_MARCH_NATIVE)
if(COMPILER_SUPPORTS_MARCH_NATIVE)
FEX: Only pass CPU tunables to FEXCore and FEXLoader This fixes an issue where CPU tunables were ending up in the thunk generator which means if your CPU doesn't support all the features on the *Builder* then it would crash with SIGILL. This was happening with Canonical's runners because they typically only support ARMv8.2 but we are compiling packages to run on ARMv8.4 devices. cc: FEX-2311.1
2023-11-08 13:50:33 +00:00
list(APPEND FEX_TUNE_COMPILE_FLAGS "-march=native")
Use mcpu=native with Clang 12 Clang 12 fixes the bug with big.little configurations so we can keep using mcpu=native past this point
2021-04-17 01:39:06 +00:00
endif()
Works around Clang failing to identify new Kryo CPUs Some of the newer CPU cores in LLVM's source claim to be a Cortex-A73, which means they become limited to an ARMv8.0 feature set. This is what you get if you compile FEX with -mcpu=native To work around this issue, manually parse /proc/cpuinfo ourselves and pull out the CPU type to pass to clang directly. This also fixes the issue that we were using -march on AArch64, which no longer works on newer clang versions. We instead need to use mcpu or mtune. Should improve all atomic op performance outside of the JITs, where they were turning in to loadstore exclusive pairs.
2021-01-19 11:21:10 +00:00
endif()
Arm64: Don't fall back to native In the case of Arm64, make sure not to fallback to native if we hit an unsupported CPU. Can cause issues depending on system configuration.
2021-10-22 03:39:49 +00:00
else()
CMake: Adds a TUNE_CPU option By default we tune to the native CPU, using some heuristics to determine the true native CPU since Apple doesn't expose an MIDR. Adds an option that allows the user to pass in the CPU to tune for. This will be useful for debugging and also for package building.
2021-12-30 01:14:40 +00:00
check_cxx_compiler_flag("-mcpu=${TUNE_CPU}" COMPILER_SUPPORTS_CPU_TYPE)
if(COMPILER_SUPPORTS_CPU_TYPE)
FEX: Only pass CPU tunables to FEXCore and FEXLoader This fixes an issue where CPU tunables were ending up in the thunk generator which means if your CPU doesn't support all the features on the *Builder* then it would crash with SIGILL. This was happening with Canonical's runners because they typically only support ARMv8.2 but we are compiling packages to run on ARMv8.4 devices. cc: FEX-2311.1
2023-11-08 13:50:33 +00:00
list(APPEND FEX_TUNE_COMPILE_FLAGS "-mcpu=${TUNE_CPU}")
CMake: Adds a TUNE_CPU option By default we tune to the native CPU, using some heuristics to determine the true native CPU since Apple doesn't expose an MIDR. Adds an option that allows the user to pass in the CPU to tune for. This will be useful for debugging and also for package building.
2021-12-30 01:14:40 +00:00
else()
message(FATAL_ERROR "Trying to compile cpu type '${TUNE_CPU}' but the compiler doesn't support this")
Arm64: Don't fall back to native In the case of Arm64, make sure not to fallback to native if we hit an unsupported CPU. Can cause issues depending on system configuration.
2021-10-22 03:39:49 +00:00
endif()
Works around Clang failing to identify new Kryo CPUs Some of the newer CPU cores in LLVM's source claim to be a Cortex-A73, which means they become limited to an ARMv8.0 feature set. This is what you get if you compile FEX with -mcpu=native To work around this issue, manually parse /proc/cpuinfo ourselves and pull out the CPU type to pass to clang directly. This also fixes the issue that we were using -march on AArch64, which no longer works on newer clang versions. We instead need to use mcpu or mtune. Should improve all atomic op performance outside of the JITs, where they were turning in to loadstore exclusive pairs.
2021-01-19 11:21:10 +00:00
endif()
Moves clang-tidy arguments to root cmakelists This way we don't need to redeclare the arguments twice Also moves IWYU lower so it doesn't hit any external projects other than FEXCore Still not running these since everything needs to be cleaned up anyway
2021-03-10 20:38:16 +00:00
if (ENABLE_IWYU)
find_program(IWYU_EXE "iwyu")
if (IWYU_EXE)
message(STATUS "IWYU enabled")
set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE "${IWYU_EXE}")
endif()
endif()
Initial Commit
2019-07-13 09:41:34 +00:00
add_compile_options(-Wall)
Adds Config.h generated file Gives us the install path and FEXInterpreter locations
2021-03-24 02:12:18 +00:00
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/include/Config.h.in
Move Config.h to ConfigDefines.h We already have a Config.h which conflicts with this file. In issue cropped up if you need to include Config.h (the generated one) from inside Common/ then it would only pull the Common/Config.h file. Just change the name to not be confusing
2021-06-16 02:06:49 +00:00
${CMAKE_BINARY_DIR}/generated/ConfigDefines.h)
Adds Config.h generated file Gives us the install path and FEXInterpreter locations
2021-03-24 02:12:18 +00:00
Moves BUILD_TESTS check up the list This way Source/ can have its own tests
2021-03-14 22:24:36 +00:00
if (BUILD_TESTS)
include(CTest)
enable_testing()
message(STATUS "Unit tests are enabled")
Use number of jobs as defined by TEST_JOB_COUNT At the moment we always run ctest with max number of cpus. If undefined, it will keep current behaviour, otherwise it will honour TEST_JOB_COUNT. Therefore to run ctest one test at a time, use `cmake ... -DTEST_JOB_COUNT=1`
2024-07-01 13:03:22 +00:00
set (TEST_JOB_COUNT "" CACHE STRING "Override number of parallel jobs to use while running tests")
if (TEST_JOB_COUNT)
message(STATUS "Running tests with ${TEST_JOB_COUNT} jobs")
Use nproc only if TEST_JOB_COUNT not specified
2024-07-08 19:38:56 +00:00
elseif(CMAKE_VERSION VERSION_LESS "3.29")
Use number of jobs as defined by TEST_JOB_COUNT At the moment we always run ctest with max number of cpus. If undefined, it will keep current behaviour, otherwise it will honour TEST_JOB_COUNT. Therefore to run ctest one test at a time, use `cmake ... -DTEST_JOB_COUNT=1`
2024-07-01 13:03:22 +00:00
execute_process(COMMAND "nproc" OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE TEST_JOB_COUNT)
endif()
set(TEST_JOB_FLAG "-j${TEST_JOB_COUNT}")
Moves BUILD_TESTS check up the list This way Source/ can have its own tests
2021-03-14 22:24:36 +00:00
endif()
Improves compile ability for older libraries Adds a header only include utility folder that can be included from everywhere. Contains syscall helpers for older glibc and defines for older Linux uapi headers missing some defines.
2021-12-24 23:43:25 +00:00
add_subdirectory(FEXHeaderUtils/)
FEXCore: Moves CodeEmitter to FHU Now that the vixl dependency is gone, this gets moved to FHU since the frontend is going to need it for a microjit.
2024-05-08 19:00:08 +00:00
add_subdirectory(CodeEmitter/)
Move External/FEXCore/ to FEXCore/ It is not an external component, and it makes paths needlessly long. Ryan seemed amenable to this when we discussed on IRC earlier. Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2023-08-17 20:30:42 +00:00
add_subdirectory(FEXCore/)
Remove annoying vixl warnings
2020-11-20 09:58:58 +00:00
Switches binfmt_misc install step to use registration files This is easier to represent than the raw files. Once we do a debian file install then this becomes more important
2021-06-23 03:22:09 +00:00
# Binfmt_misc files must be installed prior to Source/ installs
add_subdirectory(Data/binfmts/)
Initial Commit
2019-07-13 09:41:34 +00:00
add_subdirectory(Source/)
Implements support for installing global application profiles These need to be used sparingly, we don't want to proactively crush user options.
2021-03-24 05:32:16 +00:00
add_subdirectory(Data/AppConfig/)
Initial Commit
2019-07-13 09:41:34 +00:00
Thunks: Install a global thunksDB for our current thunks This covers the x86_64 definitions, in the future we can have the 32-bit versions in here as well.
2021-10-08 03:20:34 +00:00
# Install the ThunksDB file
CMake: Support multiple json files in the root of Data/ Instead of just ThunksDB
2022-08-07 04:31:23 +00:00
file(GLOB CONFIG_SOURCES CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/Data/*.json)
# Any application configuration json file gets installed
foreach(CONFIG_SRC ${CONFIG_SOURCES})
install(FILES ${CONFIG_SRC}
DESTINATION ${DATA_DIRECTORY}/)
endforeach()
Thunks: Install a global thunksDB for our current thunks This covers the x86_64 definitions, in the future we can have the 32-bit versions in here as well.
2021-10-08 03:20:34 +00:00
Initial Commit
2019-07-13 09:41:34 +00:00
if (BUILD_TESTS)
add_subdirectory(unittests/)
endif()
Thunklibs: Add partial X11, SDL, GL, EGL, asound, cmake integration
2020-08-08 08:35:13 +00:00
Don't build thunks by default Allow people to build fex without a cross-compiler installed
2021-01-30 11:28:15 +00:00
if (BUILD_THUNKS)
Thunks: Use external Vulkan-Headers This will help compiling on older distros which are shipping older Vulkan-Headers. We need to catch newer Vulkan features earlier than what distros ship since it is highly common that users will update their drivers through means that make their drivers be newer. For example to build on Ubuntu 20.04 we will support symbols much newer than what that verison of the distro supports. We could wrap all uses of newer features behind `#ifdef` checks, or include the newest version of the loader that FEX itself supports. The submodule is much cleaner and resolves the issue of drivers supporting newer vulkan versions than libvulkan-dev. Again super common with Nvidia blob users, kisak-ppa users, or people updating mesa directly to be on the bleeding edge.
2022-08-05 02:52:57 +00:00
set (FEX_PROJECT_SOURCE_DIR ${PROJECT_SOURCE_DIR})
Thunks: Add a new code generator based on libclang
2021-12-10 10:24:56 +00:00
add_subdirectory(ThunkLibs/Generator)
CMake: Clean up build architecture for ThunkLibs Host thunk libraries are always built as part of the main project now. Guest thunk libraries are still cross-compiled in a CMake ExternalProject, but *additionally* there are CMake targets in the main project to make sure IDE engines can properly handle guest source files.
2022-02-10 10:23:43 +00:00
# Thunk targets for both host libraries and IDE integration
add_subdirectory(ThunkLibs/HostLibs)
Don't build thunks by default Allow people to build fex without a cross-compiler installed
2021-01-30 11:28:15 +00:00
CMake: Clean up build architecture for ThunkLibs Host thunk libraries are always built as part of the main project now. Guest thunk libraries are still cross-compiled in a CMake ExternalProject, but *additionally* there are CMake targets in the main project to make sure IDE engines can properly handle guest source files.
2022-02-10 10:23:43 +00:00
# Thunk targets for IDE integration of guest code, only
add_subdirectory(ThunkLibs/GuestLibs)
Allows installing of FEXThunks in our data directory This is necessary for building FEX packages that contain some initial thunk libs. Gives an initial foothold for a default location for the host and guest thunk folders
2021-03-24 08:14:24 +00:00
CMake: Clean up build architecture for ThunkLibs Host thunk libraries are always built as part of the main project now. Guest thunk libraries are still cross-compiled in a CMake ExternalProject, but *additionally* there are CMake targets in the main project to make sure IDE engines can properly handle guest source files.
2022-02-10 10:23:43 +00:00
# Thunk targets for guest libraries
include(ExternalProject)
Don't build thunks by default Allow people to build fex without a cross-compiler installed
2021-01-30 11:28:15 +00:00
ExternalProject_Add(guest-libs
PREFIX guest-libs
SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ThunkLibs/GuestLibs"
BINARY_DIR "Guest"
Thunks: Pass Vulkan XML to the thunks generators
2021-10-03 01:03:24 +00:00
CMAKE_ARGS
Thunks: Adds support for building 32-bit. Only VDSO for now.
2022-09-25 03:24:38 +00:00
"-DBITNESS=64"
Thunks: Pass Vulkan XML to the thunks generators
2021-10-03 01:03:24 +00:00
"-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
Thunks: Only build guest target for libfex_thunk_test if FEXLinuxTests are enabled
2023-10-03 09:39:46 +00:00
"-DBUILD_FEX_LINUX_TESTS=${BUILD_FEX_LINUX_TESTS}"
Thunks: Add support for building with clang Fairly straightforward, just requires enabling lld in this case since cross-compiling doesn't work well with gnu linker. Also lld doesn't understand the linker script program header symbolic names for read/write/execute. So we need to use the raw number there. Works around an issue where GCC 11 generates broken `init_array` section and also plt sections that glibc doesn't understand.
2022-10-10 05:49:31 +00:00
"-DENABLE_CLANG_THUNKS=${ENABLE_CLANG_THUNKS}"
CMake: Add toolchain file for 32-bit cross-compiler
2022-09-19 07:19:22 +00:00
"-DCMAKE_TOOLCHAIN_FILE:FILEPATH=${X86_64_TOOLCHAIN_FILE}"
Thunks: Pass Vulkan XML to the thunks generators
2021-10-03 01:03:24 +00:00
"-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
Thunks: Use external Vulkan-Headers This will help compiling on older distros which are shipping older Vulkan-Headers. We need to catch newer Vulkan features earlier than what distros ship since it is highly common that users will update their drivers through means that make their drivers be newer. For example to build on Ubuntu 20.04 we will support symbols much newer than what that verison of the distro supports. We could wrap all uses of newer features behind `#ifdef` checks, or include the newest version of the loader that FEX itself supports. The submodule is much cleaner and resolves the issue of drivers supporting newer vulkan versions than libvulkan-dev. Again super common with Nvidia blob users, kisak-ppa users, or people updating mesa directly to be on the bleeding edge.
2022-08-05 02:52:57 +00:00
"-DFEX_PROJECT_SOURCE_DIR=${FEX_PROJECT_SOURCE_DIR}"
Thunks: Add a new code generator based on libclang
2021-12-10 10:24:56 +00:00
"-DGENERATOR_EXE=$<TARGET_FILE:thunkgen>"
Don't build thunks by default Allow people to build fex without a cross-compiler installed
2021-01-30 11:28:15 +00:00
INSTALL_COMMAND ""
BUILD_ALWAYS ON
Thunks: Add a new code generator based on libclang
2021-12-10 10:24:56 +00:00
DEPENDS thunkgen
Don't build thunks by default Allow people to build fex without a cross-compiler installed
2021-01-30 11:28:15 +00:00
)
Allows installing of FEXThunks in our data directory This is necessary for building FEX packages that contain some initial thunk libs. Gives an initial foothold for a default location for the host and guest thunk folders
2021-03-24 08:14:24 +00:00
Thunks: Adds support for building 32-bit. Only VDSO for now.
2022-09-25 03:24:38 +00:00
ExternalProject_Add(guest-libs-32
PREFIX guest-libs-32
SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ThunkLibs/GuestLibs"
BINARY_DIR "Guest_32"
CMAKE_ARGS
"-DBITNESS=32"
"-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
Thunks: Only build guest target for libfex_thunk_test if FEXLinuxTests are enabled
2023-10-03 09:39:46 +00:00
"-DBUILD_FEX_LINUX_TESTS=${BUILD_FEX_LINUX_TESTS}"
Thunks: Add support for building with clang Fairly straightforward, just requires enabling lld in this case since cross-compiling doesn't work well with gnu linker. Also lld doesn't understand the linker script program header symbolic names for read/write/execute. So we need to use the raw number there. Works around an issue where GCC 11 generates broken `init_array` section and also plt sections that glibc doesn't understand.
2022-10-10 05:49:31 +00:00
"-DENABLE_CLANG_THUNKS=${ENABLE_CLANG_THUNKS}"
Thunks: Adds support for building 32-bit. Only VDSO for now.
2022-09-25 03:24:38 +00:00
"-DCMAKE_TOOLCHAIN_FILE:FILEPATH=${X86_32_TOOLCHAIN_FILE}"
"-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
"-DFEX_PROJECT_SOURCE_DIR=${FEX_PROJECT_SOURCE_DIR}"
"-DGENERATOR_EXE=$<TARGET_FILE:thunkgen>"
INSTALL_COMMAND ""
BUILD_ALWAYS ON
DEPENDS thunkgen
)
Allows installing of FEXThunks in our data directory This is necessary for building FEX packages that contain some initial thunk libs. Gives an initial foothold for a default location for the host and guest thunk folders
2021-03-24 08:14:24 +00:00
install(
CODE "MESSAGE(\"-- Installing: guest-libs\")"
CODE "
Fixes Host and guest thunks install path Hosts were using the cmake install path with $DESTDIR which duplicates paths. GuestThunks were doing some magic that wasn't actually necessary
2022-02-15 23:28:46 +00:00
EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} --build . --target install
Allows installing of FEXThunks in our data directory This is necessary for building FEX packages that contain some initial thunk libs. Gives an initial foothold for a default location for the host and guest thunk folders
2021-03-24 08:14:24 +00:00
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Guest
)"
DEPENDS guest-libs
)
cmake: Adds uninstall target Following guidance from cmake's FAQ: https://gitlab.kitware.com/cmake/community/-/wikis/FAQ#can-i-do-make-uninstall-with-cmake Due to some of the special handling that we do with installs, we need to do additional uninstall handling that the install manifest doesn't cover. Specifically we need to add additional uninstall targets for: - FEXInterpreter - binfmt_misc - guest_thunks (Doing its own uninstall target, so passthrough) While it isn't generally advised to install and uninstall through source systems, this is something that users want to do all the time. This has been asked for a couple of times now. Fixes #1592
2022-09-15 01:16:16 +00:00
Thunks: Adds support for building 32-bit. Only VDSO for now.
2022-09-25 03:24:38 +00:00
install(
CODE "MESSAGE(\"-- Installing: guest-libs-32\")"
CODE "
EXECUTE_PROCESS(COMMAND ${CMAKE_COMMAND} --build . --target install
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Guest_32
)"
DEPENDS guest-libs-32
)
cmake: Adds uninstall target Following guidance from cmake's FAQ: https://gitlab.kitware.com/cmake/community/-/wikis/FAQ#can-i-do-make-uninstall-with-cmake Due to some of the special handling that we do with installs, we need to do additional uninstall handling that the install manifest doesn't cover. Specifically we need to add additional uninstall targets for: - FEXInterpreter - binfmt_misc - guest_thunks (Doing its own uninstall target, so passthrough) While it isn't generally advised to install and uninstall through source systems, this is something that users want to do all the time. This has been asked for a couple of times now. Fixes #1592
2022-09-15 01:16:16 +00:00
add_custom_target(uninstall_guest-libs
COMMAND ${CMAKE_COMMAND} "--build" "." "--target" "uninstall"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Guest
)
Thunks: Adds support for building 32-bit. Only VDSO for now.
2022-09-25 03:24:38 +00:00
add_custom_target(uninstall_guest-libs-32
COMMAND ${CMAKE_COMMAND} "--build" "." "--target" "uninstall"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Guest_32
)
cmake: Adds uninstall target Following guidance from cmake's FAQ: https://gitlab.kitware.com/cmake/community/-/wikis/FAQ#can-i-do-make-uninstall-with-cmake Due to some of the special handling that we do with installs, we need to do additional uninstall handling that the install manifest doesn't cover. Specifically we need to add additional uninstall targets for: - FEXInterpreter - binfmt_misc - guest_thunks (Doing its own uninstall target, so passthrough) While it isn't generally advised to install and uninstall through source systems, this is something that users want to do all the time. This has been asked for a couple of times now. Fixes #1592
2022-09-15 01:16:16 +00:00
add_dependencies(uninstall uninstall_guest-libs)
Thunks: Adds support for building 32-bit. Only VDSO for now.
2022-09-25 03:24:38 +00:00
add_dependencies(uninstall uninstall_guest-libs-32)
Don't build thunks by default Allow people to build fex without a cross-compiler installed
2021-01-30 11:28:15 +00:00
endif()
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
set(FEX_VERSION_MAJOR "0")
set(FEX_VERSION_MINOR "0")
set(FEX_VERSION_PATCH "0")
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
if (OVERRIDE_VERSION STREQUAL "detect")
find_package(Git)
if (GIT_FOUND)
execute_process(
COMMAND ${GIT_EXECUTABLE} describe --abbrev=0
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
OUTPUT_VARIABLE GIT_DESCRIBE_STRING
RESULT_VARIABLE GIT_ERROR
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
)
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
if (NOT ${GIT_ERROR} EQUAL 0)
# Likely built in a way that doesn't have tags
# Setup a version tag that is unknown
set(GIT_DESCRIBE_STRING "FEX-0000")
endif()
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
endif()
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
else()
set(GIT_DESCRIBE_STRING "FEX-${OVERRIDE_VERSION}")
endif()
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
# Parse the version here
# Change something like `FEX-2106.1-76-<hash>` in to a list
string(REPLACE "-" ";" DESCRIBE_LIST ${GIT_DESCRIBE_STRING})
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
# Extract the `2106.1` element
list(GET DESCRIBE_LIST 1 DESCRIBE_LIST)
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
# Change `2106.1` in to a list
string(REPLACE "." ";" DESCRIBE_LIST ${DESCRIBE_LIST})
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
# Calculate list size
list(LENGTH DESCRIBE_LIST LIST_SIZE)
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
# Pull out the major version
list(GET DESCRIBE_LIST 0 FEX_VERSION_MAJOR)
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
CMake: Adds an OVERRIDE_VERSION option This is intended to be used by a package maintainer to override the version when the git repo or git executable isn't available. Not expected to be used by normal users. Instead by our automated ppa tooling.
2021-12-31 06:55:46 +00:00
# Minor version only exists if there is a .1 at the end
# eg: 2106 versus 2106.1
if (LIST_SIZE GREATER 1)
list(GET DESCRIBE_LIST 1 FEX_VERSION_MINOR)
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
endif()
# Package creation
set (CPACK_GENERATOR "DEB")
cmake: Remove the static-pie compilation option Due to glibc issues around static applications doing dlopen this is a fundamentally broken option and no longer supported by FEX. Remove the option entirely as to not be confusing. We kept this around initially for chroot support, but with our RootFS mounting AArch64 folders inside the chroot this isn't necessary anymore.
2022-08-05 02:22:11 +00:00
set (CPACK_PACKAGE_NAME fex-emu)
CPack: Update package name Didn't expose a real version before
2021-11-21 18:34:44 +00:00
set (CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${GIT_DESCRIBE_STRING}_${CMAKE_SYSTEM_PROCESSOR}")
New domain. Needed to fix FEXRootFSFetcher from #1967
2022-09-02 17:43:07 +00:00
set (CPACK_PACKAGE_CONTACT "FEX-Emu Maintainers <team@fex-emu.com>")
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
set (CPACK_PACKAGE_VERSION_MAJOR "${FEX_VERSION_MAJOR}")
set (CPACK_PACKAGE_VERSION_MINOR "${FEX_VERSION_MINOR}")
set (CPACK_PACKAGE_VERSION_PATCH "${FEX_VERSION_PATCH}")
CPack: Add description file lintian complains about this
2021-11-21 18:32:36 +00:00
set (CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/CPack/Description.txt")
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
# Debian defines
CPack: Adds more library dependencies FEXConfig mostly needs these squashfuse is for FEXMountDaemon
2021-11-21 18:40:30 +00:00
set (CPACK_DEBIAN_PACKAGE_DEPENDS "libc6, libstdc++6, libepoxy0, libsdl2-2.0-0, libegl1, libx11-6, squashfuse")
CPack: Add an ldconfig trigger lintian was complaining about this
2021-11-21 18:38:56 +00:00
set (CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA
"${CMAKE_CURRENT_SOURCE_DIR}/CPack/postinst;${CMAKE_CURRENT_SOURCE_DIR}/CPack/prerm;${CMAKE_CURRENT_SOURCE_DIR}/CPack/triggers")
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
if (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
# binfmt_misc conflicts with qemu-user-static
# We also only install binfmt_misc on aarch64 hosts
CPack: Update conflicts and change package name when built statically Will allow users to choose between a static package or a non-static package These packages will conflict with each other, so you can only choose one or the other. fex-emu-static: Necessary for Chroots, Can't use thunking. fex-emu: Necessary for thunking, Can't as easily be used for chroots
2021-11-21 18:36:02 +00:00
set (CPACK_DEBIAN_PACKAGE_CONFLICTS "${CPACK_DEBIAN_PACKAGE_CONFLICTS}, qemu-user-static")
Implements support for cpack debian package building This doesn't currently install thunks which can come a bit later. We require a postinst and prerm step for importing and unimporting the binfmt_misc files. Easy enough
2021-06-23 03:24:29 +00:00
endif()
include (CPack)
Reference in New Issue Copy Permalink