Modernize sanitizer scripts

StableCoder · StableCoder · commit 33a33ee83bc8 · 2024-08-23T08:46:49.000-07:00
The previous sanitizer support was implemented in a very rigid manner,
with the compile options available for each sanitizer type been preset,
and enabling of each sanitizer through a preset variable.

This change makes it so that setting of compile options can be set on a
per-sanitizer-type basis and then added to builds via functions. Use via
the legacy `USE_SANITIZER` is available, but deprecated.

This is also flexible enough to allow overriding of the compile options,
via variables either in-script or passed in via the command-line.

Results of checks for compile compatability are cached, reducing time
on subsequent builds, provided the associated compile options are not
updated.

Checks for sanitizer availability/compatability are no longer platform
dependent. It will check on all platforms.
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
@@ -2,8 +2,7 @@ stages:
   - Analysis
   - Targeted Code Coverage
   - All Code Coverage
-  - Fedora
-  - openSUSE
+  - Sanitizers
 
 variables:
   CTEST_OUTPUT_ON_FAILURE: "1"
@@ -427,10 +426,10 @@ Windows/All CC Clang Shared:
     - ninja -C build ccov-report
     - ninja -C build ccov-all-report
 
-# Fedora
+# Sanitizers
 
-.fedora_success_template: &fedora_success_template
-  stage: Fedora
+.linux_success_template: &linux_success_template
+  stage: Sanitizers
   image: stabletec/build-core:fedora
   parallel:
     matrix:
@@ -444,8 +443,8 @@ Windows/All CC Clang Shared:
     - ninja -C build
     - ninja -C build test
 
-.fedora_failure_template: &fedora_failure_template
-  stage: Fedora
+.linux_failure_template: &linux_failure_template
+  stage: Sanitizers
   image: stabletec/build-core:fedora
   parallel:
     matrix:
@@ -459,37 +458,79 @@ Windows/All CC Clang Shared:
     - ninja -C build
     - "! ninja -C build test"
 
-Fedora/Static Analysis:
+Linux/Static Analysis:
   variables:
     CC: clang
     CXX: clang++
     CMAKE_OPTIONS: -DCLANG_TIDY=ON -DCPPCHECK=ON
-  <<: *fedora_success_template
+  <<: *linux_success_template
 
-Fedora/ThreadSanitizer:
+Linux/Clang/ThreadSanitizer:
   variables:
     CC: clang
     CXX: clang++
-    CMAKE_OPTIONS: -DUSE_SANITIZER=Thread
-  <<: *fedora_failure_template
+    CMAKE_OPTIONS: -D EXAMPLE_USE_SANITIZER=thread
+  <<: *linux_failure_template
 
-Fedora/AddressSanitizer:
+Linux/Clang/AddressSanitizer:
   variables:
     CC: clang
     CXX: clang++
-    CMAKE_OPTIONS: -DUSE_SANITIZER=Address
-  <<: *fedora_failure_template
+    CMAKE_OPTIONS: -D EXAMPLE_USE_SANITIZER=address
+  <<: *linux_failure_template
 
-Fedora/LeakSanitizer:
+Linux/Clang/LeakSanitizer:
   variables:
     CC: clang
     CXX: clang++
-    CMAKE_OPTIONS: -DUSE_SANITIZER=Leak
-  <<: *fedora_failure_template
+    CMAKE_OPTIONS: -D EXAMPLE_USE_SANITIZER=leak
+  <<: *linux_failure_template
 
-Fedora/UndefinedSanitizer:
+Linux/Clang/MemorySanitizer:
   variables:
     CC: clang
     CXX: clang++
