beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 15:40:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Meta/Lagom/CMakeLists.txt

731 lines
28 KiB
Text
Raw Normal View History

CMake: Bump CMake minimum up to 3.21 to work around CLion bug Fix the recursive directory bug in CLion Nova EAP's CMake version in a way that doesn't also break `./Meta/serenity.sh run lagom ladybird`. This brings the Lagom minimum required closer to the Serenity minimum required. Which is still fine, because the serenity.sh script knows how to build CMake from source if a developer's local copy is too old.
2023-11-10 08:09:55 +00:00
cmake_minimum_required (VERSION 3.21)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
project(
Lagom
VERSION 0.0.0
DESCRIPTION "Host build of SerenityOS libraries and applications"
HOMEPAGE_URL "https://github.com/SerenityOS/serenity"
LANGUAGES C CXX
)
Lagom: Import the beginnings of a "port" of Serenity libs for the outside. The C++ facilities of Serenity are getting pretty comfortable, and I'd like to take them with me to projects outside the system. Let's make it a bit easier to do that by bundling AK and LibCore (for now) into a portable library called "Lagom". :^)
2019-07-25 09:56:08 +00:00
Lagom: Update GCC version check in CMakeLists.txt This was forgotten in bc2ebcadc0eb695605051c9d362c3f5dc184c63c.
2022-10-31 14:08:39 +00:00
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "12")
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
message(FATAL_ERROR
Lagom: Update GCC version check in CMakeLists.txt This was forgotten in bc2ebcadc0eb695605051c9d362c3f5dc184c63c.
2022-10-31 14:08:39 +00:00
"A GCC version less than 12 was detected (${CMAKE_CXX_COMPILER_VERSION}), this is unsupported.\n"
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
"Please re-read the build instructions documentation, and upgrade your host compiler.\n")
Meta: Add BUILD_SHARED_LIBS option for Lagom builds This standard CMake option controls whether add_library() calls will use STATIC or SHARED by default. The flag is set to on by default since that's what we want for normal CI jobs and local builds and the test262 runner, but disabled for oss-fuzz builds. This should finally fix the oss-fuzz build after it was broken in #9017 oss-fuzz un-breakage was verified by running the following commands in the oss-fuzz repo: python infra/helper.py build_image serenity python infra/helper.py build_fuzzers --sanitizer address --engine afl \ --architecture x86_64 serenity /path/to/local/checkout/Meta/Lagom python infra/helper.py check_build --sanitizer address --engine afl \ --architecture x86_64 serenity
2021-08-01 10:37:28 +00:00
endif()
Meta: Add LibUnicode (and its tests) to Lagom This is primarily to allow using LibUnicode within LibJS and its REPL. Note: this seems to be the first time that a Lagom dependency requires generated source files. For this to work, some of Lagom's CMakeLists.txt commands needed to be re-organized to include the CMake files that fetch and parse UnicodeData.txt. The paths required to invoke the generator also differ depending on what is currently building (SerenityOS vs. Lagom as part of the Serenity build vs. a standalone Lagom build).
2021-07-25 19:15:47 +00:00
# This is required for CMake (when invoked for a Lagom-only build) to
# ignore any files downloading during the build, e.g. UnicodeData.txt.
# https://cmake.org/cmake/help/latest/policy/CMP0058.html
cmake_policy(SET CMP0058 NEW)
Meta: Link Lagom with LLD by default and allow configuring the linker This ports over the `LADYBIRD_USE_LLD` option from the standalone Ladybird build and generalizes it to work for mold as well: the `LAGOM_USE_LINKER` variable can be set to the desired name of the linker. If it's empty, we default to trying LLD and Mold on ELF platforms (in this order).
2023-09-05 05:40:57 +00:00
# Make CMAKE_EXE_LINKER_FLAGS have an effect on `try_compile()` jobs.
# This is required if we want to have the `LAGOM_USE_LINKER` option
# take effect in `check_linker_flag` checks.
cmake_policy(SET CMP0056 NEW)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
get_filename_component(
SERENITY_PROJECT_ROOT "${PROJECT_SOURCE_DIR}/../.."
ABSOLUTE CACHE
)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
set(SerenityOS_SOURCE_DIR "${SERENITY_PROJECT_ROOT}" CACHE STRING "")
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Meta: Add Meta/CMake to the CMAKE_MODULE_PATH for Serenity and Lagom This makes it so we don't need to specify the full path to all the helper scripts we include() from different places in the codebase and feels a lot cleaner.
2021-09-07 07:50:09 +00:00
list(APPEND CMAKE_MODULE_PATH "${SERENITY_PROJECT_ROOT}/Meta/CMake")
Meta: Move all options to targetname_options.cmake files This common strategy of having a serenity_option() macro defined in either the Lagom or top level CMakeLists.txt allows us to do two things: First, we can more clearly see which options are Serenity-specific, Lagom-specific, or common between the target and host builds. Second, it enables the upcoming SuperBuild changes to set() the options in the SuperBuild's CMake cache and forward each target's options to the corresponding ExternalProject.
2021-09-07 08:08:54 +00:00
if(NOT COMMAND serenity_option)
macro(serenity_option)
set(${ARGV})
endmacro()
endif()
Meta: Error out on find_program errors with CMake less than 3.18 We have seen some cases where the build fails for folks, and they are missing unzip/tar/gzip etc. We can catch some of these in CMake itself, so lets make sure to handle that uniformly across the build system. The REQUIRED flag to `find_program` was only added on in CMake 3.18 and above, so we can't rely on that to actually halt the program execution.
2022-03-18 11:31:36 +00:00
include(check_for_dependencies)
Meta: Link Lagom with LLD by default and allow configuring the linker This ports over the `LADYBIRD_USE_LLD` option from the standalone Ladybird build and generalizes it to work for mold as well: the `LAGOM_USE_LINKER` variable can be set to the desired name of the linker. If it's empty, we default to trying LLD and Mold on ELF platforms (in this order).
2023-09-05 05:40:57 +00:00
include(use_linker)
CMake: Pass NO_POLICY_SCOPE to options cmake helpers Tell CMake to not create a new policy scope for the (lagom|serenity|common)_options.cmake helpers, and lets us set common policies for both projects in common_options.cmake that actually apply to the rest of the project, instead of just common_options.cmake itself.
2022-12-14 01:57:01 +00:00
include(lagom_options NO_POLICY_SCOPE)
Meta: Move all options to targetname_options.cmake files This common strategy of having a serenity_option() macro defined in either the Lagom or top level CMakeLists.txt allows us to do two things: First, we can more clearly see which options are Serenity-specific, Lagom-specific, or common between the target and host builds. Second, it enables the upcoming SuperBuild changes to set() the options in the SuperBuild's CMake cache and forward each target's options to the corresponding ExternalProject.
2021-09-07 08:08:54 +00:00
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
if(ENABLE_ALL_THE_DEBUG_MACROS)
include(all_the_debug_macros)
endif()
Lagom: Add option to build Ladybird as part of a Lagom build This means that Ladybird can be built with either Meta/Lagom or Ladybird as the top-level source directory. This setup is a bit awkward, but will preserve the packaging story for Ladybird until we come up with a more permanent solution.
2022-12-23 18:36:45 +00:00
# FIXME: Is it worth inventing `serenity_dependent_option` ?
if (ENABLE_LAGOM_LADYBIRD)
set(ENABLE_LAGOM_LIBWEB ON CACHE BOOL "" FORCE)
endif()
Meta: Add FIXME for not setting BUILD_SHARED_LIBS in Lagom build This is really the business of the consuming project. We will need to make changes to libjs-test262 and to oss-fuzz to address this properly.
2021-09-07 00:06:46 +00:00
# FIXME: BUILD_SHARED_LIBS has a default of OFF, as it's intended to be set by the
Meta: Define LagomMain outside of the BUILD_LAGOM branch This allows code generators to use LagomMain. Otherwise, during CI, they are built during the superbuild without BUILD_LAGOM=ON.
2021-11-23 17:34:31 +00:00
# user when configuring the project. We should instead change libjs-test262
Meta: Add FIXME for not setting BUILD_SHARED_LIBS in Lagom build This is really the business of the consuming project. We will need to make changes to libjs-test262 and to oss-fuzz to address this properly.
2021-09-07 00:06:46 +00:00
# and oss-fuzz to set this option on their end, and enable it by default in
Lagom: Add two-stage build for Fuzzers to enable fuzzing generated code This allows us to fuzz the generated unicode and timezone database helpers, and to fuzz things like LibJS using Fuzzilli to get proper coverage of our unicode handling code. Update the Azure CI to use the new two-stage build as well, and cleanup some unused CMake options there.
2022-02-19 23:09:40 +00:00
# Meta/serenity.sh. This is #9867.
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
option(BUILD_SHARED_LIBS "Build shared libraries instead of static libraries" ON)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
find_package(Threads REQUIRED)
Meta/Lagom: Link Threads::Threads This is required for me to be able to build both Serenity and Ladybird from the same repo. Without this the two builds seem to stomp on each other, then fail to link.
2023-01-05 14:47:27 +00:00
# FIXME: This global link libraries is required to workaround linker issues (on some systems)
# from the Ladybird import. See https://github.com/SerenityOS/serenity/issues/16847
link_libraries(Threads::Threads)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Meta: Semi-automatically detect ccache for Lagom builds The top-level CMakeLists.txt already automatically detects ccache, but CI will invoke CMake with Lagom's CMakeLists.txt. Add an option to Lagom to do the same detection.
2021-08-17 02:10:34 +00:00
if (ENABLE_LAGOM_CCACHE)
Meta: Separate ccache setup into its own component
2022-12-06 21:57:20 +00:00
include(setup_ccache)
Meta: Semi-automatically detect ccache for Lagom builds The top-level CMakeLists.txt already automatically detects ccache, but CI will invoke CMake with Lagom's CMakeLists.txt. Add an option to Lagom to do the same detection.
2021-08-17 02:10:34 +00:00
endif()
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
if (ENABLE_FUZZERS_LIBFUZZER OR ENABLE_FUZZERS_OSSFUZZ)
set(ENABLE_FUZZERS ON)
endif()
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
# We need to make sure not to build code generators for Fuzzer builds, as they already have their own main.cpp
# Instead, we import them from a previous install of Lagom. This mandates a two-stage build for fuzzers.
# The same concern goes for cross-compile builds, where we need the tools built for the host
set(BUILD_LAGOM_TOOLS ON)
if (ENABLE_FUZZERS OR CMAKE_CROSSCOMPILING)
find_package(LagomTools REQUIRED)
set(BUILD_LAGOM_TOOLS OFF)
endif()
Meta+Tests: Allow running FLAC spec tests The FLAC "spec tests", or rather the test suite by xiph that exercises weird FLAC features and edge cases, can be found at https://github.com/ietf-wg-cellar/flac-test-files and is a good challenge for our FLAC decoder to become more spec compliant. Running these tests is similar to LibWasm spec tests, you need to pass INCLUDE_FLAC_SPEC_TESTS to CMake. As of integrating these tests, 23 out of 63 fail. :yakplus:
2022-07-25 11:28:16 +00:00
include(flac_spec_tests)
Meta: Move compiler flags into standalone CMake files This way we can have all of them in a single place, similar to how we structure options added via the serenity_option() macro.
2022-05-14 13:07:12 +00:00
include(lagom_compile_options)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Lagom: Enable compile_commands.json for the lagom build directory This allows a developer who only wants to look at Lagom to have their IDE find source files and headers properly.
2022-10-17 05:55:04 +00:00
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
Everywhere: Add support for compilation under emscripten Co-Authored-By: Andrew Kaster <akaster@serenityos.org>
2022-11-20 03:23:14 +00:00
if (EMSCRIPTEN)
set(CMAKE_EXECUTABLE_SUFFIX ".js")
add_compile_options(-gsource-map)
add_link_options(--emrun "SHELL:-s ALLOW_MEMORY_GROWTH")
endif()
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
if (ENABLE_ADDRESS_SANITIZER)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=address")
endif()
Lagom: Add clang address/memory/undefined-behavior analyzer support Adding the ability to turn on Clang analyzer support in the Lagom build. Right now the following are working warning free on the LibJS test suite: -DENABLE_MEMORY_SANITIZER:BOOL=ON -DENABLE_ADDRESS_SANITIZER:BOOL=ON The following analyzer produces errors when running the LibJS test suite: -DENABLE_UNDEFINED_SANITIZER:BOOL=ON
2020-04-05 10:21:03 +00:00
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
if (ENABLE_MEMORY_SANITIZER)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
add_compile_options(-fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer)
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=memory -fsanitize-memory-track-origins")
endif()
Lagom: Add clang address/memory/undefined-behavior analyzer support Adding the ability to turn on Clang analyzer support in the Lagom build. Right now the following are working warning free on the LibJS test suite: -DENABLE_MEMORY_SANITIZER:BOOL=ON -DENABLE_ADDRESS_SANITIZER:BOOL=ON The following analyzer produces errors when running the LibJS test suite: -DENABLE_UNDEFINED_SANITIZER:BOOL=ON
2020-04-05 10:21:03 +00:00
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
if (ENABLE_UNDEFINED_SANITIZER)
Meta: Enable vptr sanitation by default for Lagom UBSAN builds
2022-09-14 20:33:46 +00:00
add_compile_options(-fsanitize=undefined -fno-omit-frame-pointer)
CMake: Add `UNDEFINED_BEHAVIOR_IS_FATAL` configure option This is mainly intended for use on CI, as UBSan instrumentation results in a serious load and execution time penalty there. See the previous commit for more details. With this enabled, the size of LibWeb, built for x86-64 with Clang 17 as of 0b91d36a is reduced as follows: FILE SIZE VM SIZE -------------- -------------- +18% +2.99Mi [ = ] 0 .debug_info +14% +758Ki [ = ] 0 .debug_addr +2.6% +7.92Ki [ = ] 0 .debug_abbrev +129% +2.66Ki [ = ] 0 [Unmapped] -0.2% -208 -0.2% -208 .plt -0.2% -312 -0.2% -312 .rela.plt -0.1% -336 -0.1% -336 .dynsym -0.0% -647 -0.0% -513 [8 Others] -0.1% -1.14Ki -0.1% -1.14Ki .dynstr -20.1% -53.5Ki -20.1% -53.5Ki .eh_frame_hdr -7.2% -56.8Ki [ = ] 0 .debug_str_offsets -7.1% -156Ki [ = ] 0 .debug_str -15.0% -160Ki [ = ] 0 .symtab -63.6% -245Ki -63.6% -245Ki .relr.dyn -25.4% -357Ki -25.4% -357Ki .eh_frame -27.7% -1.09Mi [ = ] 0 .strtab -59.3% -10.0Mi [ = ] 0 .debug_rnglists -41.3% -11.0Mi [ = ] 0 .debug_line -70.0% -12.0Mi -70.0% -12.0Mi .rodata -65.2% -15.1Mi -65.2% -15.1Mi .data -53.0% -15.7Mi -53.0% -15.7Mi .text -41.7% -62.1Mi -57.7% -43.4Mi TOTAL
2023-08-12 13:39:22 +00:00
if (UNDEFINED_BEHAVIOR_IS_FATAL)
add_compile_options(-fno-sanitize-recover=undefined)
endif()
Meta: Disable -fsanitize=function on macOS with clang 17 or higher This seems to trip on calling file static functions through a function pointer directly. Still need to reduce and report upstream.
2023-12-19 22:41:57 +00:00
if (APPLE AND CMAKE_CXX_COMPILER_ID MATCHES "Clang$" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "17")
add_compile_options(-fno-sanitize=function)
endif()
Meta: Enable vptr sanitation by default for Lagom UBSAN builds
2022-09-14 20:33:46 +00:00
set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=undefined")
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
endif()
Lagom: Add clang address/memory/undefined-behavior analyzer support Adding the ability to turn on Clang analyzer support in the Lagom build. Right now the following are working warning free on the LibJS test suite: -DENABLE_MEMORY_SANITIZER:BOOL=ON -DENABLE_ADDRESS_SANITIZER:BOOL=ON The following analyzer produces errors when running the LibJS test suite: -DENABLE_UNDEFINED_SANITIZER:BOOL=ON
2020-04-05 10:21:03 +00:00
Meta: Support enabling compile-time format string checking on Lagom
2023-07-05 19:01:56 +00:00
if (ENABLE_COMPILETIME_FORMAT_CHECK)
add_compile_definitions(ENABLE_COMPILETIME_FORMAT_CHECK)
endif()
Meta+Ladybird: Add some extra definitions for Haiku
2023-08-27 18:53:47 +00:00
if (HAIKU)
# Haiku needs some extra compile definitions to make important stuff in its headers available.
add_compile_definitions(_DEFAULT_SOURCE)
add_compile_definitions(_GNU_SOURCE)
add_compile_definitions(__USE_GNU)
endif()
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
if (ENABLE_FUZZERS)
add_compile_options(-fno-omit-frame-pointer)
endif()
Lagom: Add option to build Ladybird as part of a Lagom build This means that Ladybird can be built with either Meta/Lagom or Ladybird as the top-level source directory. This setup is a bit awkward, but will preserve the packaging story for Ladybird until we come up with a more permanent solution.
2022-12-23 18:36:45 +00:00
if (ENABLE_LAGOM_LADYBIRD AND (ENABLE_FUZZERS OR ENABLE_COMPILER_EXPLORER_BUILD))
message(FATAL_ERROR
"Ladybird build not supported for Fuzzers or Compiler Explorer."
"Disable ENABLE_LAGOM_LADYBIRD and try again."
)
endif()
LibAudio: Create a playback class with a PulseAudio implementation This adds an abstract `Audio::PlaybackStream` class to allow cross- platform audio playback to be done in an opaque manner by applications in both Serenity and Lagom. Currently, the only supported audio API is PulseAudio, but a Serenity implementation should be added shortly as well.
2023-07-04 09:55:53 +00:00
CHECK_INCLUDE_FILE(pulse/pulseaudio.h HAVE_PULSEAUDIO)
Lagom: Add ClangPlugins to the build system
2024-04-16 01:50:49 +00:00
add_library(JSClangPlugin INTERFACE)
add_library(GenericClangPlugin INTERFACE)
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang$")
Meta: Move more common flags to common_compile_options.cmake For the most part no behavior change, except that we now pass -Wno-implicit-const-int-float-conversion and -Wno-literal-suffix only to clang and gcc each in both lagom and serenity builds, while we previously passed them to both in lagom builds (and passed them to one each in serenity builds). The former is a clang flag, the latter a gcc flag, but since we also use -Wno-unknown-warning-option it doesn't really matter.
2023-04-17 23:50:53 +00:00
add_compile_options(-Wno-overloaded-virtual)
Lagom: Disable the unused-private-field warning on Lagom's clang builds With the compilation of LibWeb, there's now quite a few cases where this warning gets triggered. Rather than trying to fix them all right away, we simply disable the warning for now. This workaround was proposed by Andrew Kaster and BertalanD who promised to open an issue about it!
2022-04-30 18:04:30 +00:00
# FIXME: Re-enable this check when the warning stops triggering, or document why we can't stop it from triggering.
# For now, there is a lot of unused private fields in LibWeb that trigger this that could be removed.
# See issue #14137 for details
add_compile_options(-Wno-unused-private-field)
Lagom: Add clang address/memory/undefined-behavior analyzer support Adding the ability to turn on Clang analyzer support in the Lagom build. Right now the following are working warning free on the LibJS test suite: -DENABLE_MEMORY_SANITIZER:BOOL=ON -DENABLE_ADDRESS_SANITIZER:BOOL=ON The following analyzer produces errors when running the LibJS test suite: -DENABLE_UNDEFINED_SANITIZER:BOOL=ON
2020-04-05 10:21:03 +00:00
Meta: Rename Fuzzer flags to `ENABLE_FUZZERS_{LIBFUZZER,OSSFUZZ}`
2022-03-29 14:31:51 +00:00
if (ENABLE_FUZZERS_LIBFUZZER)
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
add_compile_options(-fsanitize=fuzzer)
Lagom: Use -fsanitize=fuzzer, not -fsanitize=fuzzer-no-link Fuzzers don't link for me without this change.
2020-11-13 20:47:32 +00:00
set(LINKER_FLAGS "${LINKER_FLAGS} -fsanitize=fuzzer")
Lagom: Add fuzz testing for LibJS using libFuzzer (#1692) Note: clang only (see https://llvm.org/docs/LibFuzzer.html) - add FuzzJs which will run the LibJS parser on random javascript inputs - added a basic dictionary of javascript tokens To use fuzzer: CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -DENABLE_FUZZER_SANITIZER=1 .. Fuzzers/FuzzJs -dict=../Fuzzers/FuzzJs.dict
2020-04-08 08:40:02 +00:00
endif()
CMake: Export targets for Clang Plugins so they can be used by Serenity
2024-05-14 00:25:47 +00:00
# Vanilla host builds only for building the clang plugins
if (ENABLE_CLANG_PLUGINS AND NOT CROSS_COMPILING AND NOT ENABLE_FUZZERS AND NOT ENABLE_COMPILER_EXPLORER_BUILD)
Lagom: Add ClangPlugins to the build system
2024-04-16 01:50:49 +00:00
add_subdirectory(ClangPlugins)
depend_on_clang_plugin(JSClangPlugin LibJSGCClangPlugin)
depend_on_clang_plugin(GenericClangPlugin LambdaCaptureClangPlugin)
endif()
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
Meta: Rename Fuzzer flags to `ENABLE_FUZZERS_{LIBFUZZER,OSSFUZZ}`
2022-03-29 14:31:51 +00:00
if (ENABLE_FUZZERS_LIBFUZZER)
Lagom: Add two-stage build for Fuzzers to enable fuzzing generated code This allows us to fuzz the generated unicode and timezone database helpers, and to fuzz things like LibJS using Fuzzilli to get proper coverage of our unicode handling code. Update the Azure CI to use the new two-stage build as well, and cleanup some unused CMake options there.
2022-02-19 23:09:40 +00:00
message(FATAL_ERROR
"Fuzzer Sanitizer (-fsanitize=fuzzer) is only supported for Fuzzer targets with LLVM. "
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
"Reconfigure CMake with -DCMAKE_C_COMPILER and -DCMAKE_CXX_COMPILER pointing to a clang-based toolchain "
"or build binaries without built-in fuzzing support by setting -DENABLE_FUZZERS instead."
Lagom: Add two-stage build for Fuzzers to enable fuzzing generated code This allows us to fuzz the generated unicode and timezone database helpers, and to fuzz things like LibJS using Fuzzilli to get proper coverage of our unicode handling code. Update the Azure CI to use the new two-stage build as well, and cleanup some unused CMake options there.
2022-02-19 23:09:40 +00:00
)
endif()
Lagom: Let's not hard-code the compiler. Add compiler-relevant flags though. I'm still getting the hang of this CMake thing.
2019-07-26 09:02:47 +00:00
endif()
Lagom: Import the beginnings of a "port" of Serenity libs for the outside. The C++ facilities of Serenity are getting pretty comfortable, and I'd like to take them with me to projects outside the system. Let's make it a bit easier to do that by bundling AK and LibCore (for now) into a portable library called "Lagom". :^)
2019-07-25 09:56:08 +00:00
Lagom: Enable sanitizer builds with gcc Previously the CMake options for -fsanitize=address, thread and undefined were gated behind clang, which was unecessary. Only -fsanitize=fuzzer is clang-only.
2021-05-12 11:49:19 +00:00
# These are here to support Fuzzili builds further down the directory stack
set(ORIGINAL_CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
set(ORIGINAL_CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
set(ORIGINAL_CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
configure_file(../../AK/Debug.h.in AK/Debug.h @ONLY)
Meta: Add LibUnicode (and its tests) to Lagom This is primarily to allow using LibUnicode within LibJS and its REPL. Note: this seems to be the first time that a Lagom dependency requires generated source files. For this to work, some of Lagom's CMakeLists.txt commands needed to be re-organized to include the CMake files that fetch and parse UnicodeData.txt. The paths required to invoke the generator also differ depending on what is currently building (SerenityOS vs. Lagom as part of the Serenity build vs. a standalone Lagom build).
2021-07-25 19:15:47 +00:00
include_directories(../../)
include_directories(../../Userland/)
include_directories(../../Userland/Libraries/)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
include_directories(../../Userland/Services)
Meta: Add LibUnicode (and its tests) to Lagom This is primarily to allow using LibUnicode within LibJS and its REPL. Note: this seems to be the first time that a Lagom dependency requires generated source files. For this to work, some of Lagom's CMakeLists.txt commands needed to be re-organized to include the CMake files that fetch and parse UnicodeData.txt. The paths required to invoke the generator also differ depending on what is currently building (SerenityOS vs. Lagom as part of the Serenity build vs. a standalone Lagom build).
2021-07-25 19:15:47 +00:00
include_directories(${CMAKE_BINARY_DIR})
include_directories(${CMAKE_CURRENT_BINARY_DIR})
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
include_directories(${CMAKE_CURRENT_BINARY_DIR}/Userland/Libraries)
include_directories(${CMAKE_CURRENT_BINARY_DIR}/Userland/Services)
Meta: Add LibUnicode (and its tests) to Lagom This is primarily to allow using LibUnicode within LibJS and its REPL. Note: this seems to be the first time that a Lagom dependency requires generated source files. For this to work, some of Lagom's CMakeLists.txt commands needed to be re-organized to include the CMake files that fetch and parse UnicodeData.txt. The paths required to invoke the generator also differ depending on what is currently building (SerenityOS vs. Lagom as part of the Serenity build vs. a standalone Lagom build).
2021-07-25 19:15:47 +00:00
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
# install rules, think about moving to its own helper cmake file
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
include(CMakePackageConfigHelpers)
# find_package(<package>) call for consumers to find this project
Meta: Add Android cross-compile support to Lagom This is a start to properly letting us cross-compile Lagom where both the Tools and the BUILD_LAGOM=ON build are using Lagom CMakeLists. The initial cut allows an Android build to succeed, more or less. But there are issues with namespace clashes when using FetchContent with this approach.
2022-07-11 07:07:47 +00:00
set(package Lagom CACHE STRING "")
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
# Allow package maintainers to freely override the path for the configs
set(Lagom_INSTALL_CMAKEDIR "${CMAKE_INSTALL_DATADIR}/${package}"
CACHE PATH "CMake package config location relative to the install prefix")
mark_as_advanced(Lagom_INSTALL_CMAKEDIR)
install(
Meta: Update jakt build support for fully bootstrapped compiler Remove the Corrosion dependency, and use the now-builtin add_jakt_executable function from the Jakt install rules to build our example application. By using find_package(Jakt), we now have to set ENABLE_JAKT manually on both serenity and Lagom at the same time, so the preferred method to do this for now is: cmake -B Build/superbuild<arch><toolchain> \ -S Meta/CMake/Superbuild \ -DENABLE_JAKT=ON \ -DJAKT_SOURCE_DIR=/path/to/jakt Where omitting JAKT_SOURCE_DIR will still pull from the main branch of SerenityOS/jakt. This can be done after runing Meta/serenity.sh run.
2022-08-28 23:47:03 +00:00
FILES "${SERENITY_PROJECT_ROOT}/Meta/CMake/lagom-install-config.cmake"
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
DESTINATION "${Lagom_INSTALL_CMAKEDIR}"
Meta: Update jakt build support for fully bootstrapped compiler Remove the Corrosion dependency, and use the now-builtin add_jakt_executable function from the Jakt install rules to build our example application. By using find_package(Jakt), we now have to set ENABLE_JAKT manually on both serenity and Lagom at the same time, so the preferred method to do this for now is: cmake -B Build/superbuild<arch><toolchain> \ -S Meta/CMake/Superbuild \ -DENABLE_JAKT=ON \ -DJAKT_SOURCE_DIR=/path/to/jakt Where omitting JAKT_SOURCE_DIR will still pull from the main branch of SerenityOS/jakt. This can be done after runing Meta/serenity.sh run.
2022-08-28 23:47:03 +00:00
RENAME "${package}Config.cmake"
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
COMPONENT Lagom_Development
)
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
install(
EXPORT LagomTargets
NAMESPACE Lagom::
DESTINATION "${Lagom_INSTALL_CMAKEDIR}"
COMPONENT Lagom_Development
)
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
Lagom: Make lagom_lib take names prefixed with Lib This matches serenity_lib, and consolidates the logic to strip Lib from the front of the library name for the Lagom export name into one place at the top of lagom_lib.
2022-10-17 05:48:14 +00:00
function(lagom_lib target_name fs_name)
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
cmake_parse_arguments(LAGOM_LIBRARY "" "LIBRARY_TYPE" "SOURCES;LIBS" ${ARGN})
Lagom: Make lagom_lib take names prefixed with Lib This matches serenity_lib, and consolidates the logic to strip Lib from the front of the library name for the Lagom export name into one place at the top of lagom_lib.
2022-10-17 05:48:14 +00:00
string(REPLACE "Lib" "" library ${target_name})
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
if (NOT LAGOM_LIBRARY_LIBRARY_TYPE)
set(LAGOM_LIBRARY_LIBRARY_TYPE "")
Lagom: Link LibMain statically This matches how LibMain is used within Serenity. This commit makes it possible to build Lagom with LTO. Previously, `serenity_main` functions would be dead-stripped away, as the linker could prove that nothing from the executable ever called them.
2022-10-01 14:08:26 +00:00
endif()
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
add_library(${target_name} ${LAGOM_LIBRARY_LIBRARY_TYPE} ${LAGOM_LIBRARY_SOURCES})
Lagom: Add proper install rules Create the proper export files to allow Lagom to be a well-behaved ExternalProject, based on the example project from the cmake-init project generator here: https://github.com/friendlyanon/cmake-init-shared-static
2021-07-28 00:22:12 +00:00
set_target_properties(
${target_name} PROPERTIES
VERSION "${PROJECT_VERSION}"
SOVERSION "${PROJECT_VERSION_MAJOR}"
EXPORT_NAME ${library}
OUTPUT_NAME lagom-${fs_name}
)
Everywhere: Mark dependencies of most targets as PRIVATE Otherwise, we end up propagating those dependencies into targets that link against that library, which creates unnecessary link-time dependencies. Also included are changes to readd now missing dependencies to tools that actually need them.
2022-10-21 19:43:56 +00:00
target_link_libraries(${target_name} PRIVATE ${LAGOM_LIBRARY_LIBS})
Lagom: Add ClangPlugins to the build system
2024-04-16 01:50:49 +00:00
target_link_libraries(${target_name} PUBLIC GenericClangPlugin)
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
if (NOT "${target_name}" STREQUAL "AK")
target_link_libraries(${target_name} PRIVATE AK)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
endif()
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
Lagom: Include all generated installed files on library targets Do this with INSTALL_INTERFACE genex include directory rules. We should really standardize where the generated headers *actually* get installed to though.
2023-10-04 01:20:14 +00:00
# FIXME: Clean these up so that we don't need so many include dirs
target_include_directories(${target_name} INTERFACE
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/Services>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/Userland/Libraries>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/Userland/Services>
)
CMake: Export targets for Clang Plugins so they can be used by Serenity
2024-05-14 00:25:47 +00:00
add_lagom_library_install_rules(${target_name} ALIAS_NAME ${library})
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
# FIXME: Move this to serenity_install_headers
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
install(
DIRECTORY "${SERENITY_PROJECT_ROOT}/Userland/Libraries/Lib${library}"
COMPONENT Lagom_Development
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
FILES_MATCHING PATTERN "*.h"
)
Lagom+CMake: Propagate dependencies for generated custom targets We have logic for serenity_generated_sources which works well for source files that are specified in GENERATED_SOURCES prior to calling serenity_lib or serenity_bin. However, code generated with invoke_generator, and the LibWeb generators do not always follow the pattern of the IDL and GML files. For the LibWeb generators, we can just add_dependencies to LibWeb at the time we declare the generate_Foo custom target. However for LibLocale, LibTimeZone, and LibUnicode, we don't have the name of the target available, so export the name in a variable to set into GENERATED_SOURCES. To make this work for Lagom, we need to make sure that lagom_lib and serenity_bin in Lagom/CMakeLists.txt call serenity_generated_sources on the target. This enables the Xcode generator on macOS hosts, at least for Lagom.
2022-10-17 05:49:52 +00:00
serenity_generated_sources(${target_name})
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
endfunction()
function(lagom_test source)
Meta: Add option to specify custom test names for Lagom
2023-10-27 05:59:58 +00:00
cmake_parse_arguments(LAGOM_TEST "" "NAME;WORKING_DIRECTORY" "LIBS" ${ARGN})
if (NOT DEFINED LAGOM_TEST_NAME)
get_filename_component(LAGOM_TEST_NAME ${source} NAME_WE)
endif()
add_executable(${LAGOM_TEST_NAME} ${source})
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
target_link_libraries(${LAGOM_TEST_NAME} PRIVATE AK LibCore LibFileSystem LibTest LibTestMain ${LAGOM_TEST_LIBS})
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
add_test(
Meta: Add option to specify custom test names for Lagom
2023-10-27 05:59:58 +00:00
NAME ${LAGOM_TEST_NAME}
COMMAND ${LAGOM_TEST_NAME}
Meta: Set the Lagom test working directory for run-lagom-target When we call add_test() from each test's CMakeLists.txt, we specify the working directory to be that of the CMakeList.txt file itself. Create a property to store that directory and reference it when run-lagom-target is invoked by serenity.sh. Note that for non-test Lagom targets which do not set this property, the working directory will be Build/lagom (because the property will be the empty string, which CMake resolves relative to the current build path).
2023-02-01 13:36:15 +00:00
WORKING_DIRECTORY ${LAGOM_TEST_WORKING_DIRECTORY}
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
)
Meta: Add option to specify custom test names for Lagom
2023-10-27 05:59:58 +00:00
set_target_properties(${LAGOM_TEST_NAME} PROPERTIES LAGOM_WORKING_DIRECTORY "${LAGOM_TEST_WORKING_DIRECTORY}")
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
endfunction()
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
function(lagom_utility name)
cmake_parse_arguments(LAGOM_UTILITY "" "" "SOURCES;LIBS" ${ARGN})
add_executable("${name}" ${LAGOM_UTILITY_SOURCES})
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
target_link_libraries("${name}" PRIVATE AK LibCore ${LAGOM_UTILITY_LIBS})
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
endfunction()
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
function(serenity_test test_src sub_dir)
cmake_parse_arguments(PARSE_ARGV 2 SERENITY_TEST "MAIN_ALREADY_DEFINED" "CUSTOM_MAIN" "LIBS")
# FIXME: Pass MAIN_ALREADY_DEFINED and CUSTOM_MAIN to support tests that use them.
lagom_test(${test_src} LIBS ${SERENITY_TEST_LIBS} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
endfunction()
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
function(serenity_bin name)
add_executable(${name} ${SOURCES} ${GENERATED_SOURCES})
add_executable(Lagom::${name} ALIAS ${name})
Lagom: Add ClangPlugins to the build system
2024-04-16 01:50:49 +00:00
target_link_libraries(${name} PUBLIC GenericClangPlugin)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
install(
TARGETS ${target_name}
EXPORT LagomTargets
RUNTIME #
COMPONENT Lagom_Runtime
LIBRARY #
COMPONENT Lagom_Runtime
NAMELINK_COMPONENT Lagom_Development
ARCHIVE #
COMPONENT Lagom_Development
INCLUDES #
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
Lagom+CMake: Propagate dependencies for generated custom targets We have logic for serenity_generated_sources which works well for source files that are specified in GENERATED_SOURCES prior to calling serenity_lib or serenity_bin. However, code generated with invoke_generator, and the LibWeb generators do not always follow the pattern of the IDL and GML files. For the LibWeb generators, we can just add_dependencies to LibWeb at the time we declare the generate_Foo custom target. However for LibLocale, LibTimeZone, and LibUnicode, we don't have the name of the target available, so export the name in a variable to set into GENERATED_SOURCES. To make this work for Lagom, we need to make sure that lagom_lib and serenity_bin in Lagom/CMakeLists.txt call serenity_generated_sources on the target. This enables the Xcode generator on macOS hosts, at least for Lagom.
2022-10-17 05:49:52 +00:00
serenity_generated_sources(${name})
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
endfunction()
function(serenity_lib name fs_name)
Meta: Allow specifying the library type when invoking serenity_lib() This will allow creating object libraries with this function.
2024-03-26 14:01:36 +00:00
cmake_parse_arguments(PARSE_ARGV 2 SERENITY_LIB "" "TYPE" "")
lagom_lib(${name} ${fs_name} LIBRARY_TYPE ${SERENITY_LIB_TYPE} SOURCES ${SOURCES} ${GENERATED_SOURCES})
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
endfunction()
function(serenity_install_headers dir)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
endfunction()
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
function(serenity_install_sources dir)
endfunction()
macro(add_serenity_subdirectory path)
add_subdirectory("${SERENITY_PROJECT_ROOT}/${path}" "${CMAKE_CURRENT_BINARY_DIR}/${path}")
endmacro()
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
add_custom_target(components ALL)
option(BUILD_EVERYTHING "Build all optional components" ON)
LibTimeZone+Meta: Add plumbing for an IANA Time Zone Database generator The IANA Time Zone Database contains data needed, at least, for various JavaScript objects. This adds plumbing for a parser and code generator for this data. The generated data will be made available by LibTimeZone, much like how UCD and CLDR data is available through LibUnicode.
2021-12-22 21:33:38 +00:00
if (NOT TARGET all_generated)
# Meta target to run all code-gen steps in the build.
add_custom_target(all_generated)
endif()
CMake: Export targets for Clang Plugins so they can be used by Serenity
2024-05-14 00:25:47 +00:00
# Plugins need to be installed in order to be used by non-lagom builds
add_lagom_library_install_rules(GenericClangPlugin)
add_lagom_library_install_rules(JSClangPlugin)
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
# Create mostly empty targets for system libraries we don't need to build for Lagom
add_library(LibC INTERFACE)
add_library(LibCrypt INTERFACE)
Lagom: Link the system's LibSystem on SerenityOS
2022-10-23 22:05:33 +00:00
add_library(LibSystem INTERFACE)
Meta: Don't link LibCrypt to native libcrypt on Haiku
2023-08-27 18:58:53 +00:00
if (NOT APPLE AND NOT ANDROID AND NOT EMSCRIPTEN AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD" AND NOT HAIKU)
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
target_link_libraries(LibCrypt INTERFACE crypt) # LibCore::Account uses crypt() but it's not in libcrypt on macOS
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
endif()
Lagom: Link the system's LibSystem on SerenityOS
2022-10-23 22:05:33 +00:00
if (SERENITYOS)
# Serenity only allows syscalls from LibSystem, so if someone asks for that on Lagom,
# we need to pass that through to the system's LibSystem.
target_link_libraries(LibSystem INTERFACE system)
endif()
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
add_library(NoCoverage INTERFACE)
# "install" these special targets to placate CMake
Lagom: Link the system's LibSystem on SerenityOS
2022-10-23 22:05:33 +00:00
install(TARGETS LibC LibCrypt LibSystem NoCoverage EXPORT LagomTargets)
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
# AK
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
add_serenity_subdirectory(AK)
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
lagom_lib(AK ak SOURCES ${AK_SOURCES})
Meta: Use ```find_package``` for configuring backtraces
2024-05-28 08:01:28 +00:00
find_package(Backtrace)
if (Backtrace_FOUND AND NOT "${Backtrace_LIBRARIES}" STREQUAL "")
target_link_libraries(AK PRIVATE ${Backtrace_LIBRARIES})
target_include_directories(AK PRIVATE ${Backtrace_INCLUDE_DIRS})
Meta: Link AK to libexecinfo on BSDs and Haiku This requirement was missed when AK was split into its own library in 5945cdc054e603214e9aeea9221888d523506c83
2024-02-26 22:50:11 +00:00
endif()
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
LibURL+LibUnicode+LibWebView: Handle punycode directly in LibURL We had defined punycode handling in LibUnicode when LibURL (AK at the time) was unable to depend on LibUnicode. This is no longer the case.
2024-03-25 14:57:36 +00:00
add_serenity_subdirectory(Userland/Libraries/LibUnicode)
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 03:22:27 +00:00
add_serenity_subdirectory(Userland/Libraries/LibURL)
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
# LibCore
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
add_serenity_subdirectory(Userland/Libraries/LibCore)
Everywhere: Mark dependencies of most targets as PRIVATE Otherwise, we end up propagating those dependencies into targets that link against that library, which creates unnecessary link-time dependencies. Also included are changes to readd now missing dependencies to tools that actually need them.
2022-10-21 19:43:56 +00:00
target_link_libraries(LibCore PRIVATE Threads::Threads)
LibCore: Add support for NetBSD in anon_create
2023-02-20 15:29:50 +00:00
if (${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
# NetBSD has its shm_open and shm_unlink functions in librt so we need to link that
target_link_libraries(LibCore PRIVATE librt.so)
endif()
Meta: Link to libnsl and libsocket on Solaris in Lagom CMakeLists
2023-02-25 18:10:57 +00:00
if (${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
# Solaris has socket and networking related functions in two extra libraries
target_link_libraries(LibCore PRIVATE nsl socket)
endif()
Meta+Ladybird: Link to libnetwork on Haiku
2023-08-27 18:57:10 +00:00
if (HAIKU)
# Haiku has networking related functions in the network library
target_link_libraries(LibCore PRIVATE network)
endif()
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 03:22:27 +00:00
target_link_libraries(LibCore PRIVATE LibURL)
Lagom: Import the beginnings of a "port" of Serenity libs for the outside. The C++ facilities of Serenity are getting pretty comfortable, and I'd like to take them with me to projects outside the system. Let's make it a bit easier to do that by bundling AK and LibCore (for now) into a portable library called "Lagom". :^)
2019-07-25 09:56:08 +00:00
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
# LibMain
Lagom+LibCore: Build LibCore, AK, and LibMain with add_subdirectory By deferring to the CMakeLists in each of these libraries' directories, we can get rid of a lot of curious GLOB patterns and list removals in the Lagom CMakeLists.
2022-10-13 20:07:09 +00:00
add_serenity_subdirectory(Userland/Libraries/LibMain)
Meta: Define LagomMain outside of the BUILD_LAGOM branch This allows code generators to use LagomMain. Otherwise, during CI, they are built during the superbuild without BUILD_LAGOM=ON.
2021-11-23 17:34:31 +00:00
Everywhere: Use `LibFileSystem` where trivial
2023-03-21 15:35:30 +00:00
# LibFileSystem
# This is needed even if Lagom is not enabled because it is depended upon by code generators.
add_serenity_subdirectory(Userland/Libraries/LibFileSystem)
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
# LibTimeZone
LibTimeZone+Meta: Add plumbing for an IANA Time Zone Database generator The IANA Time Zone Database contains data needed, at least, for various JavaScript objects. This adds plumbing for a parser and code generator for this data. The generated data will be made available by LibTimeZone, much like how UCD and CLDR data is available through LibUnicode.
2021-12-22 21:33:38 +00:00
# This is needed even if Lagom is not enabled because it is depended upon by code generators.
Meta: Use add_serenity_directory for LibTimeZone This lets us eliminate the "meta prefix" for the LibTimeZone generators.
2022-10-13 21:54:06 +00:00
add_serenity_subdirectory(Userland/Libraries/LibTimeZone)
# We need an install rule for LibTimeZone b/c it is a manual OBJECT library instead of serenity_lib
install(TARGETS LibTimeZone EXPORT LagomTargets)
LibTimeZone+Meta: Add plumbing for an IANA Time Zone Database generator The IANA Time Zone Database contains data needed, at least, for various JavaScript objects. This adds plumbing for a parser and code generator for this data. The generated data will be made available by LibTimeZone, much like how UCD and CLDR data is available through LibUnicode.
2021-12-22 21:33:38 +00:00
LibIDL+WrapperGenerator: Move IDL code into a library IDL function overload resolution requires knowing each IDL function's parameters and their types at runtime. The simplest way to do that is just to make the types the generator uses available to the runtime. Parsing has moved to LibIDL, but code generation has not, since that is very specific to WrapperGenerator.
2022-08-22 13:50:06 +00:00
# LibIDL
Everywhere: Rename WrapperGenerator to BindingsGenerator This code generator no longer creates JS wrappers for platform objects in the old sense, instead they're JS objects internally themselves. Most of what we generate now are prototypes - which can be seen as bindings for the internal C++ methods implementing getters, setters, and methods - as well as object constructors, i.e. bindings for the internal create_with_global_object() method. Also tweak the naming of various CMake glue code existing around this.
2022-09-21 17:22:16 +00:00
# This is used by the BindingsGenerator so needs to always be built.
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
add_serenity_subdirectory(Userland/Libraries/LibIDL)
LibIDL+WrapperGenerator: Move IDL code into a library IDL function overload resolution requires knowing each IDL function's parameters and their types at runtime. The simplest way to do that is just to make the types the generator uses available to the runtime. Parsing has moved to LibIDL, but code generation has not, since that is very specific to WrapperGenerator.
2022-08-22 13:50:06 +00:00
Meta+Userland: Allow generating C++ initializer code from GML This does the exact same thing as the runtime initializer, except it is faster and can catch some errors much earlier. The code generator includes these important features: - Automatic include generation where necessary - Special-casing for TabWidget and ScrollableContainerWidget - No use of DeprecatedString where possible
2023-08-11 13:16:51 +00:00
# LibGUI - only GML
# This is used by the GML compiler and therefore always needed.
set(LIBGUI_GML_SOURCES
GML/Lexer.cpp
GML/Parser.cpp
)
list(TRANSFORM LIBGUI_GML_SOURCES PREPEND "${SERENITY_PROJECT_ROOT}/Userland/Libraries/LibGUI/")
lagom_lib(LibGUI_GML gui_gml
SOURCES ${LIBGUI_GML_SOURCES}
)
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
# Manually install AK headers
install(
DIRECTORY "${SERENITY_PROJECT_ROOT}/AK"
COMPONENT Lagom_Development
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
FILES_MATCHING PATTERN "*.h"
)
CMake: Make sure to install generated sources and header files We weren't installing a lot of generated sources for the top level Lagom build or for LibWeb, making it impossible to use LibWeb from a find_package. ...And also Kernel/API/KeyCode.h, which is included by no less than 8 different files in Userland/Libraries. We also weren't installing any Ladybird header files.
2023-08-08 04:14:22 +00:00
install(FILES
${Lagom_BINARY_DIR}/AK/Debug.h
COMPONENT Lagom_Development
DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/AK"
)
Meta: Switch to a SuperBuild that splits host and target builds Replace the old logic where we would start with a host build, and swap all the CMake compiler and target variables underneath it to trick CMake into building for Serenity after we configured and built the Lagom code generators. The SuperBuild creates two ExternalProjects, one for Lagom and one for Serenity. The Serenity project depends on the install stage for the Lagom build. The SuperBuild also generates a CMakeToolchain file for the Serenity build to use that replaces the old toolchain file that was only used for Ports. To ensure that code generators are rebuilt when core libraries such as AK and LibCore are modified, developers will need to direct their manual `ninja` invocations to the SuperBuild's binary directory instead of the Serenity binary directory. This commit includes warning coalescing and option style cleanup for the affected CMakeLists in the Kernel, top level, and runtime support libraries. A large part of the cleanup is replacing USE_CLANG_TOOLCHAIN with the proper CMAKE_CXX_COMPILER_ID variable, which will no longer be confused by a host clang compiler.
2021-09-07 08:21:36 +00:00
Everywhere: Move all host tools into the Lagom/Tools subdirectory This allows us to remove all the add_subdirectory calls from the top level CMakeLists.txt that referred to targets linking LagomCore. Segregating the host tools and Serenity targets helps us get to a place where the main Serenity build can simply use a CMake toolchain file rather than swapping all the compiler/sysroot variables after building host libraries and tools.
2021-08-08 07:31:23 +00:00
# Code Generators and other host tools
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
if (BUILD_LAGOM_TOOLS)
Everywhere: Move all host tools into the Lagom/Tools subdirectory This allows us to remove all the add_subdirectory calls from the top level CMakeLists.txt that referred to targets linking LagomCore. Segregating the host tools and Serenity targets helps us get to a place where the main Serenity build can simply use a CMake toolchain file rather than swapping all the compiler/sysroot variables after building host libraries and tools.
2021-08-08 07:31:23 +00:00
add_subdirectory(Tools)
endif()
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
if (BUILD_LAGOM)
Meta: Create Build/lagom/Root/res with resources for lagom binaries This way, build files can install things into `${CMAKE_BINARY_DIR}/Root/res/` and it'll work in both serenity and lagom builds. It allows using a single `Core::ResourceImplementation::install()` call to install both checked-in and generated files (as long as both get copied into this new build-time staging dir). No behavior change.
2024-01-30 14:24:31 +00:00
# Create lagom equivalent of Serenity's Build/foo/Root/res (which for Serenity becomes /res in the disk image).
# FIXME: Add more files as needed.
set(LAGOM_RES "${Lagom_BINARY_DIR}/Root/res")
file(MAKE_DIRECTORY "${LAGOM_RES}/fonts")
foreach(font
LiberationMono-Bold.ttf
LiberationMono-BoldItalic.ttf
LiberationMono-Italic.ttf
LiberationMono-Regular.ttf
LiberationSans-Bold.ttf
LiberationSans-BoldItalic.ttf
LiberationSans-Italic.ttf
LiberationSans-Regular.ttf
LiberationSerif-Bold.ttf
LiberationSerif-BoldItalic.ttf
LiberationSerif-Italic.ttf
LiberationSerif-Regular.ttf
)
configure_file("${SERENITY_PROJECT_ROOT}/Base/res/fonts/${font}" "${LAGOM_RES}/fonts/${font}" COPYONLY)
endforeach()
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# Lagom Libraries
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
set(lagom_standard_libraries
LibWeb: Add painting command executor that uses LibAccelGfx This change introduces a command executor for RecordingPainter that utilizes LibAccelGfx.
2023-10-27 15:14:27 +00:00
AccelGfx
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
Archive
Audio
Compress
Meta: Build LibCpp for Lagom
2023-06-17 19:11:06 +00:00
Cpp
Meta: Remove SerenityOS components not needed for Ladybird
2024-05-30 19:19:35 +00:00
Crypto
headless-browser: Print a diff when a test failure occurs This will make it a lot easier to understand what went wrong, especially when the failure occurs on CI but not at home. And of course, use LibDiff to generate the diff! :^)
2023-05-28 18:55:32 +00:00
Diff
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
Gemini
Gfx
GL
LibGLSL: Add LibGLSL This adds a new library, LibGLSL for parsing and compiling GLSL programs to LibGPU IR. Currently the compiler consists only of stubs.
2022-08-28 17:23:30 +00:00
GLSL
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
GPU
HTTP
Lagom: Port LibImageDecoderClient to Lagom This library offers tools to communicate with an ImageDecoder server through IPC. There is currently no such executable for Lagom but that shouldn't take long :^)
2023-09-20 13:19:25 +00:00
ImageDecoderClient
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
IPC
LibJIT+LibJS: Move JIT::Assembler into a new LibJIT library This will allow other parts of the system to generate machine code at runtime. :^)
2023-10-26 13:18:28 +00:00
JIT
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
JS
Line
Locale
Markdown
PDF
Ladybird: Add RequestServer process to optionally replace Qt Networking LibTLS still can't access many parts of the web, so let's hide this behind a flag (with all the plumbing that entails). Hopefully this can encourage folks to improve LibTLS's algorithm support :^).
2023-08-01 20:39:19 +00:00
Protocol
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
Regex
LibAudio+LibRIFF: Move general RIFF handling to LibRIFF This splits the RIFFTypes header/TU into the WAV specific parts, which move to WavTypes.h, as well as the general RIFF parts which move to the new LibRIFF. Sidenote for the spec comments: even though they are linked from a site that explains the WAV format, the document is the (an) overall RIFF spec from Microsoft. A better source may be used later; the changes to the header are as minimal as possible.
2023-10-12 13:02:39 +00:00
RIFF
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
SoftGPU
SQL
Syntax
TextCodec
Threading
TLS
Video
Wasm
WebSocket
XML
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
)
Meta: Fix ENABLE_LAGOM_LIBWEB CMake configuration
2023-08-12 16:01:28 +00:00
# These are needed for both LibWeb and LibProtocol.
Meta: Replace Lagom's LibWebView setup with LibWebView's CMakeLists.txt This lets us add new sources to LibWebView in a single location.
2023-08-30 11:27:45 +00:00
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/RequestServer/RequestClient.ipc Userland/Services/RequestServer/RequestClientEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/RequestServer/RequestServer.ipc Userland/Services/RequestServer/RequestServerEndpoint.h)
Meta: Fix ENABLE_LAGOM_LIBWEB CMake configuration
2023-08-12 16:01:28 +00:00
Meta: Add Lagom option to disable building LibWeb Compiling LibWeb for Lagom can add quite a bit of compile time. Add a CMake option to disable it locally.
2022-09-12 19:35:54 +00:00
if (ENABLE_LAGOM_LIBWEB)
Meta: Replace Lagom's LibWebView setup with LibWebView's CMakeLists.txt This lets us add new sources to LibWebView in a single location.
2023-08-30 11:27:45 +00:00
list(APPEND lagom_standard_libraries Web WebView)
LibWebView: Allow using native/user style sheets on Lagom Move the methods to set the native/user style sheets to the base ViewImplementation class. We must also generate the native style sheet explicitly for now, as LibWebView on Lagom isn't able to include the main LibWebView CMakeLists.txt file yet.
2023-08-26 17:34:59 +00:00
Meta: Replace Lagom's LibWebView setup with LibWebView's CMakeLists.txt This lets us add new sources to LibWebView in a single location.
2023-08-30 11:27:45 +00:00
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebContent/WebContentServer.ipc Userland/Services/WebContent/WebContentServerEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebContent/WebContentClient.ipc Userland/Services/WebContent/WebContentClientEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebContent/WebDriverClient.ipc Userland/Services/WebContent/WebDriverClientEndpoint.h)
compile_ipc(${SERENITY_PROJECT_ROOT}/Userland/Services/WebContent/WebDriverServer.ipc Userland/Services/WebContent/WebDriverServerEndpoint.h)
Meta: Hide WebView behind ENABLE_LAGOM_LIBWEB CMake option If ENABLE_LAGOM_LIBWEB is OFF, this will fail to build.
2022-10-06 12:09:45 +00:00
endif()
Lagom: Build DOMTreeModel from LibWebView This will be used in Ladybird.
2022-09-25 10:10:28 +00:00
Lagom: Build LibELF on arm64 This seems to build fine now on Arm Macs.
2023-02-25 04:35:31 +00:00
if (NOT EMSCRIPTEN)
Meta: Use stripped-down version of LibELF on Lagom
2024-04-24 20:29:08 +00:00
list(APPEND lagom_standard_libraries ELF X86)
Lagom: Exclude libraries with X86 code when building for macOS on Arm The CMakeLists.txt for Lagom contains a few libraries and executables with X86-specific code. By excluding those libraries, Lagom builds for macOS on Arm as well. The places are marked FIXME to be removed when the libraries will build for Arm.
2022-01-17 23:54:36 +00:00
endif()
Lagom: Add a Shell parser fuzzer
2020-11-29 12:49:13 +00:00
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
foreach(lib IN LISTS lagom_standard_libraries)
add_serenity_subdirectory("Userland/Libraries/Lib${lib}")
endforeach()
CMake: Make sure to install generated sources and header files We weren't installing a lot of generated sources for the top level Lagom build or for LibWeb, making it impossible to use LibWeb from a find_package. ...And also Kernel/API/KeyCode.h, which is included by no less than 8 different files in Userland/Libraries. We also weren't installing any Ladybird header files.
2023-08-08 04:14:22 +00:00
# FIXME: How about we don't include Kernel/API from random high-level libraries?
install(FILES ${SERENITY_PROJECT_ROOT}/Kernel/API/KeyCode.h DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/Kernel/API")
Everywhere: Mark dependencies of most targets as PRIVATE Otherwise, we end up propagating those dependencies into targets that link against that library, which creates unnecessary link-time dependencies. Also included are changes to readd now missing dependencies to tools that actually need them.
2022-10-21 19:43:56 +00:00
target_link_libraries(LibLocale PRIVATE LibTimeZone)
CMake+Userland: Use CMakeLists from Userland to build Lagom Libraries Also do this for Shell. This greatly simplifies the CMakeLists in Lagom, replacing many glob patterns with a big list of libraries. There are still a few special libraries that need some help to conform to the pattern, like LibELF and LibWebView. It also lets us remove essentially all of the Serenity or Lagom binary directory detection logic from code generators, as now both projects directories enter the generator logic from the same place.
2022-10-14 02:14:36 +00:00
AK+Lagom: Make it possible to build for iOS This commit makes it possible to build AK and most of Lagom for iOS, based on the work for the Ladybird build demoed on discord: https://discord.com/channels/830522505605283862/830525031720943627/1211987732646068314
2024-02-27 13:32:29 +00:00
if (NOT ENABLE_FUZZERS AND NOT ENABLE_COMPILER_EXPLORER_BUILD AND NOT ANDROID AND NOT IOS)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# Lagom Utilities
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
lagom_utility(abench SOURCES ../../Userland/Utilities/abench.cpp LIBS LibMain LibFileSystem LibAudio)
lagom_utility(aconv SOURCES ../../Userland/Utilities/aconv.cpp LIBS LibMain LibFileSystem LibAudio)
Meta: Add aconv as a Lagom tool
2023-05-01 19:14:44 +00:00
LibGfx+Utilities: Add `animation` utility, make it write animated webps The high-level design is that we have a static method on WebPWriter that returns an AnimationWriter object. AnimationWriter has a virtual method for writing individual frames. This allows streaming animations to disk, without having to buffer up the entire animation in memory first. The semantics of this function, add_frame(), are that data is flushed to disk every time the function is called, so that no explicit `close()` method is needed. For some formats that store animation length at the start of the file, including WebP, this means that this needs to write to a SeekableStream, so that add_frame() can seek to the start and update the size when a frame is written. This design should work for GIF and APNG writing as well. We can move AnimationWriter to a new header if we add writers for these. Currently, `animation` can read any animated image format we can read (apng, gif, webp) and convert it to an animated webp file. The written animated webp file is not compressed whatsoever, so this creates large output files at the moment.
2024-05-06 21:44:57 +00:00
lagom_utility(animation SOURCES ../../Userland/Utilities/animation.cpp LIBS LibGfx LibMain)
Lagom: Build `file` in lagom builds
2023-02-25 04:36:02 +00:00
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
lagom_utility(gzip SOURCES ../../Userland/Utilities/gzip.cpp LIBS LibCompress LibMain)
Meta: Add "gunzip" and "gzip" to lagom build This makes it easy to compare the performance of Serenity's deflate implementation to the host system implementation. On my M1 Max MBP: % time gunzip -c \ /Users/thakis/Downloads/trace_bug.json.gz > /dev/null takes between 0.064s and 0.082s. % time Build/lagom/gunzip -c \ /Users/thakis/Downloads/trace_bug.json.gz > /dev/null on the other hand takes 4 seconds. (That .gz file is a 5.8M file -- the largest .gz file that happend to be in my Downloads folder.)
2023-03-25 17:04:22 +00:00
CMake: Bump CMake minimum up to 3.21 to work around CLion bug Fix the recursive directory bug in CLion Nova EAP's CMake version in a way that doesn't also break `./Meta/serenity.sh run lagom ladybird`. This brings the Lagom minimum required closer to the Serenity minimum required. Which is still fine, because the serenity.sh script knows how to build CMake from source if a developer's local copy is too old.
2023-11-10 08:09:55 +00:00
# Work around bug in JetBrains distributed CMake 3.27.2 where this causes infinite recursion in
# export_components() when called from CLion Nova by checking if we already have Ladybird included
# This technically breaks people including Lagom as a submodule and wanting Ladybird targets, but... who? why?
if (ENABLE_LAGOM_LADYBIRD AND PROJECT_IS_TOP_LEVEL)
Meta+CI: Disable Ladybird for fuzzer, compiler explorer and Android And move it after the declaration of headless-browser, since WebDriver depends on headless-browser.
2023-02-02 10:57:06 +00:00
add_serenity_subdirectory(Ladybird)
endif()
MacPDF: Make buildable from CMake Use `Meta/serenity.sh build lagom MacPDF` to build, and either of `open Build/lagom/bin/MacPDF.app` or `Build/lagom/bin/MacPDF.app/Contents/MacOS/MacPDF` to run. Xcode used to insert a bunch of things to Info.plist. Now it can no longer do that, so manually put them there
2023-09-29 23:59:22 +00:00
if (APPLE)
add_serenity_subdirectory(Meta/Lagom/Contrib/MacPDF)
endif()
Meta: Silence warnings from optional CMake packages These can be quite verbose on the command line if the packages aren't found. As they do not break the build, let's not spam warnings. The OpenGL package is also now skipped on macOS, where there's no point in looking for the package anyways.
2023-11-28 03:00:43 +00:00
find_package(SDL2 QUIET)
if (SDL2_FOUND)
Meta: Add a minimal SDL2 based videoplayer for Lagom
2023-11-20 14:05:58 +00:00
add_serenity_subdirectory(Meta/Lagom/Contrib/VideoPlayerSDL)
endif()
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 03:22:27 +00:00
lagom_utility(icc SOURCES ../../Userland/Utilities/icc.cpp LIBS LibGfx LibMain LibURL)
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
lagom_utility(image SOURCES ../../Userland/Utilities/image.cpp LIBS LibGfx LibMain)
lagom_utility(isobmff SOURCES ../../Userland/Utilities/isobmff.cpp LIBS LibGfx LibMain)
lagom_utility(ttfdisasm SOURCES ../../Userland/Utilities/ttfdisasm.cpp LIBS LibGfx LibMain)
lagom_utility(js SOURCES ../../Userland/Utilities/js.cpp LIBS LibCrypto LibJS LibLine LibLocale LibMain LibTextCodec Threads::Threads)
LibGfx: Add initial ISO BMFF parsing and a utility to print file info Currently, the `isobmff` utility will only print the media file type info from the FileTypeBox (major brand and compatible brands), as well as the names and sizes of top-level boxes.
2023-02-18 23:46:27 +00:00
Meta: Add a js REPL wasm target ...and build it only with emscripten.
2022-11-20 03:23:41 +00:00
if (EMSCRIPTEN)
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
lagom_utility(libjs SOURCES Wasm/js_repl.cpp LIBS LibJS LibLocale LibTimeZone LibUnicode)
Meta: Add a js REPL wasm target ...and build it only with emscripten.
2022-11-20 03:23:41 +00:00
target_link_options(libjs PRIVATE
-sEXPORTED_FUNCTIONS=_initialize_repl,_execute
-sEXPORTED_RUNTIME_METHODS=allocateUTF8
-sERROR_ON_UNDEFINED_SYMBOLS=0
-sENVIRONMENT=web)
endif()
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
lagom_utility(lzcat SOURCES ../../Userland/Utilities/lzcat.cpp LIBS LibCompress LibMain)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
lagom_utility(pdf SOURCES ../../Userland/Utilities/pdf.cpp LIBS LibGfx LibPDF LibMain)
lagom_utility(sql SOURCES ../../Userland/Utilities/sql.cpp LIBS LibFileSystem LibIPC LibLine LibMain LibSQL)
lagom_utility(tar SOURCES ../../Userland/Utilities/tar.cpp LIBS LibArchive LibCompress LibFileSystem LibMain)
lagom_utility(test262-runner SOURCES ../../Tests/LibJS/test262-runner.cpp LIBS LibJS LibFileSystem)
LibJS: Import the libjs-test262-runner from linusg/libjs-test262 For now this is a lagom only application as it is not compatible with serenity in its current state. The only change is that it is released under a different license with permission from all the authors.
2022-09-11 07:14:32 +00:00
Meta+test262-runner: Check for signature of __assert_fail in CMake Rather than trying to assume the only two C libraries on Linux are musl and glibc, this solution fixes musl builds by explicitly checking for the one C library function we are overwriting. That being said, we should find another solution to retrieving this error information from crashing tests. Possibly just overriding the SIGABRT handler would work. The full solution might require checking stderr as well as stdout in the test driver though.
2022-12-18 16:07:15 +00:00
if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
include(CheckCSourceCompiles)
# Check for musl's declaration of __assert_fail
check_c_source_compiles(
"
#include <assert.h>
__attribute__((__noreturn__)) void __assert_fail(char const* assertion, char const* file, int line, char const* function) {}
int main() {}
"
ASSERT_FAIL_HAS_INT
)
endif()
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
Meta+test262-runner: Check for signature of __assert_fail in CMake Rather than trying to assume the only two C libraries on Linux are musl and glibc, this solution fixes musl builds by explicitly checking for the one C library function we are overwriting. That being said, we should find another solution to retrieving this error information from crashing tests. Possibly just overriding the SIGABRT handler would work. The full solution might require checking stderr as well as stdout in the test driver though.
2022-12-18 16:07:15 +00:00
if (ASSERT_FAIL_HAS_INT OR EMSCRIPTEN)
target_compile_definitions(test262-runner PRIVATE ASSERT_FAIL_HAS_INT)
endif()
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
lagom_utility(wasm SOURCES ../../Userland/Utilities/wasm.cpp LIBS LibFileSystem LibWasm LibLine LibMain LibJS)
AK+LibURL: Move AK::URL into a new URL library This URL library ends up being a relatively fundamental base library of the system, as LibCore depends on LibURL. This change has two main benefits: * Moving AK back more towards being an agnostic library that can be used between the kernel and userspace. URL has never really fit that description - and is not used in the kernel. * URL _should_ depend on LibUnicode, as it needs punnycode support. However, it's not really possible to do this inside of AK as it can't depend on any external library. This change brings us a little closer to being able to do that, but unfortunately we aren't there quite yet, as the code generators depend on LibCore.
2024-03-18 03:22:27 +00:00
lagom_utility(xml SOURCES ../../Userland/Utilities/xml.cpp LIBS LibFileSystem LibMain LibXML LibURL)
Meta: Add a helper to create a Lagom utility This helper can automatically link against libraries needed by all utilities, such as LibCore. This is to make extracting AK into its own library a bit easier.
2024-01-21 23:22:51 +00:00
lagom_utility(xzcat SOURCES ../../Userland/Utilities/xzcat.cpp LIBS LibCompress LibMain)
Lagom: Add targets for `lzcat`, `xzcat` and `tar`
2023-03-28 23:38:54 +00:00
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
enable_testing()
# LibTest
file(GLOB LIBTEST_SOURCES CONFIGURE_DEPENDS "../../Userland/Libraries/LibTest/*.cpp")
list(FILTER LIBTEST_SOURCES EXCLUDE REGEX ".*Main.cpp$")
add_library(
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
LibTest
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
${LIBTEST_SOURCES}
)
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
target_link_libraries(LibTest PRIVATE AK LibCore LibFileSystem)
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
set_target_properties(LibTest PROPERTIES OUTPUT_NAME lagom-test)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
add_library(
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
LibTestMain
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
OBJECT
"${SERENITY_PROJECT_ROOT}/Userland/Libraries/LibTest/TestMain.cpp"
)
Lagom: Add ClangPlugins to the build system
2024-04-16 01:50:49 +00:00
target_link_libraries(LibTest PUBLIC GenericClangPlugin)
target_link_libraries(LibTestMain PUBLIC GenericClangPlugin)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# LibTest tests from Tests/
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
set(TEST_DIRECTORIES
AK
JSSpecCompiler: Add regression test runner
2023-10-27 06:00:08 +00:00
JSSpecCompiler
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
LibCrypto
LibCompress
LibGL
Meta: Build and run Tests/LibGfx in lagom builds They can be run using Meta/serenity.sh test lagom TestFontHandling which will build _all_ test binaries and then run TestFontHandling. There's also Meta/serenity.sh run lagom TestFontHandling which will build just TestFontHandling and run it, but currently in a way that it doesn't pass. Finally, manually doing Meta/serenity.sh build lagom TestFontHandling followed by (cd Tests/LibGfx; ../../Build/lagom/Tests/LibGfx/TestFontHandling) will build and then run just that one test in a way that makes the test pass.
2023-01-31 19:00:43 +00:00
LibGfx
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
LibLocale
LibMarkdown
LibPDF
LibSQL
LibTest: Add a suite of tests for the generators
2023-10-23 23:47:26 +00:00
LibTest
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
LibTextCodec
LibTTF
LibTimeZone
LibUnicode
LibVideo
Meta: Test LibXML on Lagom
2023-07-23 04:14:21 +00:00
LibXML
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
)
if (ENABLE_LAGOM_LIBWEB)
list(APPEND TEST_DIRECTORIES LibWeb)
Tests: Don't include LibWebView test if LibWeb is disabled This unbreaks ENABLE_LAGOM_LIBWEB=OFF again.
2023-11-24 15:51:35 +00:00
list(APPEND TEST_DIRECTORIES LibWebView)
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
endif()
Lagom: Add ClangPlugins to the build system
2024-04-16 01:50:49 +00:00
if (ENABLE_CLANG_PLUGINS AND CMAKE_CXX_COMPILER_ID MATCHES "Clang$")
list(APPEND TEST_DIRECTORIES ClangPlugins)
endif()
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
foreach (dir IN LISTS TEST_DIRECTORIES)
add_serenity_subdirectory("Tests/${dir}")
Meta+Tests: Allow running FLAC spec tests The FLAC "spec tests", or rather the test suite by xiph that exercises weird FLAC features and edge cases, can be found at https://github.com/ietf-wg-cellar/flac-test-files and is a good challenge for our FLAC decoder to become more spec compliant. Running these tests is similar to LibWasm spec tests, you need to pass INCLUDE_FLAC_SPEC_TESTS to CMake. As of integrating these tests, 23 out of 63 fail. :yakplus:
2022-07-25 11:28:16 +00:00
endforeach()
Meta: Download cacert.pem at build time
2023-03-14 13:12:58 +00:00
# LibTLS needs a special working directory to find cacert.pem
lagom_test(../../Tests/LibTLS/TestTLSHandshake.cpp LibTLS LIBS LibTLS LibCrypto)
LibTLS: Implement ASN.1 parser function for PrivateKeyInfo LibWeb wants to parse these for Web Crypto. In theory Certificate parsing in LibTLS should use it as well.
2024-03-15 03:55:47 +00:00
lagom_test(../../Tests/LibTLS/TestTLSCertificateParser.cpp LibTLS LIBS LibTLS LibCrypto)
Meta: Download cacert.pem at build time
2023-03-14 13:12:58 +00:00
Meta: Specify a working directory for the FLAC spec test on Lagom The serenity_test function cannot set this up as it has no purpose on Serenity itself.
2023-03-14 18:52:16 +00:00
# The FLAC tests need a special working directory to find the test files
lagom_test(../../Tests/LibAudio/TestFLACSpec.cpp LIBS LibAudio WORKING_DIRECTORY "${FLAC_TEST_PATH}/..")
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 06:59:47 +00:00
lagom_test(../../Tests/LibAudio/TestPlaybackStream.cpp LIBS LibAudio)
if (HAVE_PULSEAUDIO)
target_compile_definitions(TestPlaybackStream PRIVATE HAVE_PULSEAUDIO=1)
endif()
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
# LibCore
AK: Update OptionParser::m_arg_index by substracting skipped args On argument swapping to put positional ones toward the end, m_arg_index was pointing at "last arg index" + "skipped args" + "consumed args" and thus was pointing ahead of the skipped ones. m_arg_index now points after the current parsed option arguments.
2024-02-05 20:47:09 +00:00
lagom_test(../../Tests/LibCore/TestLibCoreArgsParser.cpp)
LibCore: Implement FileWatcher for macOS The macOS FileWatcher depends on macOS dispatch queues, which run on a different thread than the Core::EventLoop. This implementation handles filesystem events on its dispatch queue, then forwards the event back to the main Core::EventLoop for notifying the FileWatcher owner.
2023-01-18 19:03:14 +00:00
if ((LINUX OR APPLE) AND NOT EMSCRIPTEN)
LibCore: Implement FileWatcher for Linux This implements FileWatcher using inotify filesystem events. Serenity's InodeWatcher is remarkably similar to inotify, so this is almost an identical implementation. The existing TestLibCoreFileWatcher test is added to Lagom (currently just for Linux). This does not implement BlockingFileWatcher as that is currently not used anywhere but on Serenity.
2023-01-17 19:43:36 +00:00
lagom_test(../../Tests/LibCore/TestLibCoreFileWatcher.cpp)
LibCore: Add a class for thread-safe promises Since the existing Promise class is designed with deferred tasks on the main thread only, we need a new class that will ensure we can handle promises that are resolved/rejected off the main thread. This new class ensures that the callbacks are only called on the same thread that the promise is fulfilled from. If the callbacks are not set before the thread tries to fulfill the promise, it will spin until they are so that they will run on that thread.
2023-07-12 01:48:56 +00:00
lagom_test(../../Tests/LibCore/TestLibCorePromise.cpp LIBS LibThreading)
LibCore: Implement FileWatcher for Linux This implements FileWatcher using inotify filesystem events. Serenity's InodeWatcher is remarkably similar to inotify, so this is almost an identical implementation. The existing TestLibCoreFileWatcher test is added to Lagom (currently just for Linux). This does not implement BlockingFileWatcher as that is currently not used anywhere but on Serenity.
2023-01-17 19:43:36 +00:00
endif()
LibCore+LibTimeZone: Support time zone names in Core::DateTime::parse LibCore currently cannot depend on LibTimeZone directly. All build-time code generators depend on LibCore, so there'd be a circular dependency: LibCore -> LibTimeZone -> GenerateTZData -> LibCore. So to support parsing time zone names and applying their offsets, add a couple of weakly-defined helper functions. These work similar to the way AK::String declares some methods that LibUnicode defines. Any user who wants to parse time zone names (from outside of LibCore itself) can link against LibTimeZone to receive full support.
2023-11-07 01:50:11 +00:00
lagom_test(../../Tests/LibCore/TestLibCoreDateTime.cpp LIBS LibTimeZone)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# RegexLibC test POSIX <regex.h> and contains many Serenity extensions
Meta: Use existing test-sources lists for Lagom instead of globbing ...mostly. This creates and uses an override for the `serenity_test()` function, so that Lagom can make use of the existing `Tests/LibFoo/CMakeLists.txt` files instead of having to GLOB for test source files and manually copy any data files. Some GLOBs remain but this is most of them. Co-authored-by: Andrew Kaster <akaster@serenityos.org>
2023-01-16 15:35:40 +00:00
# It is therefore not reasonable to run it on Lagom, and we only run the Regex test
lagom_test(../../Tests/LibRegex/Regex.cpp LIBS LibRegex WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../Tests/LibRegex)
LibWeb: Run tests in lagom if ENABLE_LAGOM_LIBWEB is set
2023-01-09 21:29:39 +00:00
Utilities: Add test-jpeg-roundtrip This creates a bitmap filled with a fixed color, then (in memory) saves it as jpeg and loads it again, and repeats that until the color of the bitmap no longer changes. It then reports how many iterations that took, and what the final color was. It does this for a couple of colors. This is for quality assessment of the jpeg codec. Ideally, it should converge quickly (in one iteration), and on a color not very far from the original input color.
2024-01-14 02:36:30 +00:00
# test-jpeg-roundtrip
add_executable(test-jpeg-roundtrip
../../Userland/Utilities/test-jpeg-roundtrip.cpp)
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
target_link_libraries(test-jpeg-roundtrip AK LibGfx LibMain)
Utilities: Add test-jpeg-roundtrip This creates a bitmap filled with a fixed color, then (in memory) saves it as jpeg and loads it again, and repeats that until the color of the bitmap no longer changes. It then reports how many iterations that took, and what the final color was. It does this for a couple of colors. This is for quality assessment of the jpeg codec. Ideally, it should converge quickly (in one iteration), and on a color not very far from the original input color.
2024-01-14 02:36:30 +00:00
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# JavaScriptTestRunner + LibTest tests
# test-js
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(test-js
LibJS+LibTest: Move out the test-js test runner into LibTest
2021-05-18 14:15:12 +00:00
../../Tests/LibJS/test-js.cpp
../../Userland/Libraries/LibTest/JavaScriptTestRunnerMain.cpp)
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
target_link_libraries(test-js AK LibCore LibFileSystem LibTest LibJS)
Meta: Run test-js and test-compress as CTest executables Reduces the number of steps in the Actions workflow this way :^)
2021-02-28 22:06:42 +00:00
add_test(
NAME JS
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
COMMAND test-js --show-progress=false
Shell: Build as part of Lagom as well Bringing the Serenity Shell to your very own host system :^)
2020-06-25 12:45:23 +00:00
)
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
set_tests_properties(JS PROPERTIES ENVIRONMENT SERENITY_SOURCE_DIR=${SERENITY_PROJECT_ROOT})
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
Tests+LibJS: Add very simple bytecode LibJS tests These tests are not meant as a replacement to test-js with the -b option but are meant to test simple cases until that works. Before this it was very easy to accidentally break bytecode since no tests were run in bytecode mode. This hopefully makes it easier to spot such regressions :^).
2022-01-22 13:27:53 +00:00
# Extra tests from Tests/LibJS
Meta: Rename Lagom library target names from LagomFoo to LibFoo This matches the target names for the main serenity build, and will make simplifying the Lagom build much easier going forward. The LagomFoo name came from a time when we had both library builds in the same CMake generated project and needed to deconflict the names.
2022-07-04 14:48:19 +00:00
lagom_test(../../Tests/LibJS/test-invalid-unicode-js.cpp LIBS LibJS)
LibJS: Allow negative pointers in Value Also ensure that all a nullptr input gives null object and you don't accidentally dereference a nullptr.
2022-09-06 23:14:23 +00:00
lagom_test(../../Tests/LibJS/test-value-js.cpp LIBS LibJS)
LibJS: Add a specific test for invalid unicode characters in the lexer Also fixes that it tried to make substrings past the end of the source if we overran the source length.
2021-10-03 11:10:35 +00:00
Lagom: Change to shared library build for all Lagom code Split the Lagom build into shared libraries to match the Serenity build. This reduces the cognitive load when trying to edit the Lagom CMakeLists significantly. It also reduces the amount of source files that must be compiled to run each test or host program significantly. Also re-organize all the build rules into sections. And reorganize the CMakeLists file in general.
2021-07-26 01:37:27 +00:00
# test-wasm
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
add_executable(test-wasm
LibWasm+Meta: Add test-wasm and optionally test the conformance tests This only tests "can it be parsed", but the goal of this commit is to provide a test framework that can be built upon :) The conformance tests are downloaded, compiled* and installed only if the INCLUDE_WASM_SPEC_TESTS cmake option is enabled. (*) Since we do not yet have a wast parser, the compilation is delegated to an external tool from binaryen, `wasm-as`, which is required for the test suite download/install to succeed. This *does* run the tests in CI, but it currently does not include the spec conformance tests.
2021-05-04 03:06:59 +00:00
../../Tests/LibWasm/test-wasm.cpp
../../Userland/Libraries/LibTest/JavaScriptTestRunnerMain.cpp)
Ladybird+Meta: Extract AK into its own library on Lagom We currently bundle AK with LibCore on Lagom. This means that to use AK, all libraries must also depend on LibCore. This will create circular dependencies when we create LibURL, as LibURL will depend on LibUnicode, which will depend on LibCore, which will depend on LibURL.
2024-01-21 23:24:43 +00:00
target_link_libraries(test-wasm AK LibCore LibFileSystem LibTest LibWasm LibJS LibCrypto)
LibWasm+Meta: Add test-wasm and optionally test the conformance tests This only tests "can it be parsed", but the goal of this commit is to provide a test framework that can be built upon :) The conformance tests are downloaded, compiled* and installed only if the INCLUDE_WASM_SPEC_TESTS cmake option is enabled. (*) Since we do not yet have a wast parser, the compilation is delegated to an external tool from binaryen, `wasm-as`, which is required for the test suite download/install to succeed. This *does* run the tests in CI, but it currently does not include the spec conformance tests.
2021-05-04 03:06:59 +00:00
add_test(
NAME WasmParser
CI+Lagom: Use the same options for running test-wasm in ctest and CI Make sure that we set SERENITY_SOURCE_DIR in ctest, and make sure to pass the test root to the CI job. More overhaul of test-js 'test root' finding is needed however.
2023-02-23 00:31:35 +00:00
COMMAND test-wasm --show-progress=false ${CMAKE_CURRENT_BINARY_DIR}/Userland/Libraries/LibWasm/Tests
)
set_tests_properties(WasmParser PROPERTIES
SKIP_RETURN_CODE 1
ENVIRONMENT SERENITY_SOURCE_DIR=${SERENITY_PROJECT_ROOT}
LibWasm+Meta: Add test-wasm and optionally test the conformance tests This only tests "can it be parsed", but the goal of this commit is to provide a test framework that can be built upon :) The conformance tests are downloaded, compiled* and installed only if the INCLUDE_WASM_SPEC_TESTS cmake option is enabled. (*) Since we do not yet have a wast parser, the compilation is delegated to an external tool from binaryen, `wasm-as`, which is required for the test suite download/install to succeed. This *does* run the tests in CI, but it currently does not include the spec conformance tests.
2021-05-04 03:06:59 +00:00
)
Meta: Add a CPack installation target for js(1) This adds a CPack configuration to generate a release package for js(1). Our current CMake requirement is 3.16, which doesn't have a great story for automatically installing a binary target's library dependencies. If we eventually require CMake 3.21 or above, we can remove the helper .cmake file added here in lieu of RUNTIME_DEPENDENCIES.
2022-02-08 16:11:03 +00:00
# FIXME: When we are using CMake >= 3.21, the library installations can be replaced with RUNTIME_DEPENDENCIES.
# https://cmake.org/cmake/help/latest/command/install.html
include(get_linked_lagom_libraries.cmake)
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
get_linked_lagom_libraries(js js_libraries)
Meta: Add a CPack installation target for js(1) This adds a CPack configuration to generate a release package for js(1). Our current CMake requirement is 3.16, which doesn't have a great story for automatically installing a binary target's library dependencies. If we eventually require CMake 3.21 or above, we can remove the helper .cmake file added here in lieu of RUNTIME_DEPENDENCIES.
2022-02-08 16:11:03 +00:00
Lagom: Remove unecessary _lagom suffix from test and executable names We needed this back when we included Lagom into the main serenity build, but it has been unecessary since the superbuild.
2022-10-14 02:34:34 +00:00
install(TARGETS js ${js_libraries} COMPONENT js)
Meta: Add a CPack installation target for js(1) This adds a CPack configuration to generate a release package for js(1). Our current CMake requirement is 3.16, which doesn't have a great story for automatically installing a binary target's library dependencies. If we eventually require CMake 3.21 or above, we can remove the helper .cmake file added here in lieu of RUNTIME_DEPENDENCIES.
2022-02-08 16:11:03 +00:00
set(CPACK_GENERATOR "TGZ")
set(CPACK_STRIP_FILES TRUE)
set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
set(CPACK_COMPONENTS_ALL js)
Meta+CI: Add CI job specifically for bundling serenity-js artifacts These are used by esvu, and it is sad that we don't have macOS binaries availble for consumption by esvu users. Add a matrix job to handle this separately from the test262 results.
2022-12-01 09:08:12 +00:00
if (APPLE)
if("arm64" IN_LIST CMAKE_OSX_ARCHITECTURES AND "x86_64" IN_LIST CMAKE_OSX_ARCHITECTURES)
set(CPACK_SYSTEM_NAME "macOS-universal2")
Meta: Explicitly link generated compile-time data into the WASM JS REPL Without this, we were in a weird state where LibTimeZone believed it had TZDB data, but that data wasn't actually available to it. This caused functions like JS::get_named_time_zone_offset_nanoseconds() to trip an assertion when entering "new Date();" into the REPL.
2022-12-05 21:49:32 +00:00
else()
Meta+CI: Add CI job specifically for bundling serenity-js artifacts These are used by esvu, and it is sad that we don't have macOS binaries availble for consumption by esvu users. Add a matrix job to handle this separately from the test262 results.
2022-12-01 09:08:12 +00:00
set(CPACK_SYSTEM_NAME "macOS-${CMAKE_SYSTEM_PROCESSOR}")
endif()
else()
set(CPACK_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}")
endif()
set(CPACK_ARCHIVE_JS_FILE_NAME "serenity-js-${CPACK_SYSTEM_NAME}")
set(CPACK_PACKAGE_FILE_NAME "serenity-js-${CPACK_SYSTEM_NAME}")
Meta: Add a CPack installation target for js(1) This adds a CPack configuration to generate a release package for js(1). Our current CMake requirement is 3.16, which doesn't have a great story for automatically installing a binary target's library dependencies. If we eventually require CMake 3.21 or above, we can remove the helper .cmake file added here in lieu of RUNTIME_DEPENDENCIES.
2022-02-08 16:11:03 +00:00
include(CPack)
Lagom: Various fixes to make Lagom run on OSS-Fuzz (#4176)
2020-11-27 22:57:02 +00:00
endif()
Build: Switch to CMake :^) Closes https://github.com/SerenityOS/serenity/issues/2080
2020-05-06 15:40:06 +00:00
endif()
LibX86: Add an X86 instruction decoder library + basic disassembler This will be very useful for developer tools like ProfileView, and also for future tools like debuggers and such. :^)
2020-04-11 11:16:17 +00:00
CMake: Allow building fuzzing targets without libFuzzer or OSS-Fuzz
2022-03-21 10:36:41 +00:00
if (ENABLE_FUZZERS)
Lagom: Add fuzz testing for LibJS using libFuzzer (#1692) Note: clang only (see https://llvm.org/docs/LibFuzzer.html) - add FuzzJs which will run the LibJS parser on random javascript inputs - added a basic dictionary of javascript tokens To use fuzzer: CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -DENABLE_FUZZER_SANITIZER=1 .. Fuzzers/FuzzJs -dict=../Fuzzers/FuzzJs.dict
2020-04-08 08:40:02 +00:00
add_subdirectory(Fuzzers)
Meta: Build select Services in Lagom Add overrides for serenity_bin and serenity_lib to allow the actual CMakeLists.txt from Userland to be used to build as many services as possible without adding more clutter to Meta/Lagom/CMakeLists.txt
2022-07-04 16:08:01 +00:00
else()
export_components("${CMAKE_BINARY_DIR}/components.ini")
Lagom: Add fuzz testing for LibJS using libFuzzer (#1692) Note: clang only (see https://llvm.org/docs/LibFuzzer.html) - add FuzzJs which will run the LibJS parser on random javascript inputs - added a basic dictionary of javascript tokens To use fuzzer: CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -DENABLE_FUZZER_SANITIZER=1 .. Fuzzers/FuzzJs -dict=../Fuzzers/FuzzJs.dict
2020-04-08 08:40:02 +00:00
endif()
Meta: Allow running Lagom tests with "serenity.sh run lagom <target>" After 5ac57f9, we could no longer run "serenity.sh run lagom TestString" because the TestString binary now lives in a subdirectory under Build/lagom. Thus the existing method of running "$BUILD_DIR/TestString" could not work. This adds a "run-lagom-target" custom target to Lagom, to run a command and pass arguments to that invocation. It turns out there really isn't a "pretty" way of doing this with CMake or Ninja. But we can pass these as environment variables for CMake to interpret. We just must be careful to massage arguments into a CMake list.
2023-01-25 19:46:44 +00:00
if (NOT "$ENV{LAGOM_TARGET}" STREQUAL "")
add_custom_target(run-lagom-target
Meta: Set LD_LIBRARY_PATH to Build/lagom for Lagom test targets Some tests, such as those under LibGL, try to load shared libraries at runtime which are stored in Build/lagom. Because all tests' working directory is that of their CMakeLists.txt file, they fail to find those shared libraries at runtime. Set LD_LIBRARY_PATH to Build/lagom so the tests may find the shared libraries. This fixes, for example, both of these commands: ./Meta/serenity.sh test lagom TestAPI ./Meta/serenity.sh run lagom TestAPI
2023-02-01 13:42:31 +00:00
COMMAND "${CMAKE_COMMAND}"
Meta+Lagom: Enable CMAKE_BUILD_WITH_INSTALL_RPATH On macOS, CMake incorrectly tries to add and/or remove rpaths from files that it has already processed when it performs installation. Setting the rpaths during the build process ensures that they are only set once, and as a bonus, makes installation slightly more performant. Fixes #10055.
2023-03-18 15:23:35 +00:00
-E env "SERENITY_SOURCE_DIR=${SERENITY_PROJECT_ROOT}" "$<TARGET_FILE:$ENV{LAGOM_TARGET}>"
$ENV{LAGOM_ARGS}
Meta: Set LD_LIBRARY_PATH to Build/lagom for Lagom test targets Some tests, such as those under LibGL, try to load shared libraries at runtime which are stored in Build/lagom. Because all tests' working directory is that of their CMakeLists.txt file, they fail to find those shared libraries at runtime. Set LD_LIBRARY_PATH to Build/lagom so the tests may find the shared libraries. This fixes, for example, both of these commands: ./Meta/serenity.sh test lagom TestAPI ./Meta/serenity.sh run lagom TestAPI
2023-02-01 13:42:31 +00:00
Meta: Set the Lagom test working directory for run-lagom-target When we call add_test() from each test's CMakeLists.txt, we specify the working directory to be that of the CMakeList.txt file itself. Create a property to store that directory and reference it when run-lagom-target is invoked by serenity.sh. Note that for non-test Lagom targets which do not set this property, the working directory will be Build/lagom (because the property will be the empty string, which CMake resolves relative to the current build path).
2023-02-01 13:36:15 +00:00
WORKING_DIRECTORY "$<TARGET_PROPERTY:$ENV{LAGOM_TARGET},LAGOM_WORKING_DIRECTORY>"
Meta: Allow running Lagom tests with "serenity.sh run lagom <target>" After 5ac57f9, we could no longer run "serenity.sh run lagom TestString" because the TestString binary now lives in a subdirectory under Build/lagom. Thus the existing method of running "$BUILD_DIR/TestString" could not work. This adds a "run-lagom-target" custom target to Lagom, to run a command and pass arguments to that invocation. It turns out there really isn't a "pretty" way of doing this with CMake or Ninja. But we can pass these as environment variables for CMake to interpret. We just must be careful to massage arguments into a CMake list.
2023-01-25 19:46:44 +00:00
DEPENDS "$<TARGET_FILE:$ENV{LAGOM_TARGET}>"
USES_TERMINAL
VERBATIM
)
endif()
Meta: Download cacert.pem at build time
2023-03-14 13:12:58 +00:00
include(ca_certificates_data)
Reference in a new issue Copy permalink