system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-09 01:10:47 +00:00
Code Issues Projects Releases Wiki Activity
857cdee0d0
serenity/CMakeLists.txt

193 lines
7.4 KiB
CMake
Raw Normal View History

Build: Allow using CMake 3.16 Because apparently that's what a lot of people have, and they report it works fine.
2020-05-15 07:52:37 +00:00
cmake_minimum_required(VERSION 3.16)
project(SerenityOS C CXX ASM)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
cmake: Make setting CMAKE_BUILD_TYPE an error. I tried setting it to Release, then noticed that it didn't build due to gcc's optimizer-level dependent warnings and -Werror, then started fixing the warnings for a bit (all false positives), then looked at the global CMakeLists.txt and realized that the default build is aleady using compiler optimizations. It looks like people aren't supposed to change this, so make that explicit to be friendly to people familiar with cmake but new to serenity.
2020-06-06 01:23:31 +00:00
if(NOT "${CMAKE_BUILD_TYPE}" STREQUAL "")
message(FATAL
": Don't use CMAKE_BUILD_TYPE when building serenity.\n"
"The default build type is optimized with debug info and asserts enabled,\n"
"and that's all there is.")
endif()
CMake: Make the install step more zen The "Installing $foo..." messages are just noise, so turn them off.
2020-06-19 14:52:39 +00:00
set(CMAKE_INSTALL_MESSAGE NEVER)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
enable_testing()
CMake: compile_commands.json output Problem: - CMake is not outputting `compile_commands.json`. - `compile_commands.json` is used by build integration tooling such as `clang-tidy`. Solution: - Enable `CMAKE_EXPORT_COMPILE_COMMANDS` option so that the file is output.
2020-11-11 22:59:06 +00:00
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
Build: Support non-i686 toolchains * Add SERENITY_ARCH option to CMake for selecting the target toolchain * Port all build scripts but continue to use i686 * Update GitHub Actions cache to include BuildIt.sh
2020-12-29 03:38:52 +00:00
set(SERENITY_ARCH "i686" CACHE STRING "Target architecture for SerenityOS.")
CMake: Add public cmake option to document ENABLE_ALL_THE_DEBUG_MACROS - Making this an option makes this option visible to users and tooling. - Rename `ALL_THE_DEBUG_MACROS` -> `ENABLE_ALL_THE_DEBUG_MACROS`.
2021-01-01 10:26:52 +00:00
# Central location for all custom options used in the Serenity build.
CMake: Consolidate all options to the root of the project
2021-01-01 10:19:48 +00:00
option(ENABLE_ADDRESS_SANITIZER "Enable address sanitizer testing in gcc/clang" FALSE)
Kernel: Initial integration of Kernel Address Sanitizer (KASAN) KASAN is a dynamic analysis tool that finds memory errors. It focuses mostly on finding use-after-free and out-of-bound read/writes bugs. KASAN works by allocating a "shadow memory" region which is used to store whether each byte of memory is safe to access. The compiler then instruments the kernel code and a check is inserted which validates the state of the shadow memory region on every memory access (load or store). To fully integrate KASAN into the SerenityOS kernel we need to: a) Implement the KASAN interface to intercept the injected loads/stores. void __asan_load*(address); void __asan_store(address); b) Setup KASAN region and determine the shadow memory offset + translation. This might be challenging since Serenity is only 32bit at this time. Ex: Linux implements kernel address -> shadow address translation like: static inline void *kasan_mem_to_shadow(const void *addr) { return ((unsigned long)addr >> KASAN_SHADOW_SCALE_SHIFT) + KASAN_SHADOW_OFFSET; } c) Integrating KASAN with Kernel allocators. The kernel allocators need to be taught how to record allocation state in the shadow memory region. This commit only implements the initial steps of this long process: - A new (default OFF) CMake build flag `ENABLE_KERNEL_ADDRESS_SANITIZER` - Stubs out enough of the KASAN interface to allow the Kernel to link clean. Currently the KASAN kernel crashes on boot (triple fault because of the crash in strlen other sanitizer are seeing) but the goal here is to just get started, and this should help others jump in and continue making progress on KASAN. References: * ASAN Paper: https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/37752.pdf * KASAN Docs: https://github.com/google/kasan * NetBSD KASAN Blog: https://blog.netbsd.org/tnf/entry/kernel_address_sanitizer_part_3 * LWN KASAN Article: https://lwn.net/Articles/612153/ * Tracking Issue #5351
2021-02-14 20:47:10 +00:00
option(ENABLE_KERNEL_ADDRESS_SANITIZER "Enable kernel address sanitizer testing in gcc/clang" FALSE)
CMake: Consolidate all options to the root of the project
2021-01-01 10:19:48 +00:00
option(ENABLE_MEMORY_SANITIZER "Enable memory sanitizer testing in gcc/clang" FALSE)
option(ENABLE_UNDEFINED_SANITIZER "Enable undefined behavior sanitizer testing in gcc/clang" FALSE)
option(ENABLE_FUZZER_SANITIZER "Enable fuzzer sanitizer testing in clang" FALSE)
CMake: Add public cmake option to document ENABLE_ALL_THE_DEBUG_MACROS - Making this an option makes this option visible to users and tooling. - Rename `ALL_THE_DEBUG_MACROS` -> `ENABLE_ALL_THE_DEBUG_MACROS`.
2021-01-01 10:26:52 +00:00
option(ENABLE_ALL_THE_DEBUG_MACROS "Enable all debug macros to validate they still compile" FALSE)
CMake: Add public cmake option to document BUILD_LAGOM - Making this an option makes this option visible to users and tooling.
2021-01-01 10:44:04 +00:00
option(BUILD_LAGOM "Build parts of the system targeting the host OS for fuzzing/testing" FALSE)
CMake: Consolidate all options to the root of the project
2021-01-01 10:19:48 +00:00
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
add_custom_target(run
COMMAND ${CMAKE_SOURCE_DIR}/Meta/run.sh
USES_TERMINAL
)
CMake: Add 'setup-and-run' target to perform all prereqs and run the image Running 'ninja install && ninja image && ninja run` is kind of annoying. I got tired, and came up with this instead, which does the right thing and I don't have to type out the incantation.
2021-02-14 23:59:20 +00:00
# This can currently only be implemented by ordered commands
# as cmake doesn't support inter dependency ordering, and we
# would like to avoid inject dependencies on the existing
# custom commands to allow people to run commands adhoc with
# out forcing re-builds when they might not want them.
add_custom_target(setup-and-run
COMMAND ${CMAKE_MAKE_PROGRAM} install
COMMAND ${CMAKE_MAKE_PROGRAM} image
COMMAND ${CMAKE_MAKE_PROGRAM} run
USES_TERMINAL
)
Build: rename `image` target => `qemu-image` Also add a new `image` target which is just an alias to `qemu-image`. This makes the CMakeLists.txt file more readable in my opinion.
2020-06-20 01:04:42 +00:00
add_custom_target(image
DEPENDS qemu-image
)
add_custom_target(qemu-image
Build: Support non-i686 toolchains * Add SERENITY_ARCH option to CMake for selecting the target toolchain * Port all build scripts but continue to use i686 * Update GitHub Actions cache to include BuildIt.sh
2020-12-29 03:38:52 +00:00
COMMAND ${CMAKE_COMMAND} -E env "SERENITY_ROOT=${CMAKE_SOURCE_DIR}" "SERENITY_ARCH=${SERENITY_ARCH}" ${CMAKE_SOURCE_DIR}/Meta/build-image-qemu.sh
Build: rename `image` target => `qemu-image` Also add a new `image` target which is just an alias to `qemu-image`. This makes the CMakeLists.txt file more readable in my opinion.
2020-06-20 01:04:42 +00:00
BYPRODUCTS ${CMAKE_BINARY_DIR}/_disk_image
USES_TERMINAL
)
Build: Add grub-image target to CMake
2020-05-26 21:51:18 +00:00
add_custom_target(grub-image
Build: Support non-i686 toolchains * Add SERENITY_ARCH option to CMake for selecting the target toolchain * Port all build scripts but continue to use i686 * Update GitHub Actions cache to include BuildIt.sh
2020-12-29 03:38:52 +00:00
COMMAND ${CMAKE_COMMAND} -E env "SERENITY_ROOT=${CMAKE_SOURCE_DIR}" "SERENITY_ARCH=${SERENITY_ARCH}" ${CMAKE_SOURCE_DIR}/Meta/build-image-grub.sh
Build: Use a separate byproduct name for the GRUB disk image (#2424) The grub-image target no longer conflicts with normal image target. This unbreaks using CMake with Ninja. Fixes #2423.
2020-05-28 08:08:38 +00:00
BYPRODUCTS ${CMAKE_BINARY_DIR}/grub_disk_image
Build: Add grub-image target to CMake
2020-05-26 21:51:18 +00:00
USES_TERMINAL
)
CMake: Add convenience targets to run lint-shell-scripts and check-style
2020-05-28 19:06:44 +00:00
add_custom_target(lint-shell-scripts
COMMAND ${CMAKE_SOURCE_DIR}/Meta/lint-shell-scripts.sh
USES_TERMINAL
)
add_custom_target(check-style
COMMAND ${CMAKE_SOURCE_DIR}/Meta/check-style.sh
USES_TERMINAL
)
CMake: Set C++20 mode in canonical cmake Problem: - Setting `CMAKE_CXX_FLAGS` directly to effect the version of the C++ standard being used is no longer the recommended best practice. Solution: - Set C++20 mode in the compiler by setting `CMAKE_CXX_STANDARD`. - Force the build system generator not to fallback to the latest standard supported by the compiler by enabling `CMAKE_CXX_STANDARD_REQUIRED`. This shouldn't ever be a problem though since the toolchain is tightly controlled. - Disable GNU compiler extensions by disabling `CMAKE_CXX_EXTENSIONS` to preserve the previous flags.
2020-12-22 00:47:47 +00:00
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
Meta: Make it possible to (somewhat) build the system inside Serenity This removes some hard references to the toolchain, some unnecessary uses of an external install command, and disables a -Werror flag (for the time being) - only if run inside serenity. With this, we can build and link the kernel :^)
2021-02-14 21:49:25 +00:00
if (${CMAKE_HOST_SYSTEM_NAME} MATCHES SerenityOS)
# FIXME: Something makes this go crazy and flag unused variables that aren't flagged as such when building with the toolchain.
# Disable -Werror for now.
Toolchain: Use -ftls-model=initial-exec by default Our TLS implementation relies on the TLS model being "initial-exec". We previously enforced this by adding the '-ftls-model=initial-exec' flag in the root CmakeLists file, but that did not affect ports - So now we put that flag in the gcc spec files. Closes #5366
2021-02-19 13:54:40 +00:00
add_compile_options(-Wno-unknown-warning-option -Wall -Wextra -Wmissing-declarations -Wformat=2 -fdiagnostics-color=always)
Meta: Make it possible to (somewhat) build the system inside Serenity This removes some hard references to the toolchain, some unnecessary uses of an external install command, and disables a -Werror flag (for the time being) - only if run inside serenity. With this, we can build and link the kernel :^)
2021-02-14 21:49:25 +00:00
else()
Toolchain: Use -ftls-model=initial-exec by default Our TLS implementation relies on the TLS model being "initial-exec". We previously enforced this by adding the '-ftls-model=initial-exec' flag in the root CmakeLists file, but that did not affect ports - So now we put that flag in the gcc spec files. Closes #5366
2021-02-19 13:54:40 +00:00
add_compile_options(-Wno-unknown-warning-option -Wall -Wextra -Werror -Wmissing-declarations -Wformat=2 -fdiagnostics-color=always)
Meta: Make it possible to (somewhat) build the system inside Serenity This removes some hard references to the toolchain, some unnecessary uses of an external install command, and disables a -Werror flag (for the time being) - only if run inside serenity. With this, we can build and link the kernel :^)
2021-02-14 21:49:25 +00:00
endif()
CMake: Use add_compile_options instead of appending to CMAKE_CXX_FLAGS Problem: - Appending to CMAKE_CXX_FLAGS for everything is cumbersome. Solution: - Use the `add_compile_options` built-in function to handle adding compiler options (and even de-duplicating).
2020-12-22 01:04:46 +00:00
Build: Make things build with clang without needing local changes Useful for sanitizer fuzzer builds. clang doesn't have a -fconcepts switch (I'm guessing it just enables concepts automatically with -std=c++2a, but I haven't checked), and at least the version on my system doesn't understand -Wno-deprecated-move, so pass these two flags only to gcc. In return, disable -Woverloaded-virtual which fires in many places. The preceding commits fixed the handful of -Wunused-private-field warnings that clang emitted.
2020-08-04 15:08:03 +00:00
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
CMake: Use add_compile_options instead of appending to CMAKE_CXX_FLAGS Problem: - Appending to CMAKE_CXX_FLAGS for everything is cumbersome. Solution: - Use the `add_compile_options` built-in function to handle adding compiler options (and even de-duplicating).
2020-12-22 01:04:46 +00:00
add_compile_options(-fconcepts)
Build: Make things build with clang without needing local changes Useful for sanitizer fuzzer builds. clang doesn't have a -fconcepts switch (I'm guessing it just enables concepts automatically with -std=c++2a, but I haven't checked), and at least the version on my system doesn't understand -Wno-deprecated-move, so pass these two flags only to gcc. In return, disable -Woverloaded-virtual which fires in many places. The preceding commits fixed the handful of -Wunused-private-field warnings that clang emitted.
2020-08-04 15:08:03 +00:00
elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
CMake: Use add_compile_options instead of appending to CMAKE_CXX_FLAGS Problem: - Appending to CMAKE_CXX_FLAGS for everything is cumbersome. Solution: - Use the `add_compile_options` built-in function to handle adding compiler options (and even de-duplicating).
2020-12-22 01:04:46 +00:00
add_compile_options(-Wno-overloaded-virtual)
Build: Make things build with clang without needing local changes Useful for sanitizer fuzzer builds. clang doesn't have a -fconcepts switch (I'm guessing it just enables concepts automatically with -std=c++2a, but I haven't checked), and at least the version on my system doesn't understand -Wno-deprecated-move, so pass these two flags only to gcc. In return, disable -Woverloaded-virtual which fires in many places. The preceding commits fixed the handful of -Wunused-private-field warnings that clang emitted.
2020-08-04 15:08:03 +00:00
endif()
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
CMake: Add public cmake option to document ENABLE_ALL_THE_DEBUG_MACROS - Making this an option makes this option visible to users and tooling. - Rename `ALL_THE_DEBUG_MACROS` -> `ENABLE_ALL_THE_DEBUG_MACROS`.
2021-01-01 10:26:52 +00:00
if (ENABLE_ALL_THE_DEBUG_MACROS)
CMake: Decouple cmake utility functions from top-level CMakeLists.txt Problem: - These utility functions are only used in `AK`, but are being defined in the top-level. This clutters the top-level. Solution: - Move the utility functions to `Meta/CMake/utils.cmake` and include where needed. - Also, move `all_the_debug_macros.cmake` into `Meta/CMake` directory to consolidate the location of `*.cmake` script files.
2020-12-23 17:07:22 +00:00
include(${CMAKE_SOURCE_DIR}/Meta/CMake/all_the_debug_macros.cmake)
CMake: Add public cmake option to document ENABLE_ALL_THE_DEBUG_MACROS - Making this an option makes this option visible to users and tooling. - Rename `ALL_THE_DEBUG_MACROS` -> `ENABLE_ALL_THE_DEBUG_MACROS`.
2021-01-01 10:26:52 +00:00
endif(ENABLE_ALL_THE_DEBUG_MACROS)
Meta: Provide option to build with ALL debug macros
2020-08-26 22:59:36 +00:00
Everywhere: Use CMake to generate AK/Debug.h. This was done with the help of several scripts, I dump them here to easily find them later: awk '/#ifdef/ { print "#cmakedefine01 "$2 }' AK/Debug.h.in for debug_macro in $(awk '/#ifdef/ { print $2 }' AK/Debug.h.in) do find . \( -name '*.cpp' -o -name '*.h' -o -name '*.in' \) -not -path './Toolchain/*' -not -path './Build/*' -exec sed -i -E 's/#ifdef '$debug_macro'/#if '$debug_macro'/' {} \; done # Remember to remove WRAPPER_GERNERATOR_DEBUG from the list. awk '/#cmake/ { print "set("$2" ON)" }' AK/Debug.h.in
2021-01-23 22:29:11 +00:00
configure_file(AK/Debug.h.in AK/Debug.h @ONLY)
Meta: Split debug defines into multiple headers. The following script was used to make these changes: #!/bin/bash set -e tmp=$(mktemp -d) echo "tmp=$tmp" find Kernel \( -name '*.cpp' -o -name '*.h' \) | sort > $tmp/Kernel.files find . \( -path ./Toolchain -prune -o -path ./Build -prune -o -path ./Kernel -prune \) -o \( -name '*.cpp' -o -name '*.h' \) -print | sort > $tmp/EverythingExceptKernel.files cat $tmp/Kernel.files | xargs grep -Eho '[A-Z0-9_]+_DEBUG' | sort | uniq > $tmp/Kernel.macros cat $tmp/EverythingExceptKernel.files | xargs grep -Eho '[A-Z0-9_]+_DEBUG' | sort | uniq > $tmp/EverythingExceptKernel.macros comm -23 $tmp/Kernel.macros $tmp/EverythingExceptKernel.macros > $tmp/Kernel.unique comm -1 $tmp/Kernel.macros $tmp/EverythingExceptKernel.macros > $tmp/EverythingExceptKernel.unique cat $tmp/Kernel.unique | awk '{ print "#cmakedefine01 "$1 }' > $tmp/Kernel.header cat $tmp/EverythingExceptKernel.unique | awk '{ print "#cmakedefine01 "$1 }' > $tmp/EverythingExceptKernel.header for macro in $(cat $tmp/Kernel.unique) do cat $tmp/Kernel.files | xargs grep -l $macro >> $tmp/Kernel.new-includes ||: done cat $tmp/Kernel.new-includes | sort > $tmp/Kernel.new-includes.sorted for macro in $(cat $tmp/EverythingExceptKernel.unique) do cat $tmp/Kernel.files | xargs grep -l $macro >> $tmp/Kernel.old-includes ||: done cat $tmp/Kernel.old-includes | sort > $tmp/Kernel.old-includes.sorted comm -23 $tmp/Kernel.new-includes.sorted $tmp/Kernel.old-includes.sorted > $tmp/Kernel.includes.new comm -13 $tmp/Kernel.new-includes.sorted $tmp/Kernel.old-includes.sorted > $tmp/Kernel.includes.old comm -12 $tmp/Kernel.new-includes.sorted $tmp/Kernel.old-includes.sorted > $tmp/Kernel.includes.mixed for file in $(cat $tmp/Kernel.includes.new) do sed -i -E 's/#include <AK\/Debug\.h>/#include <Kernel\/Debug\.h>/' $file done for file in $(cat $tmp/Kernel.includes.mixed) do echo "mixed include in $file, requires manual editing." done
2021-01-25 15:07:10 +00:00
configure_file(Kernel/Debug.h.in Kernel/Debug.h @ONLY)
Everywhere: Use CMake to generate AK/Debug.h. This was done with the help of several scripts, I dump them here to easily find them later: awk '/#ifdef/ { print "#cmakedefine01 "$2 }' AK/Debug.h.in for debug_macro in $(awk '/#ifdef/ { print $2 }' AK/Debug.h.in) do find . \( -name '*.cpp' -o -name '*.h' -o -name '*.in' \) -not -path './Toolchain/*' -not -path './Build/*' -exec sed -i -E 's/#ifdef '$debug_macro'/#if '$debug_macro'/' {} \; done # Remember to remove WRAPPER_GERNERATOR_DEBUG from the list. awk '/#cmake/ { print "set("$2" ON)" }' AK/Debug.h.in
2021-01-23 22:29:11 +00:00
Libraries: Move to Userland/Libraries/
2021-01-12 11:17:30 +00:00
include_directories(Userland/Libraries)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
include_directories(.)
Everywhere: Use CMake to generate AK/Debug.h. This was done with the help of several scripts, I dump them here to easily find them later: awk '/#ifdef/ { print "#cmakedefine01 "$2 }' AK/Debug.h.in for debug_macro in $(awk '/#ifdef/ { print $2 }' AK/Debug.h.in) do find . \( -name '*.cpp' -o -name '*.h' -o -name '*.in' \) -not -path './Toolchain/*' -not -path './Build/*' -exec sed -i -E 's/#ifdef '$debug_macro'/#if '$debug_macro'/' {} \; done # Remember to remove WRAPPER_GERNERATOR_DEBUG from the list. awk '/#cmake/ { print "set("$2" ON)" }' AK/Debug.h.in
2021-01-23 22:29:11 +00:00
include_directories(${CMAKE_BINARY_DIR})
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
add_subdirectory(Meta/Lagom)
DevTools: Move to Userland/DevTools/
2021-01-12 11:18:55 +00:00
add_subdirectory(Userland/DevTools/IPCCompiler)
Libraries: Move to Userland/Libraries/
2021-01-12 11:17:30 +00:00
add_subdirectory(Userland/Libraries/LibWeb/CodeGenerators)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
add_subdirectory(AK/Tests)
Libraries: Move to Userland/Libraries/
2021-01-12 11:17:30 +00:00
add_subdirectory(Userland/Libraries/LibRegex/Tests)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
Build: Support make's and ninja's restat optimization After running a build command, make by default stat()s the command's output, and if it wasn't touched, then it cancels all build steps that were scheduled only because this command was expected to change the output. Ninja has the same feature, but it's opt-in behind the per-command "restat = 1" setting. However, CMake enables it by default for all custom commands. Use Meta/write-only-on-difference.sh to write the output to a temporary file, and then copy the temporary file only to the final location if the contents of the output have changed since last time. write-only-on-difference.sh automatically creates the output's parent directory, so stop doing that in CMake. Reduces the number of build steps that run after touching a file in LibCore from 522 to 312. Since we now no longer trigger the CMake special case "If COMMAND specifies an executable target name (created by the add_executable() command), it will automatically be replaced by the location of the executable created at build time", we now need to use qualified paths to the generators. Somewhat related to #2877.
2020-08-02 13:54:06 +00:00
set(write_if_different ${CMAKE_SOURCE_DIR}/Meta/write-only-on-difference.sh)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
find_program(CCACHE_PROGRAM ccache)
if(CCACHE_PROGRAM)
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
endif()
unset(CMAKE_SYSROOT)
set(CMAKE_STAGING_PREFIX ${CMAKE_BINARY_DIR}/Root)
set(CMAKE_INSTALL_PREFIX ${CMAKE_BINARY_DIR}/Root)
set(CMAKE_INSTALL_DATAROOTDIR ${CMAKE_BINARY_DIR}/Root/res)
Meta: Make it possible to (somewhat) build the system inside Serenity This removes some hard references to the toolchain, some unnecessary uses of an external install command, and disables a -Werror flag (for the time being) - only if run inside serenity. With this, we can build and link the kernel :^)
2021-02-14 21:49:25 +00:00
if (${CMAKE_HOST_SYSTEM_NAME} MATCHES SerenityOS)
message("Good job on building cmake!")
else()
set(TOOLCHAIN_PATH ${CMAKE_SOURCE_DIR}/Toolchain/Local/${SERENITY_ARCH}/bin)
set(TOOLCHAIN_PREFIX ${TOOLCHAIN_PATH}/${SERENITY_ARCH}-pc-serenity-)
set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}gcc)
set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}g++)
set(CMAKE_ASM_COMPILER ${TOOLCHAIN_PREFIX}gcc)
set(CMAKE_LINKER ${TOOLCHAIN_PREFIX}ld)
set(CMAKE_RANLIB ${TOOLCHAIN_PREFIX}ranlib)
set(CMAKE_STRIP ${TOOLCHAIN_PREFIX}strip)
set(CMAKE_AR ${TOOLCHAIN_PREFIX}ar)
endif()
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
Toolchain: Allow building using CMake on macOS
2020-07-08 21:57:51 +00:00
foreach(lang ASM C CXX OBJC OBJCXX)
unset(CMAKE_${lang}_OSX_COMPATIBILITY_VERSION_FLAG)
unset(CMAKE_${lang}_OSX_CURRENT_VERSION_FLAG)
unset(CMAKE_${lang}_LINK_FLAGS)
unset(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS)
unset(CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS)
unset(CMAKE_SHARED_MODULE_LOADER_${lang}_FLAG )
unset(CMAKE_${lang}_OSX_DEPLOYMENT_TARGET_FLAG)
unset(CMAKE_${lang}_SYSROOT_FLAG)
CMake: Only enable "MacOS workaround" on MacOS This was preventing ports from building on Linux.
2021-01-07 10:39:24 +00:00
if (CMAKE_SYSTEM_NAME MATCHES Darwin)
## MacOS Workaround. Don't generate install_name flag when cross compiling
set(CMAKE_${lang}_CREATE_SHARED_LIBRARY
"<CMAKE_${lang}_COMPILER> <LANGUAGE_COMPILE_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS> <LINK_FLAGS> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
endif()
Toolchain: Allow building using CMake on macOS
2020-07-08 21:57:51 +00:00
endforeach()
Meta: Disable rpath generation for MacOS
2020-12-27 23:04:29 +00:00
set(CMAKE_INSTALL_NAME_TOOL "")
Toolchain: Allow building using CMake on macOS
2020-07-08 21:57:51 +00:00
set(CMAKE_SHARED_LIBRARY_SUFFIX ".so")
DynamicLoader+Userland: Enable RELRO for shared libraries as well :^) To support this, I had to reorganize the "load_elf" function into two passes. First we map all the dynamic objects, to get their symbols into the global lookup table. Then we link all the dynamic objects. So many read-only GOT's! :^)
2021-02-18 21:49:58 +00:00
set(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS "-shared -Wl,--hash-style=gnu,-z,relro,-z,now")
LibELF+Userland: Enable RELRO for all userland executables :^) The dynamic loader will now mark RELRO segments read-only after performing relocations. This is pretty cool! Note that this only applies to main executables so far,. RELRO support for shared libraries will require some reorganizing of the dynamic loader.
2021-02-18 17:43:20 +00:00
set(CMAKE_CXX_LINK_FLAGS "-Wl,--hash-style=gnu,-z,relro,-z,now")
Toolchain: Allow building using CMake on macOS
2020-07-08 21:57:51 +00:00
CMake: set CMAKE_SKIP_RPATH everywhere Else, there's tons of "-- Set runtime path of" spam at build time, with apparently no way of disabling the build noise other than turning of rpaths. If the dynamic loader uses them at some point, we probably want to set them through cflags/ldflags instead of through cmake's built-in thing anyways, for that reason.
2021-01-06 23:55:01 +00:00
# We disable it completely because it makes cmake very spammy.
Meta: Disable rpath generation for MacOS
2020-12-27 23:04:29 +00:00
# This will need to be revisited when the Loader supports RPATH/RUN_PATH.
CMake: set CMAKE_SKIP_RPATH everywhere Else, there's tons of "-- Set runtime path of" spam at build time, with apparently no way of disabling the build noise other than turning of rpaths. If the dynamic loader uses them at some point, we probably want to set them through cflags/ldflags instead of through cmake's built-in thing anyways, for that reason.
2021-01-06 23:55:01 +00:00
set(CMAKE_SKIP_RPATH TRUE)
Meta: Disable rpath generation for MacOS
2020-12-27 23:04:29 +00:00
Build: Build Userland with -O2, Kernel with -Os For some reason I don't yet understand, building the kernel with -O2 produces a way-too-large kernel on some people's systems. Since there are some really nice performance benefits from -O2 in userspace, let's do a compromise and build Userland with -O2 but put Kernel back into the -Os box for now.
2021-02-24 10:30:19 +00:00
add_compile_options(-g1 -fno-exceptions -fstack-protector-strong -Wno-address-of-packed-member -Wundef -Wcast-qual -Wwrite-strings -Wimplicit-fallthrough -Wno-nonnull-compare -Wno-deprecated-copy -Wno-expansion-to-defined)
CMake: Use add_compile_options instead of appending to CMAKE_CXX_FLAGS Problem: - Appending to CMAKE_CXX_FLAGS for everything is cumbersome. Solution: - Use the `add_compile_options` built-in function to handle adding compiler options (and even de-duplicating).
2020-12-22 01:04:46 +00:00
add_compile_options(-ffile-prefix-map=${CMAKE_SOURCE_DIR}=.)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
Build: Only use -fstack-clash-protection with GCC This is not yet supported by Clang, so let's disable it for non-GCC compilers for now. (CLion was whining about it.)
2021-02-23 13:15:26 +00:00
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
add_compile_options(-fstack-clash-protection)
endif()
CMake: Use add_compile_options instead of appending to CMAKE_CXX_FLAGS Problem: - Appending to CMAKE_CXX_FLAGS for everything is cumbersome. Solution: - Use the `add_compile_options` built-in function to handle adding compiler options (and even de-duplicating).
2020-12-22 01:04:46 +00:00
add_compile_definitions(DEBUG SANITIZE_PTRS)
Toolchain: Fix usage of libgcc_s & build PIE executables by default We can now build the porst with the shared libraries toolchain.
2020-12-11 13:44:08 +00:00
set(CMAKE_CXX_FLAGS_STATIC "${CMAKE_CXX_FLAGS} -static")
Toolchain+LibC: Fix usage of crt files We now configure the gcc spec files to use a different crt files for static & PIE binaries. This relieves us from the need to explicitly specify the desired crt0 file in cmake scripts.
2020-12-20 20:32:10 +00:00
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pie -fpic")
CMake: Remove some trailing whitespace from a few CMakeLists.txt files
2021-01-01 10:20:55 +00:00
Build: Allow setting DBGLN_NO_COMPILETIME_FORMAT_CHECK via CMake flag
2021-02-08 17:26:28 +00:00
if (DBGLN_NO_COMPILETIME_FORMAT_CHECK)
add_compile_definitions(DBGLN_NO_COMPILETIME_FORMAT_CHECK)
endif()
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
add_link_options(--sysroot ${CMAKE_BINARY_DIR}/Root)
Libraries: Move to Userland/Libraries/
2021-01-12 11:17:30 +00:00
include_directories(Userland/Libraries/LibC)
include_directories(Userland/Libraries/LibM)
Userland: Add LibSystem and funnel all syscalls through it This achieves two things: - Programs can now intentionally perform arbitrary syscalls by calling syscall(). This allows us to work on things like syscall fuzzing. - It restricts the ability of userspace to make syscalls to a single 4KB page of code. In order to call the kernel directly, an attacker must now locate this page and call through it.
2021-02-05 11:16:30 +00:00
include_directories(Userland/Libraries/LibSystem)
Services: Move to Userland/Services/
2021-01-12 11:23:01 +00:00
include_directories(Userland/Services)
Shell: Move to Userland/Shell/
2021-01-12 10:53:14 +00:00
include_directories(Userland)
TextEditor: Move the main window UI to JSON This is our first client of the new JSON GUI declaration thingy. The skeleton of the TextEditor app GUI is now declared separately from the C++ logic, and we use the Core::Object::name() of widgets to locate them once they have been instantiated by the GUI builder.
2020-09-14 10:51:12 +00:00
include_directories(${CMAKE_CURRENT_BINARY_DIR})
Services: Move to Userland/Services/
2021-01-12 11:23:01 +00:00
include_directories(${CMAKE_CURRENT_BINARY_DIR}/Userland/Services)
Libraries: Move to Userland/Libraries/
2021-01-12 11:17:30 +00:00
include_directories(${CMAKE_CURRENT_BINARY_DIR}/Userland/Libraries)
Shell: Move to Userland/Shell/
2021-01-12 10:53:14 +00:00
include_directories(${CMAKE_CURRENT_BINARY_DIR}/Userland)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
Ports: Fix CMake-based ports The SDL port failed to build because the CMake toolchain filed pointed to the old root. Now the toolchain file assumes that the Root is in Build/Root. Additionally, the AK/ and Kernel/ headers need to be installed in the root too.
2020-05-26 18:20:24 +00:00
add_subdirectory(AK)
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
add_subdirectory(Kernel)
add_subdirectory(Userland)
Base: Remove /res/pci.ids and download at build time instead This is an external file from https://pci-ids.ucw.cz that's being updated daily, which was imported a while ago but probably shouldn't live in the SerenityOS repository in the first place (or else would need manual maintenance). The legal aspects of redistributing this file as we currently do are not quite clear to me, they require either GPL (version 2 or later) or 3-clause BSD - Serenity is 2-clause BSD... The current version we use is 2019.08.08, so quite outdated - and while most of these devices are obviously not supported, we're still capable of *listing* them, so having an up-to-date version with recent additions and fixes would be nice. This updates the root CMakeLists.txt to check for existence of the file and download it if not found - effectively on every fresh build. Do note that this is not a critical file, and the system runs just fine should this ever fail. :^)
2021-02-06 23:52:40 +00:00
set(PCI_IDS_URL https://pci-ids.ucw.cz/v2.2/pci.ids)
set(PCI_IDS_PATH ${CMAKE_INSTALL_DATAROOTDIR}/pci.ids)
if(NOT EXISTS ${PCI_IDS_PATH})
message(STATUS "Downloading PCI ID database from ${PCI_IDS_URL}...")
file(DOWNLOAD ${PCI_IDS_URL} ${PCI_IDS_PATH} INACTIVITY_TIMEOUT 10)
endif()
Reference in New Issue Copy Permalink