-    CMAKE_OPTIONS: -DUSE_SANITIZER=Undefined
-  <<: *fedora_success_template
+    CMAKE_OPTIONS: -D EXAMPLE_USE_SANITIZER=memory
+  <<: *linux_failure_template
+
+Linux/Clang/UndefinedSanitizer:
+  variables:
+    CC: clang
+    CXX: clang++
+    CMAKE_OPTIONS: -D EXAMPLE_USE_SANITIZER=undefined
+  <<: *linux_success_template
+
+Linux/Clang/ThreadSanitizer (LEGACY):
+  variables:
+    CC: clang
+    CXX: clang++
+    CMAKE_OPTIONS: -D USE_SANITIZER=thread
+  <<: *linux_failure_template
+
+Linux/Clang/AddressSanitizer (LEGACY):
+  variables:
+    CC: clang
+    CXX: clang++
+    CMAKE_OPTIONS: -D USE_SANITIZER=address
+  <<: *linux_failure_template
+
+Linux/Clang/LeakSanitizer (LEGACY):
+  variables:
+    CC: clang
+    CXX: clang++
+    CMAKE_OPTIONS: -D USE_SANITIZER=leak
+  <<: *linux_failure_template
+
+Linux/Clang/MemorySanitizer (LEGACY):
+  variables:
+    CC: clang
+    CXX: clang++
+    CMAKE_OPTIONS: -D USE_SANITIZER=memory
+  <<: *linux_failure_template
+
+Linux/Clang/UndefinedSanitizer (LEGACY):
+  variables:
+    CC: clang
+    CXX: clang++
+    CMAKE_OPTIONS: -D USE_SANITIZER=undefined
+  <<: *linux_success_template
diff --git a/README.md b/README.md
@@ -7,16 +7,17 @@ This is a collection of quite useful scripts that expand the possibilities for b
 
 - [C++ Standards `c++-standards.cmake`](#c-standards-c-standardscmake)
 - [Sanitizer Builds `sanitizers.cmake`](#sanitizer-builds-sanitizerscmake)
+  - [Usage](#usage)
 - [Code Coverage `code-coverage.cmake`](#code-coverage-code-coveragecmake)
   - [Added Targets](#added-targets)
-  - [Usage](#usage)
+  - [Usage](#usage-1)
     - [Example 1 - All targets instrumented](#example-1---all-targets-instrumented)
       - [1a - Via global command](#1a---via-global-command)
       - [1b - Via target commands](#1b---via-target-commands)
     - [Example 2: Target instrumented, but with regex pattern of files to be excluded from report](#example-2-target-instrumented-but-with-regex-pattern-of-files-to-be-excluded-from-report)
     - [Example 3: Target added to the 'ccov' and 'ccov-all' targets](#example-3-target-added-to-the-ccov-and-ccov-all-targets)
 - [AFL Fuzzing Instrumentation `afl-fuzzing.cmake`](#afl-fuzzing-instrumentation-afl-fuzzingcmake)
-  - [Usage](#usage-1)
+  - [Usage](#usage-2)
 - [Compiler Options `compiler-options.cmake`](#compiler-options-compiler-optionscmake)
 - [Dependency Graph `dependency-graph.cmake`](#dependency-graph-dependency-graphcmake)
   - [Required Arguments](#required-arguments)
@@ -88,16 +89,55 @@ A quick rundown of the tools available, and what they do:
 - [MemorySanitizer](https://clang.llvm.org/docs/MemorySanitizer.html) detects uninitialized reads.
 - [Control Flow Integrity](https://clang.llvm.org/docs/ControlFlowIntegrity.html) is designed to detect certain forms of undefined behaviour that can potentially allow attackers to subvert the program's control flow.
 
-These are used by declaring the `USE_SANITIZER` CMake variable as string containing any of:
-- Address
-- Memory
-- MemoryWithOrigins
-- Undefined
-- Thread
-- Leak
-- CFI
+### Usage
+
+The most basic way to enable sanitizers is to simply call `add_sanitizer_support` with the desired sanitizer names, whereupon it will check for the availability and compatability of the combined flags and apply to following compile targets:
+```cmake
+# apply address and leak sanitizers
+add_sanitizer_support(address leak)
+# future targets will be compiled with '-fsanitize=address -fsanitize=leak'
+```
+
+Compile options on a per-sanitizer basis can be accomplished by calling `set_sanitizer_options` before with the name of the sanitizer and desired compile options:
+```cmake
+# set custom options that will be applies with that specific sanitizer
+set_sanitizer_options(address -fno-omit-frame-pointer)
+
+add_sanitizer_support(address leak)
+# future targets will be compiled with '-fsanitize=address -fno-omit-frame-pointer -fsanitize=leak'
+```
+
+Per-sanitizer compile options can also be set by setting the named `SANITIZER_${SANITIZER_NAME}_OPTIONS` variable before, either in script or via the command line.
+```cmake
+# CMake called from command line as `cmake -S . -B build -D SANITIZER_ADDRESS_OPTION='-fno-omit-frame-pointer'`
+
+add_sanitizer_support(address)
+# future targets will be compiled with '-fsanitize=address -fno-omit-frame-pointer' 
+# despite no call to `set_sanitizer_options`
+```
+
+To prevent custom sanitizer options from external source being overwritten, the `DEFAULT` option can be used, so that the flags are only used if none have been set previously:
+```cmake
+# command line has options set via command-line: `cmake -S . -B build -D SANITIZER_ADDRESS_OPTION='-fno-omit-frame-pointer'`
 
-Multiple values are allowed, e.g. `-DUSE_SANITIZER=Address,Leak` but some sanitizers cannot be combined together, e.g.`-DUSE_SANITIZER=Address,Memory` will result in configuration error. The delimeter character is not required and `-DUSE_SANITIZER=AddressLeak` would work as well.
+# attempt to set custom options that will not apply since the variable already exists
+# and `DEFAULT` option is passed in.
+set_sanitizer_options(address DEFAULT -some-other-flag)
+
+add_sanitizer_support(address)
+# future targets will be compiled with '-fsanitize=address -fno-omit-frame-pointer'
+```
+
+Different sets of options used with the sanitizer can be accomplished by defining the sanitizer serparately with the call to `set_sanitizer_option`:
+```cmake
+# Despite both using the 'memory' sanitizer, which specific set of flags can be chosen
+# when calling `add_sanitizer_support` with either 'memory' or 'memorywithorigins'
+set_sanitizer_options(memory DEFAULT -fno-omit-frame-pointer)
+set_sanitizer_options(memorywithorigins DEFAULT
+                      SANITIZER memory
+                      -fno-omit-frame-pointer 
+                      -fsanitize-memory-track-origins)
+```
 
 ## Code Coverage [`code-coverage.cmake`](code-coverage.cmake)
 
diff --git a/example/all/CMakeLists.txt b/example/all/CMakeLists.txt
@@ -7,29 +7,46 @@ set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/../..;")
 include(c++-standards)
 include(code-coverage)
 include(formatting)
-include(sanitizers)
 include(tools)
 include(dependency-graph)
 
 # Require C++11
 cxx_11()
 
 # Tools
-file(GLOB_RECURSE FFILES *.[hc] *.[hc]pp)
-clang_format(format ${FFILES})
+if(NOT WIN32)
+  file(GLOB_RECURSE FFILES *.[hc] *.[hc]pp)
+  clang_format(format ${FFILES})
 
-cmake_format(cmake-format ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-             CMakeLists.txt)
+  cmake_format(cmake-format ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               CMakeLists.txt)
 
-clang_tidy(-format-style=file -checks=* -header-filter='${CMAKE_SOURCE_DIR}/*')
-include_what_you_use(-Xiwyu)
-cppcheck(
-  --enable=warning,performance,portability,missingInclude
-  --template="[{severity}][{id}] {message} {callstack} \(On {file}:{line}\)"
-  --suppress=missingIncludeSystem --quiet --verbose --force)
+  clang_tidy(-format-style=file -checks=*
+             -header-filter='${CMAKE_SOURCE_DIR}/*')
+  include_what_you_use(-Xiwyu)
+  cppcheck(
+    --enable=warning,performance,portability,missingInclude
+    --template="[{severity}][{id}] {message} {callstack} \(On {file}:{line}\)"
+    --suppress=missingIncludeSystem --quiet --verbose --force)
+endif()
 
 enable_testing()
 
+# Sanitizers
+include(sanitizers)
+
+set_sanitizer_options(address DEFAULT)
+set_sanitizer_options(leak DEFAULT)
+set_sanitizer_options(memory DEFAULT)
+set_sanitizer_options(memorywithorigins DEFAULT SANITIZER memory
+                      -fsanitize-memory-track-origins)
+set_sanitizer_options(undefined DEFAULT)
+set_sanitizer_options(thread DEFAULT)
+
+if(EXAMPLE_USE_SANITIZER)
+  add_sanitizer_support(${EXAMPLE_USE_SANITIZER})
+endif()
+
 # Fails with ThreadSanitizer
 add_executable(tsanFail ../src/tsan_fail.cpp)
 target_code_coverage(tsanFail AUTO ALL)
@@ -44,7 +61,7 @@ target_code_coverage(lsanFail AUTO ALL)
 add_test(lsan lsanFail)
 
 # Fails with AddressSanitizer
-if(USE_SANITIZER MATCHES "[Aa]ddress")
+if(EXAMPLE_USE_SANITIZER MATCHES "([Aa]ddress)")
   add_executable(asanFail ../src/asan_fail.cpp)
   target_code_coverage(asanFail AUTO ALL)
   add_test(asan asanFail)
diff --git a/sanitizers.cmake b/sanitizers.cmake
