Full Changelog: 24.04.1...24.08

Sanitizer Scripts Rework

How sanitizers work has been completely changed internally.

Sanitizers and their options are now declared via calling the set_sanitizer_options() function, and applying sanitizers to be used is via the new add_sanitizer_support() call.

Whether sanitizers are available/supported is no longer a function of the script inferring via the compiler/platform, but instead by checking whether the flags are available on the compiler no matter the platform.

DEPRECATED

The ability to use sanitizers via the global USE_SANITIZER variable is now deprecated and will be removed in a future release.

To maintain the same behaviour after removal, add this to CMake scripts file after including the sanitizers file:

if(NOT MSVC)
    set(SANITIZER_LEGACY_DEFAULT_COMMON_OPTIONS -fno-omit-frame-pointer)
endif()

set_sanitizer_options(address DEFAULT ${SANITIZER_LEGACY_DEFAULT_COMMON_OPTIONS})
set_sanitizer_options(leak DEFAULT ${SANITIZER_LEGACY_DEFAULT_COMMON_OPTIONS})
set_sanitizer_options(memory DEFAULT ${SANITIZER_LEGACY_DEFAULT_COMMON_OPTIONS})
set_sanitizer_options(memorywithorigins DEFAULT SANITIZER memory
    -fsanitize-memory-track-origins ${SANITIZER_LEGACY_DEFAULT_COMMON_OPTIONS})
set_sanitizer_options(undefined DEFAULT ${SANITIZER_LEGACY_DEFAULT_COMMON_OPTIONS})
set_sanitizer_options(thread DEFAULT ${SANITIZER_LEGACY_DEFAULT_COMMON_OPTIONS})
set_sanitizer_options(cfi DEFAULT ${SANITIZER_LEGACY_DEFAULT_COMMON_OPTIONS})

set(USE_SANITIZER
      ""
      CACHE
        STRING
        "Compile with sanitizers. Available sanitizers are: ${SANITIZERS_AVAILABLE_LIST}"
)

if(USE_SANITIZER)
  add_sanitizer_support(${USE_SANITIZER})
endif()

Accidentally broke LLVM-based code coverage when linking objects in.

Full Changelog: 24.04...24.04.1

Full Changelog: 23.09...24.04

• Set the prepare-catch.cmake as deprecated, since modern Catch has solid CMake scripts and integration already.
• The OBJECTS set for code coverage now also adds static libraries in addition to the original shared libraries when displaying coverage information.

• Fix ccov-all-export on Windows platform with an if/else split.
• Add C support for clang-tidy, iwyu and cppcheck
• Mark detail C/C++ tool variables as advanced to not clutter normal output with implementation details
• Rework of tools.cmake items. The options of CLANG_TIDY, IWYU and CPPCHECK have been removed. Instead, it is up to the including project on when/how to enable these tools. The ability to 'reset' the tools, to disable them for certain scopes has been accommodated via the use of reset_* macros.

To remake the exact behaviour from before for tools.cmake, you can change something like this:

clang_tidy(...)
include_what_you_use(...)
cppcheck(...)

to

option(CLANG_TIDY "Turns on clang-tidy processing if it is found." OFF)
if(CLANG_TIDY)
  clang_tidy(...)
endif()

option(IWYU "Turns on include-what-you-use processing if it is found." OFF)
if(IWYU)
  include_what_you_use(...)
endif()

option(CPPCHECK "Turns on cppcheck processing if it is found." OFF)
if(CPPCHECK)
  cppcheck(...)
endif()

Fixed code coverage support on Windows for the ccov-all-export target, thanks to @stanczyk4 via #45.

What's Changed

• Add plain option for target coverage by @rlalik in #36
• Fix setting of cache variables by @rlalik in #38
• code-coverage.cmake: do not inline when determining code coverage by @FreddyFunk in #40
• Fix llvm toolchain used for code coverage when using AppleClang on macOS
• Remove all Find*.cmake module files. All the covered libraries now have proper pkg/CMake config files installed with them.
• Add CMAKE_CROSSCOMPILING_EMULATOR to code-coverage. When cross-compiling, the used emulator will be prefixed to the call.
• Remove ccov-preprocessing target

New Contributors

• @FreddyFunk made their first contribution in #40

Full Changelog: 22.01...23.04

Some fixes, some new features.

• Implemented Link-Time Optimization (Ineffective on GCC) (link-time-optimization.cmake)
• Better code-coverage usability on Windows (code-coverage.cmake)
• Fixed code coverage ccov-all targets when using CMake pre-3.17 (code-coverage.cmake)
• Fixed code-coverage ccov-all targets on Windows (code-coverage.cmake)
• Added standard C++23 function (c++-standards.cmake)
• Added macros for C-standards from C90 to C23 (c-standards.cmake)
• New per-target export option (code-coverage.cmake)
• Remove double-running of code-coverage targets (code-coverage.cmake)
• Can now combine multiple sanitizers in one build (sanitizers.cmake)
• Add new Control Flow sanitizer optin (sanitizers.cmake)
• Add ability to make AFL++ (american fuzzy lop) fuzz instrumented builds (afl-fuzzing.cmake)

Changes from November 2020 -> January 2021

• Added new script that can build GLSL shader source files can be linked to a specified target and compiled for, complete with only re compiling only files modified since last compilation.
• Added files that allow for using the find_package function in CMake to find various libraries not included with CMake: fmt, assimp, glm, OpenXR and yaml-cpp.

Changes from April -> November 2020

• Changes primary branch from 'master' to 'main', including README links
• Fixed shared code not showing on ccov-all reports (with clang)
• Catch2 no longer uses 'master' as the default branch, as CMake tries to use. As such, the specific tag 'v2.x' is to be used, which safely follows Catch2's releases.

What it says on the tin.