FEX-Emu/FEX
1
0
Fork 0
mirror of https://github.com/FEX-Emu/FEX.git synced 2024-11-30 10:11:07 +00:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity
35c52f20f9
FEX/CMakeLists.txt

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)
Initial Commit
2019-07-13 09:41:34 +00:00
project(FEX)
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: Fix typo in clang thunks option.
2022-11-22 05:11:01 +00:00
option(ENABLE_CLANG_THUNKS "Build thunks with clang" FALSE)
Initial Commit
2019-07-13 09:41:34 +00:00
option(ENABLE_CLANG_FORMAT "Run clang format over the source" 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: Add option to use the mold linker
2022-03-09 18:53:40 +00:00
option(ENABLE_LLD "Enable linking with lld" FALSE)
option(ENABLE_MOLD "Enable linking with mold" FALSE)
Initial Commit
2019-07-13 09:41:34 +00:00
option(ENABLE_ASAN "Enables Clang ASAN" FALSE)
option(ENABLE_TSAN "Enables Clang TSAN" 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 an option to disable the IR interpreter By default we won't build with the interpeter to reduce user confusion. The interpreter isn't really useful to end users so remove it. Completely removes it from building except for the fallback operations. This also removes the selection from FEXConfig to remove selection confusion there. File Stats: FEXLoader Size with Interpreter: 3422768 bytes FEXLoader Size without Interpreter: 3301944 bytes Size difference: 96.4699915% Bytes removed: 120824 bytes 4k pages removed: 29.498046875 -> 30 rounded up VM Stats (Reported from bloaty): Memory Size with Interpreter: 6.50Mi Memory Size without Interpreter: 6.38Mi Size difference: 98.1538462%
2022-02-01 21:00:29 +00:00
option(ENABLE_INTERPRETER "Enables FEX's Interpreter" 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)
Adds a cmake option for forcing a termux build This is necessary when cross-compiling rather than building on-device
2022-03-06 16:41:31 +00:00
option(ENABLE_TERMUX_BUILD "Forces building for Termux on a non-Termux build machine" FALSE)
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")
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)
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()
Adds an option to disable the IR interpreter By default we won't build with the interpeter to reduce user confusion. The interpreter isn't really useful to end users so remove it. Completely removes it from building except for the fallback operations. This also removes the selection from FEXConfig to remove selection confusion there. File Stats: FEXLoader Size with Interpreter: 3422768 bytes FEXLoader Size without Interpreter: 3301944 bytes Size difference: 96.4699915% Bytes removed: 120824 bytes 4k pages removed: 29.498046875 -> 30 rounded up VM Stats (Reported from bloaty): Memory Size with Interpreter: 6.50Mi Memory Size without Interpreter: 6.38Mi Size difference: 98.1538462%
2022-02-01 21:00:29 +00:00
if (ENABLE_INTERPRETER)
message(STATUS "Interpreter enabled")
add_definitions(-DINTERPRETER_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")
option(ENABLE_X86_HOST_DEBUG "Enables compiling on x86_64 host" FALSE)
if (NOT ENABLE_X86_HOST_DEBUG)
message(FATAL_ERROR
" Be warned: FEX isn't optimized for x86_64 hosts!\n"
" Support for x86_64 hosts is only for debugging and convenience!\n"
" Don't expect amazing performance or optimal code generation!\n"
" Pass -DENABLE_X86_HOST_DEBUG=True to bypass this message!")
endif()
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()
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
if (ENABLE_LLD AND ENABLE_MOLD)
message (FATAL_ERROR "Cannot enable both lld and mold")
elseif (ENABLE_LLD)
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
set (LD_OVERRIDE "-fuse-ld=lld")
CMake: Add option to use the mold linker
2022-03-09 18:53:40 +00:00
add_link_options(${LD_OVERRIDE})
elseif (ENABLE_MOLD)
add_link_options("-fuse-ld=mold")
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()
Adds a cmake option for forcing a termux build This is necessary when cross-compiling rather than building on-device
2022-03-06 16:41:31 +00:00
if(DEFINED ENV{TERMUX_VERSION} OR ENABLE_TERMUX_BUILD)
Work around Termux not supporting hardlinks The Android filesystem they are on just doesn't support them Instead of hardlinking FEXLoader to FEXInterpter, just build the executable twice and eat the filesystem cost.
2022-02-24 22:27:38 +00:00
add_definitions(-DTERMUX_BUILD=1)
set(TERMUX_BUILD 1)
# Termux doesn't support Jemalloc due to bad interactions between emutls, jemalloc, and scudo
set(ENABLE_JEMALLOC FALSE)
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()
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/)
else()
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/)
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
else()
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()
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_directories(External/vixl/src/)
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
CMake: Always use local xxhash to statically link Dynamically linking xxhash is causing problems with pressure-vessel. With this in place we only have the typical C++ dependencies ``` $ ldd ./Bin/FEXLoader linux-vdso.so.1 (0x00007fff44d9d000) libstdc++.so.6 => /lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007f4c4d884000) libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f4c4d7a0000) libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f4c4d786000) libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f4c4d55e000) /lib64/ld-linux-x86-64.so.2 (0x00007f4c4e0fa000) ```
2022-02-03 09:31:43 +00:00
add_subdirectory(External/xxhash/)
include_directories(External/xxhash/)
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)
option(CATCH_BUILD_STATIC_LIBRARY "" ON)
set(CATCH_BUILD_STATIC_LIBRARY ON)
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()
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
include_directories(External/xbyak/)
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()
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)
add_compile_options("-march=${TUNE_ARCH}")
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)
add_compile_options("-mcpu=native")
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)
add_compile_options("-mcpu=${AARCH64_CPU}")
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)
add_compile_options("-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)
add_compile_options("-mcpu=${TUNE_CPU}")
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()
if (ENABLE_CLANG_FORMAT)
find_program(CLANG_TIDY_EXE "clang-tidy")
if (NOT CLANG_TIDY_EXE)
message(FATAL_ERROR "Couldn't find clang-tidy")
endif()
set(CLANG_TIDY_FLAGS
"-checks=*"
"-fuchsia*"
"-bugprone-macro-parentheses"
"-clang-analyzer-core.*"
"-cppcoreguidelines-pro-type-*"
"-cppcoreguidelines-pro-bounds-array-to-pointer-decay"
"-cppcoreguidelines-pro-bounds-pointer-arithmetic"
"-cppcoreguidelines-avoid-c-arrays"
"-cppcoreguidelines-avoid-magic-numbers"
"-cppcoreguidelines-pro-bounds-constant-array-index"
"-cppcoreguidelines-no-malloc"
"-cppcoreguidelines-special-member-functions"
"-cppcoreguidelines-owning-memory"
"-cppcoreguidelines-macro-usage"
"-cppcoreguidelines-avoid-goto"
"-google-readability-function-size"
"-google-readability-namespace-comments"
"-google-readability-braces-around-statements"
"-google-build-using-namespace"
"-hicpp-*"
"-llvm-namespace-comment"
"-llvm-include-order" # Messes up with case sensitivity
"-llvmlibc-*"
"-misc-unused-parameters"
"-modernize-loop-convert"
"-modernize-use-auto"
"-modernize-avoid-c-arrays"
"-modernize-use-nodiscard"
"readability-*"
"-readability-function-size"
"-readability-implicit-bool-conversion"
"-readability-braces-around-statements"
"-readability-else-after-return"
"-readability-magic-numbers"
"-readability-named-parameter"
"-readability-uppercase-literal-suffix"
"-cert-err34-c"
"-cert-err58-cpp"
"-bugprone-exception-escape"
)
string(REPLACE ";" "," CLANG_TIDY_FLAGS "${CLANG_TIDY_FLAGS}")
set(CMAKE_CXX_CLANG_TIDY ${CLANG_TIDY_EXE} "${CLANG_TIDY_FLAGS}")
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")
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/)
Remove annoying vixl warnings
2020-11-20 09:58:58 +00:00
add_subdirectory(External/FEXCore)
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: 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}"
"-DSTRUCT_VERIFIER=${CMAKE_SOURCE_DIR}/Scripts/StructPackVerifier.py"
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: 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}"
"-DSTRUCT_VERIFIER=${CMAKE_SOURCE_DIR}/Scripts/StructPackVerifier.py"
"-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