Merge pull request #5 from RWTH-ELP/restructuring

Restructuring and new features
10 лет назад · 998db11834
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -0,0 +1,51 @@
 # This file is part of CMake-sanitizers.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 #
 #
 # Copyright (c)
 #   2013-2015 Matt Arsenault
 #   2015      RWTH Aachen University, Federal Republic of Germany
 #
 #
 # project information
 #
 # minimum required cmake version
 cmake_minimum_required(VERSION 2.8)
 # project name
 project("CMake-sanitizers")
 #
 # cmake configuration
 #
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 #
 # add tests
 #
 enable_testing()
 add_subdirectory(tests)
--- a/FindASan.cmake
+++ b/FindASan.cmake
@@ -1,74 +0,0 @@
 #
 # The MIT License (MIT)
 #
 # Copyright (c) 2013 Matthew Arsenault
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in
 # all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 #
 # This module tests if address sanitizer is supported by the compiler,
 # and creates a ASan build type (i.e. set CMAKE_BUILD_TYPE=ASan to use
 # it). This sets the following variables:
 #
 # CMAKE_C_FLAGS_ASAN - Flags to use for C with asan
 # CMAKE_CXX_FLAGS_ASAN  - Flags to use for C++ with asan
 # HAVE_ADDRESS_SANITIZER - True or false if the ASan build type is available
 include(CheckCCompilerFlag)
 # Set -Werror to catch "argument unused during compilation" warnings
 set(CMAKE_REQUIRED_FLAGS "-Werror -faddress-sanitizer") # Also needs to be a link flag for test to pass
 check_c_compiler_flag("-faddress-sanitizer" HAVE_FLAG_ADDRESS_SANITIZER)
 set(CMAKE_REQUIRED_FLAGS "-Werror -fsanitize=address") # Also needs to be a link flag for test to pass
 check_c_compiler_flag("-fsanitize=address" HAVE_FLAG_SANITIZE_ADDRESS)
 unset(CMAKE_REQUIRED_FLAGS)
 if(HAVE_FLAG_SANITIZE_ADDRESS)
  # Clang 3.2+ use this version
  set(ADDRESS_SANITIZER_FLAG "-fsanitize=address")
 elseif(HAVE_FLAG_ADDRESS_SANITIZER)
  # Older deprecated flag for ASan
  set(ADDRESS_SANITIZER_FLAG "-faddress-sanitizer")
 endif()
 if(NOT ADDRESS_SANITIZER_FLAG)
  return()
 else(NOT ADDRESS_SANITIZER_FLAG)
  set(HAVE_ADDRESS_SANITIZER FALSE)
 endif()
 set(HAVE_ADDRESS_SANITIZER TRUE)
 set(CMAKE_C_FLAGS_ASAN "-O1 -g ${ADDRESS_SANITIZER_FLAG} -fno-omit-frame-pointer -fno-optimize-sibling-calls"
    CACHE STRING "Flags used by the C compiler during ASan builds."
    FORCE)
 set(CMAKE_CXX_FLAGS_ASAN "-O1 -g ${ADDRESS_SANITIZER_FLAG} -fno-omit-frame-pointer -fno-optimize-sibling-calls"
    CACHE STRING "Flags used by the C++ compiler during ASan builds."
    FORCE)
 set(CMAKE_EXE_LINKER_FLAGS_ASAN "${ADDRESS_SANITIZER_FLAG}"
    CACHE STRING "Flags used for linking binaries during ASan builds."
    FORCE)
 set(CMAKE_SHARED_LINKER_FLAGS_ASAN "${ADDRESS_SANITIZER_FLAG}"
    CACHE STRING "Flags used by the shared libraries linker during ASan builds."
    FORCE)
 mark_as_advanced(CMAKE_C_FLAGS_ASAN
                 CMAKE_CXX_FLAGS_ASAN
                 CMAKE_EXE_LINKER_FLAGS_ASAN
                 CMAKE_SHARED_LINKER_FLAGS_ASAN)
--- a/FindMSan.cmake
+++ b/FindMSan.cmake
@@ -1,75 +0,0 @@
 #
 # The MIT License (MIT)
 #
 # Copyright (c) 2013 Matthew Arsenault
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in
 # all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 #
 # This module tests if memory sanitizer is supported by the compiler,
 # and creates a MSan build type (i.e. set CMAKE_BUILD_TYPE=MSan to use
 # it). This sets the following variables:
 #
 # CMAKE_C_FLAGS_MSAN - Flags to use for C with msan
 # CMAKE_CXX_FLAGS_MSAN  - Flags to use for C++ with msan
 # HAVE_MEMORY_SANITIZER - True or false if the MSan build type is available
 include(CheckCCompilerFlag)
 # Set -Werror to catch "argument unused during compilation" warnings
 set(CMAKE_REQUIRED_FLAGS "-Werror -fmemory-sanitizer") # Also needs to be a link flag for test to pass
 check_c_compiler_flag("-fmemory-sanitizer" HAVE_FLAG_MEMORY_SANITIZER)
 set(CMAKE_REQUIRED_FLAGS "-Werror -fsanitize=memory") # Also needs to be a link flag for test to pass
 check_c_compiler_flag("-fsanitize=memory" HAVE_FLAG_SANITIZE_MEMORY)
 unset(CMAKE_REQUIRED_FLAGS)
 if(HAVE_FLAG_SANITIZE_MEMORY)
  # Clang 3.2+ use this version
  set(MEMORY_SANITIZER_FLAG "-fsanitize=memory")
 elseif(HAVE_FLAG_MEMORY_SANITIZER)
  # Older deprecated flag for MSan
  set(MEMORY_SANITIZER_FLAG "-fmemory-sanitizer")
 endif()
 if(NOT MEMORY_SANITIZER_FLAG)
  return()
 else(NOT MEMORY_SANITIZER_FLAG)
  set(HAVE_MEMORY_SANITIZER TRUE)
 endif()
 set(HAVE_MEMORY_SANITIZER TRUE)
 set(CMAKE_C_FLAGS_MSAN "-O1 -g ${MEMORY_SANITIZER_FLAG} -fno-omit-frame-pointer -fno-optimize-sibling-calls"
    CACHE STRING "Flags used by the C compiler during MSan builds."
    FORCE)
 set(CMAKE_CXX_FLAGS_MSAN "-O1 -g ${MEMORY_SANITIZER_FLAG} -fno-omit-frame-pointer -fno-optimize-sibling-calls"
    CACHE STRING "Flags used by the C++ compiler during MSan builds."
    FORCE)
 set(CMAKE_EXE_LINKER_FLAGS_MSAN "${MEMORY_SANITIZER_FLAG}"
    CACHE STRING "Flags used for linking binaries during MSan builds."
    FORCE)
 set(CMAKE_SHARED_LINKER_FLAGS_MSAN "${MEMORY_SANITIZER_FLAG}"
    CACHE STRING "Flags used by the shared libraries linker during MSan builds."
    FORCE)
 mark_as_advanced(CMAKE_C_FLAGS_MSAN
                 CMAKE_CXX_FLAGS_MSAN
                 CMAKE_EXE_LINKER_FLAGS_MSAN
                 CMAKE_SHARED_LINKER_FLAGS_MSAN)
--- a/FindTSan.cmake
+++ b/FindTSan.cmake
@@ -1,77 +0,0 @@
 #
 # The MIT License (MIT)
 #
 # Copyright (c) 2013 Matthew Arsenault
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in
 # all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 #
 # This module tests if thread sanitizer is supported by the compiler,
 # and creates a TSan build type (i.e. set CMAKE_BUILD_TYPE=TSan to use
 # it). This sets the following variables:
 #
 # CMAKE_C_FLAGS_TSAN - Flags to use for C with tsan
 # CMAKE_CXX_FLAGS_TSAN  - Flags to use for C++ with tsan
 # HAVE_THREAD_SANITIZER - True or false if the TSan build type is available
 include(CheckCCompilerFlag)
 # Set -Werror to catch "argument unused during compilation" warnings
 set(CMAKE_REQUIRED_FLAGS "-Werror -fthread-sanitizer") # Also needs to be a link flag for test to pass
 check_c_compiler_flag("-fthread-sanitizer" HAVE_FLAG_THREAD_SANITIZER)
 set(CMAKE_REQUIRED_FLAGS "-Werror -fsanitize=thread") # Also needs to be a link flag for test to pass
 check_c_compiler_flag("-fsanitize=thread" HAVE_FLAG_SANITIZE_THREAD)
 unset(CMAKE_REQUIRED_FLAGS)
 # A special test that uses threads seems to not be necessary. tsan
 # symbols are used even in just int main() { return 0; }
 if(HAVE_FLAG_SANITIZE_THREAD)
  # Clang 3.2+ use this version
  set(THREAD_SANITIZER_FLAG "-fsanitize=thread")
 elseif(HAVE_FLAG_THREAD_SANITIZER)
  # Older deprecated flag for TSan
  set(THREAD_SANITIZER_FLAG_FLAG "-fthread-sanitizer")
 else()
  set(HAVE_THREAD_SANITIZER FALSE)
  return()
 endif()
 set(HAVE_THREAD_SANITIZER TRUE)
 set(CMAKE_C_FLAGS_TSAN "-O1 -g ${THREAD_SANITIZER_FLAG} -fno-omit-frame-pointer"
    CACHE STRING "Flags used by the C compiler during TSan builds."
    FORCE
    )
 set(CMAKE_CXX_FLAGS_TSAN "-O1 -g ${THREAD_SANITIZER_FLAG} -fno-omit-frame-pointer"
    CACHE STRING "Flags used by the C++ compiler during TSan builds."
    FORCE)
 set(CMAKE_EXE_LINKER_FLAGS_TSAN "${THREAD_SANITIZER_FLAG}"
    CACHE STRING "Flags used for linking binaries during TSan builds."
    FORCE)
 set(CMAKE_SHARED_LINKER_FLAGS_TSAN "${THREAD_SANITIZER_FLAG}"
    CACHE STRING "Flags used by the shared libraries linker during TSan builds."
    FORCE)
 mark_as_advanced(CMAKE_C_FLAGS_TSAN
                 CMAKE_CXX_FLAGS_TSAN
                 CMAKE_EXE_LINKER_FLAGS_TSAN
                 CMAKE_SHARED_LINKER_FLAGS_TSAN)
--- a/FindUBSan.cmake
+++ b/FindUBSan.cmake
@@ -1,124 +0,0 @@
 #
 # The MIT License (MIT)
 #
 # Copyright (c) 2013 Matthew Arsenault
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in
 # all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 #
 # Check if the compiler supports a working ubsan. Provides a UBSan
 # build type, which is essentially Debug + ubsan. The flag can be used
 # independently to compose it with other build types or sanitizers.
 #
 # Sets these variables:
 #
 # HAVE_UNDEFINED_BEHAVIOR_SANITIZER - True or false if the UBSan is available
 # UNDEFINED_BEHAVIOR_SANITIZER_FLAG - Flag to add to compiler to use ubsan if supported
 #
 # CMAKE_C_FLAGS_UBSAN - Flags to use for C with ubsan
 # CMAKE_CXX_FLAGS_UBSAN  - Flags to use for C++ with ubsan
 ##
 #
 include(CheckCXXCompilerFlag)
 include(CheckCXXSourceRuns)
 # Set -Werror to catch "argument unused during compilation" warnings
 set(CMAKE_REQUIRED_FLAGS "-Werror")
 check_cxx_compiler_flag("-fsanitize=undefined" HAVE_FLAG_SANITIZE_UNDEFINED)
 check_cxx_compiler_flag("-fcatch-undefined-behavior" HAVE_FLAG_CATCH_UNDEFINED_BEHAVIOR)
 if(HAVE_FLAG_SANITIZE_UNDEFINED)
  set(UNDEFINED_BEHAVIOR_SANITIZER_FLAG "-fsanitize=undefined")
 elseif(HAVE_FLAG_CATCH_UNDEFINED_BEHAVIOR)
  set(UNDEFINED_BEHAVIOR_SANITIZER_FLAG "-fcatch-undefined-behavior")
 else()
  set(HAVE_UNDEFINED_BEHAVIOR_SANITIZER FALSE)
  return()
 endif()
 unset(CMAKE_REQUIRED_FLAGS)
 # It isn't sufficient to check if the flag works since the
 # check_c_compiler_flag test doesn't link the output.
 #
 # Most clang packages ship broken packages (the autotools build
 # produces a broken package which doesn't include the ubsan
 # compiler-rt, so check that it actually works with a linked program
 # before trying to use it
 set(CMAKE_REQUIRED_FLAGS "${UNDEFINED_BEHAVIOR_SANITIZER_FLAG} -Wno-error=delete-non-virtual-dtor")
 check_cxx_source_runs(
 "
 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 class BarB
 {
    public:
        float y;
        /* Include something that uses a virtual function. The symbols
           that are broken on current OS X libc++ involve this */
        virtual int arst(int o)
        {
            return 4 + o;
        }
    };
 /* Just include something that ubsan will need to check */
 int main(int argc, const char* argv[])
 {
    BarB* b = new BarB();
    if (argc > 1)
    {
        fputs(argv[atoi(argv[1])], stdout);
        std::cout << b->arst(atoi(argv[1]));
    }
    delete b;
    return 0;
 }
 "
  HAVE_UNDEFINED_BEHAVIOR_SANITIZER)
 unset(CMAKE_REQUIRED_FLAGS)
 if(NOT HAVE_UNDEFINED_BEHAVIOR_SANITIZER)
  return()
 endif()
 set(CMAKE_C_FLAGS_UBSAN "-O0 -g ${UNDEFINED_BEHAVIOR_SANITIZER_FLAG} -fno-omit-frame-pointer"
    CACHE STRING "Flags used by the C compiler during UBSan builds."
    FORCE)
 set(CMAKE_CXX_FLAGS_UBSAN "-O0 -g ${UNDEFINED_BEHAVIOR_SANITIZER_FLAG} -fno-omit-frame-pointer"
    CACHE STRING "Flags used by the C++ compiler during UBSan builds."
    FORCE)
 set(CMAKE_EXE_LINKER_FLAGS_UBSAN "${UNDEFINED_BEHAVIOR_SANITIZER_FLAG}"
    CACHE STRING "Flags used for linking binaries during UBSan builds."
    FORCE)
 set(CMAKE_SHARED_LINKER_FLAGS_UBSAN "${UNDEFINED_BEHAVIOR_SANITIZER_FLAG}"
    CACHE STRING "Flags used by the shared libraries linker during UBSan builds."
    FORCE)
 mark_as_advanced(CMAKE_C_FLAGS_UBSAN
                 CMAKE_CXX_FLAGS_UBSAN
                 CMAKE_EXE_LINKER_FLAGS_UBSAN
                 CMAKE_SHARED_LINKER_FLAGS_UBSAN)
--- a/+ 3
+++ b/+ 3
@@ -1,6 +1,8 @@
 The MIT License (MIT)
 Copyright (c) 2013 Matt Arsenault
 Copyright (c)
    2013 Matthew Arsenault
    2015-2016 RWTH Aachen University, Federal Republic of Germany
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
--- a/README.md
+++ b/README.md
@@ -1,4 +1,73 @@
 sanitizers-cmake
 ================
 # CMake-sanitizers
 CMake modules to help use sanitizers
 [![](https://img.shields.io/github/issues-raw/RWTH-ELP/CMake-sanitizers.svg?style=flat-square)](https://github.com/RWTH-ELP/CMake-sanitizers/issues)
 [![MIT](http://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](LICENSE)
 CMake module to enable sanitizers for binary targets.
 ## Include into your project
 To use [FindSanitizers.cmake](cmake/FindSanitizers.cmake), simply add this repository as git submodule into your own repository
 ```Shell
 mkdir externals
 git submodule add git://github.com/RWTH-ELP/CMake-sanitizers.git externals/CMake-sanitizers
 ```
 and adding ```externals/cmake-sanitizers/cmake``` to your ```CMAKE_MODULE_PATH```
 ```CMake
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/externals/cmake-sanitizers/cmake" ${CMAKE_MODULE_PATH})
 ```
 If you don't use git or dislike submodules you can copy the files in [cmake directory](cmake) into your repository. *Be careful and keep updates in mind!*
 Now you can simply run ```find_package``` in your CMake files:
 ```CMake
 find_package(Sanitizers)
 ```
 ## Usage
 You can enable the sanitizers with ``SANITIZE_ADDRESS``, ``SANITIZE_MEMORY``, ``SANITIZE_THREAD`` or ``SANITIZE_UNDEFINED`` options in your CMake configuration. You can do this by passing e.g. ``-DSANITIZE_ADDRESS=On`` on your command line or with your graphical interface.
 If sanitizers are supported by your compiler, the specified targets will be build with sanitizer support. If your compiler has no sanitizing capabilities (I asume intel compiler doesn't) you'll get a warning but CMake will continue processing and sanitizing will simply just be ignored.
 #### Compiler issues
 Different compilers may be using different implementations for sanitizers. If you'll try to sanitize targets with C and Fortran code but don't use gcc & gfortran but clang & gfortran, this will cause linking problems. To avoid this, such problems will be detected and sanitizing will be disabled for these targets.
 Even C only targets may cause problems in certain situations. Some problems have been seen with AddressSanitizer for preloading or dynamic linking. In such cases you may try the ``SANITIZE_LINK_STATIC`` to link sanitizers for gcc static.
 ## Build targets with sanitizer support
 To enable sanitizer support you simply have to add ``add_sanitizers(<TARGET>)`` after defining your target. To provide a sanitizer blacklist file you can use the ``add_sanitizer_blacklist(<FILE>)`` function:
 ```CMake
 find_package(Sanitizers)
 add_sanitizer_blacklist("blacklist.txt")
 add_executable(some_exe foo.c bar.c)
 add_sanitizers(some_exe)
 add_library(some_lib foo.c bar.c)
 add_sanitizers(some_lib)
 ```
 ## Run your application
 The sanitizers check your program, while it's running. In some situations (e.g. LD_PRELOAD your target) it might be required to preload the used AddressSanitizer library first. In this case you may use the ``asan-wrapper`` script defined in ``ASan_WRAPPER`` variable to execute your application with ``${ASan_WRAPPER} myexe arg1 ...``.
 ## Contribute
 Anyone is welcome to contribute. Simply fork this repository, make your changes **in an own branch** and create a pull-request for your change. Please do only one change per pull-request.
 You found a bug? Please fill out an [issue](https://github.com/RWTH-ELP/CMake-sanitizers/issues) and include any data to reproduce the bug.
 #### Contributors
 * [Matt Arsenault](https://github.com/arsenm)
 * [Alexander Haase](https://github.com/alehaa)
--- a/cmake/FindASan.cmake
+++ b/cmake/FindASan.cmake
@@ -0,0 +1,59 @@
 # The MIT License (MIT)
 #
 # Copyright (c)
 #   2013 Matthew Arsenault
 #   2015-2016 RWTH Aachen University, Federal Republic of Germany
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 option(SANITIZE_ADDRESS "Enable AddressSanitizer for sanitized targets." Off)
 set(FLAG_CANDIDATES
    # Clang 3.2+ use this version. The no-omit-frame-pointer option is optional.
    "-g -fsanitize=address -fno-omit-frame-pointer"
    "-g -fsanitize=address"
    # Older deprecated flag for ASan
    "-g -faddress-sanitizer"
 )
 if (SANITIZE_ADDRESS AND (SANITIZE_THREAD OR SANITIZE_MEMORY))
    message(FATAL_ERROR "AddressSanitizer is not compatible with "
        "ThreadSanitizer or MemorySanitizer.")
 endif ()
 include(sanitize-helpers)
 if (SANITIZE_ADDRESS)
    sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "AddressSanitizer"
        "ASan")
    find_program(ASan_WRAPPER "asan-wrapper" PATHS ${CMAKE_MODULE_PATH})
 	mark_as_advanced(ASan_WRAPPER)
 endif ()
 function (add_sanitize_address TARGET)
    if (NOT SANITIZE_ADDRESS)
        return()
    endif ()
    saitizer_add_flags(${TARGET} "AddressSanitizer" "ASan")
 endfunction ()
--- a/cmake/FindMSan.cmake
+++ b/cmake/FindMSan.cmake
@@ -0,0 +1,57 @@
 # The MIT License (MIT)
 #
 # Copyright (c)
 #   2013 Matthew Arsenault
 #   2015-2016 RWTH Aachen University, Federal Republic of Germany
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 option(SANITIZE_MEMORY "Enable MemorySanitizer for sanitized targets." Off)
 set(FLAG_CANDIDATES
    "-g -fsanitize=memory"
 )
 include(sanitize-helpers)
 if (SANITIZE_MEMORY)
    if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
        message(WARNING "MemorySanitizer disabled for target ${TARGET} because "
            "MemorySanitizer is supported for Linux systems only.")
        set(SANITIZE_MEMORY Off CACHE BOOL
            "Enable MemorySanitizer for sanitized targets." FORCE)
    elseif (NOT ${CMAKE_SIZEOF_VOID_P} EQUAL 8)
        message(WARNING "MemorySanitizer disabled for target ${TARGET} because "
            "MemorySanitizer is supported for 64bit systems only.")
        set(SANITIZE_MEMORY Off CACHE BOOL
            "Enable MemorySanitizer for sanitized targets." FORCE)
    else ()
        sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "MemorySanitizer"
            "MSan")
    endif ()
 endif ()
 function (add_sanitize_memory TARGET)
    if (NOT SANITIZE_MEMORY)
        return()
    endif ()
    saitizer_add_flags(${TARGET} "MemorySanitizer" "MSan")
 endfunction ()
--- a/cmake/FindSanitizers.cmake
+++ b/cmake/FindSanitizers.cmake
@@ -0,0 +1,62 @@
 # The MIT License (MIT)
 #
 # Copyright (c)
 #   2013 Matthew Arsenault
 #   2015-2016 RWTH Aachen University, Federal Republic of Germany
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 # If any of the used compiler is a GNU compiler, add a second option to static
 # link against the sanitizers.
 option(SANITIZE_LINK_STATIC "Try to link static against sanitizers." Off)
 set(FIND_QUIETLY_FLAG "")
 if (DEFINED Sanitizers_FIND_QUIETLY)
    set(FIND_QUIETLY_FLAG "QUIET")
 endif ()
 find_package(ASan ${FIND_QUIETLY_FLAG})
 find_package(TSan ${FIND_QUIETLY_FLAG})
 find_package(MSan ${FIND_QUIETLY_FLAG})
 find_package(UBSan ${FIND_QUIETLY_FLAG})
 function(sanitizer_add_blacklist_file FILE)
    if(NOT IS_ABSOLUTE ${FILE})
        set(FILE "${CMAKE_CURRENT_SOURCE_DIR}/${FILE}")
    endif()
    get_filename_component(FILE "${FILE}" REALPATH)
    sanitizer_check_compiler_flags("-fsanitize-blacklist=${FILE}"
        "SanitizerBlacklist" "SanBlist")
 endfunction()
 function(add_sanitizers ...)
    foreach (TARGET ${ARGV})
        add_sanitize_address(${TARGET})
        add_sanitize_thread(${TARGET})
        add_sanitize_memory(${TARGET})
        add_sanitize_undefined(${TARGET})
 	endforeach ()
 endfunction(add_sanitizers)
--- a/cmake/FindTSan.cmake
+++ b/cmake/FindTSan.cmake
@@ -0,0 +1,64 @@
 # The MIT License (MIT)
 #
 # Copyright (c)
 #   2013 Matthew Arsenault
 #   2015-2016 RWTH Aachen University, Federal Republic of Germany
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 option(SANITIZE_THREAD "Enable ThreadSanitizer for sanitized targets." Off)
 set(FLAG_CANDIDATES
    "-g -fsanitize=thread"
 )
 # ThreadSanitizer is not compatible with MemorySanitizer.
 if (SANITIZE_THREAD AND SANITIZE_MEMORY)
    message(FATAL_ERROR "ThreadSanitizer is not compatible with "
        "MemorySanitizer.")
 endif ()
 include(sanitize-helpers)
 if (SANITIZE_THREAD)
    if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
        message(WARNING "ThreadSanitizer disabled for target ${TARGET} because "
            "ThreadSanitizer is supported for Linux systems only.")
        set(SANITIZE_THREAD Off CACHE BOOL
            "Enable ThreadSanitizer for sanitized targets." FORCE)
    elseif (NOT ${CMAKE_SIZEOF_VOID_P} EQUAL 8)
        message(WARNING "ThreadSanitizer disabled for target ${TARGET} because "
            "ThreadSanitizer is supported for 64bit systems only.")
        set(SANITIZE_THREAD Off CACHE BOOL
            "Enable ThreadSanitizer for sanitized targets." FORCE)
    else ()
        sanitizer_check_compiler_flags("${FLAG_CANDIDATES}" "ThreadSanitizer"
            "TSan")
    endif ()
 endif ()
 function (add_sanitize_thread TARGET)
    if (NOT SANITIZE_THREAD)
        return()
    endif ()
    saitizer_add_flags(${TARGET} "ThreadSanitizer" "TSan")
 endfunction ()
--- a/cmake/FindUBSan.cmake
+++ b/cmake/FindUBSan.cmake
@@ -0,0 +1,46 @@
 # The MIT License (MIT)
 #
 # Copyright (c)
 #   2013 Matthew Arsenault
 #   2015-2016 RWTH Aachen University, Federal Republic of Germany
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 option(SANITIZE_UNDEFINED
    "Enable UndefinedBehaviorSanitizer for sanitized targets." Off)
 set(FLAG_CANDIDATES
    "-g -fsanitize=undefined"
 )
 include(sanitize-helpers)
 if (SANITIZE_UNDEFINED)
    sanitizer_check_compiler_flags("${FLAG_CANDIDATES}"
        "UndefinedBehaviorSanitizer" "UBSan")
 endif ()
 function (add_sanitize_undefined TARGET)
    if (NOT SANITIZE_UNDEFINED)
        return()
    endif ()
    saitizer_add_flags(${TARGET} "UndefinedBehaviorSanitizer" "UBSan")
 endfunction ()
--- a/cmake/asan-wrapper
+++ b/cmake/asan-wrapper
@@ -0,0 +1,55 @@
 #!/bin/sh
 # The MIT License (MIT)
 #
 # Copyright (c)
 #   2013 Matthew Arsenault
 #   2015-2016 RWTH Aachen University, Federal Republic of Germany
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 # This script is a wrapper for AddressSanitizer. In some special cases you need
 # to preload AddressSanitizer to avoid error messages - e.g. if you're
 # preloading another library to your application. At the moment this script will
 # only do something, if we're running on a Linux platform. OSX might not be
 # affected.
 # Exit immediately, if platform is not Linux.
 if [ "$(uname)" != "Linux" ]
 then
    exec $@
 fi
 # Get the used libasan of the application ($1). If a libasan was found, it will
 # be prepended to LD_PRELOAD.
 libasan=$(ldd $1 | grep libasan | sed "s/^[[:space:]]//" | cut -d' ' -f1)
 if [ -n "$libasan" ]
 then
    if [ -n "$LD_PRELOAD" ]
    then
        export LD_PRELOAD="$libasan:$LD_PRELOAD"
    else
        export LD_PRELOAD="$libasan"
    fi
 fi
 # Execute the application.
 exec $@
--- a/cmake/sanitize-helpers.cmake
+++ b/cmake/sanitize-helpers.cmake
@@ -0,0 +1,173 @@
 # The MIT License (MIT)
 #
 # Copyright (c)
 #   2013 Matthew Arsenault
 #   2015-2016 RWTH Aachen University, Federal Republic of Germany
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 # Helper function to get the language of a source file.
 function (sanitizer_lang_of_source FILE RETURN_VAR)
    get_filename_component(FILE_EXT "${FILE}" EXT)
    string(TOLOWER "${FILE_EXT}" FILE_EXT)
    string(SUBSTRING "${FILE_EXT}" 1 -1 FILE_EXT)
    get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
    foreach (LANG ${ENABLED_LANGUAGES})
        list(FIND CMAKE_${LANG}_SOURCE_FILE_EXTENSIONS "${FILE_EXT}" TEMP)
        if (NOT ${TEMP} EQUAL -1)
            set(${RETURN_VAR} "${LANG}" PARENT_SCOPE)
            return()
        endif ()
    endforeach()
    set(${RETURN_VAR} "" PARENT_SCOPE)
 endfunction ()
 # Helper function to get compilers used by a target.
 function (sanitizer_target_compilers TARGET RETURN_VAR)
    # Check if all sources for target use the same compiler. If a target uses
    # e.g. C and Fortran mixed and uses different compilers (e.g. clang and
    # gfortran) this can trigger huge problems, because different compilers may
    # use different implementations for sanitizers.
    set(BUFFER "")
    get_target_property(TSOURCES ${TARGET} SOURCES)
    foreach (FILE ${TSOURCES})
        # If expression was found, FILE is a generator-expression for an object
        # library. Object libraries will be ignored.
        string(REGEX MATCH "TARGET_OBJECTS:([^ >]+)" _file ${FILE})
        if ("${_file}" STREQUAL "")
            sanitizer_lang_of_source(${FILE} LANG)
            if (LANG)
                list(APPEND BUFFER ${CMAKE_${LANG}_COMPILER_ID})
            endif ()
        endif ()
    endforeach ()
    list(REMOVE_DUPLICATES BUFFER)
    set(${RETURN_VAR} "${BUFFER}" PARENT_SCOPE)
 endfunction ()
 # Helper function to check compiler flags for language compiler.
 function (sanitizer_check_compiler_flag FLAG LANG VARIABLE)
    if (${LANG} STREQUAL "C")
        include(CheckCCompilerFlag)
        check_c_compiler_flag("${FLAG}" ${VARIABLE})
    elseif (${LANG} STREQUAL "CXX")
        include(CheckCXXCompilerFlag)
        check_cxx_compiler_flag("${FLAG}" ${VARIABLE})
    elseif (${LANG} STREQUAL "Fortran")
        # CheckFortranCompilerFlag was introduced in CMake 3.x. To be compatible
        # with older Cmake versions, we will check if this module is present
        # before we use it. Otherwise we will define Fortran coverage support as
        # not available.
        include(CheckFortranCompilerFlag OPTIONAL RESULT_VARIABLE INCLUDED)
        if (INCLUDED)
            check_fortran_compiler_flag("${FLAG}" ${VARIABLE})
        elseif (NOT CMAKE_REQUIRED_QUIET)
            message(STATUS "Performing Test ${VARIABLE}")
            message(STATUS "Performing Test ${VARIABLE}"
                " - Failed (Check not supported)")
        endif ()
    endif()
 endfunction ()
 # Helper function to test compiler flags.
 function (sanitizer_check_compiler_flags FLAG_CANDIDATES NAME PREFIX)
    set(CMAKE_REQUIRED_QUIET ${${PREFIX}_FIND_QUIETLY})
    get_property(ENABLED_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
    foreach (LANG ${ENABLED_LANGUAGES})
        # Sanitizer flags are not dependend on language, but the used compiler.
        # So instead of searching flags foreach language, search flags foreach
        # compiler used.
        set(COMPILER ${CMAKE_${LANG}_COMPILER_ID})
        if (NOT DEFINED ${PREFIX}_${COMPILER}_FLAGS)
            foreach (FLAG ${FLAG_CANDIDATES})
                if(NOT CMAKE_REQUIRED_QUIET)
                    message(STATUS "Try ${COMPILER} ${NAME} flag = [${FLAG}]")
                endif()
                set(CMAKE_REQUIRED_FLAGS "${FLAG}")
                unset(${PREFIX}_FLAG_DETECTED CACHE)
                sanitizer_check_compiler_flag("${FLAG}" ${LANG}
                    ${PREFIX}_FLAG_DETECTED)
                if (${PREFIX}_FLAG_DETECTED)
                    # If compiler is a GNU compiler, search for static flag, if
                    # SANITIZE_LINK_STATIC is enabled.
                    if (SANITIZE_LINK_STATIC AND (${COMPILER} STREQUAL "GNU"))
                        string(TOLOWER ${PREFIX} PREFIX_lower)
                        sanitizer_check_compiler_flag(
                            "-static-lib${PREFIX_lower}" ${LANG}
                            ${PREFIX}_STATIC_FLAG_DETECTED)
                        if (${PREFIX}_STATIC_FLAG_DETECTED)
                            set(FLAG "-static-lib${PREFIX_lower} ${FLAG}")
                        endif ()
                    endif ()
                    set(${PREFIX}_${COMPILER}_FLAGS "${FLAG}" CACHE STRING
                        "${NAME} flags for ${COMPILER} compiler.")
                    mark_as_advanced(${PREFIX}_${COMPILER}_FLAGS)
                    break()
                endif ()
            endforeach ()
            if (NOT ${PREFIX}_FLAG_DETECTED)
                set(${PREFIX}_${COMPILER}_FLAGS "" CACHE STRING
                    "${NAME} flags for ${COMPILER} compiler.")
                mark_as_advanced(${PREFIX}_${COMPILER}_FLAGS)
            endif ()
        endif ()
    endforeach ()
 endfunction ()
 # Helper to assign sanitizer flags for TARGET.
 function (saitizer_add_flags TARGET NAME PREFIX)
    # Get list of compilers used by target and check, if target can be checked
    # by sanitizer.
    sanitizer_target_compilers(${TARGET} TARGET_COMPILER)
    list(LENGTH TARGET_COMPILER NUM_COMPILERS)
    if (NUM_COMPILERS GREATER 1)
        message(WARNING "${NAME} disabled for target ${TARGET} because it will "
            "be compiled by different compilers.")
        return()
    elseif ((NUM_COMPILERS EQUAL 0) OR
        ("${${PREFIX}_${TARGET_COMPILER}_FLAGS}" STREQUAL ""))
        message(WARNING "${NAME} disabled for target ${TARGET} because there is"
            " no sanitizer available for target sources.")
        return()
    endif()
    # Set compile- and link-flags for target.
    set_property(TARGET ${TARGET} APPEND_STRING
        PROPERTY COMPILE_FLAGS " ${${PREFIX}_${TARGET_COMPILER}_FLAGS}")
    set_property(TARGET ${TARGET} APPEND_STRING
        PROPERTY COMPILE_FLAGS " ${SanBlist_${TARGET_COMPILER}_FLAGS}")
    set_property(TARGET ${TARGET} APPEND_STRING
        PROPERTY LINK_FLAGS " ${${PREFIX}_${TARGET_COMPILER}_FLAGS}")
 endfunction ()
--- a/test_project/CMakeLists.txt
+++ b/test_project/CMakeLists.txt
@@ -1,12 +0,0 @@
 cmake_minimum_required(VERSION 2.8)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/..")
 include(FindUBSan)
 include(FindTSan)
 include(FindASan)
 include(FindMSan)
 add_executable(test test.cpp)
--- a/test_project/test.cpp
+++ b/test_project/test.cpp
@@ -1,48 +0,0 @@
 #include <cstdio>
 #include <cstdlib>
 #include <iostream>
 class BarB
 {
 public:
    float y;
    /* Include something that uses a virtual function. The symbols
       that are broken on current OS X libc++ involve this */
    virtual int arst(int o)
    {
        return 4 + o;
    }
 };
 static void print_array(const int* a)
 {
    for (int i = 0; i < 4; ++i)
    {
        std::cout << a[i] << ", ";
    }
    std::cout << '\n';
 }
 /* Just include something that ubsan will need to check */
 int main(int argc, const char* argv[])
 {
    BarB* b = new BarB();
    if (argc > 1)
    {
        int uninitialized[4];
        //int* uninitialized = new int[4];
        print_array(uninitialized);
        //delete[] uninitialized;
        int x = atoi(argv[1]);
        std::cout << (4 / x) << '\n';
        fputs(argv[x], stdout);
        std::cout << b->arst(x) << '\n';
    }
    delete b;
    return 0;
 }
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -0,0 +1,52 @@
 # This file is part of CMake-sanitizers.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
 #
 # The above copyright notice and this permission notice shall be included in all
 # copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 #
 #
 # Copyright (c)
 #   2013-2015 Matt Arsenault
 #   2015      RWTH Aachen University, Federal Republic of Germany
 #
 # Function to add testcases.
 function(add_testcase TESTNAME SOURCEFILES)
 	# remove ${TESTNAME} from ${ARGV} to use ${ARGV} as ${SOURCEFILES}
 	list(REMOVE_AT ARGV 0)
 	# add a new executable
 	add_executable(${TESTNAME} ${ARGV})
 	add_sanitizers(${TESTNAME})
 	# add a testcase for executable
 	add_test(${TESTNAME} ${TESTNAME})
 endfunction(add_testcase)
 #
 # search for sanitizers
 #
 find_package(Sanitizers)
 #
 # add testcases
 #
 add_testcase("asan_test_cpp" asan_test.cpp)
--- a/tests/asan_test.cpp
+++ b/tests/asan_test.cpp
@@ -0,0 +1,39 @@
 /* This file is part of CMake-sanitizers.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 *
 * Copyright (c)
 *  2013-2015 Matt Arsenault
 *  2015      RWTH Aachen University, Federal Republic of Germany
 */
 int
 main(int argc, char **argv)
 {
 	// Allocate a new array and delete it.
 	int *array = new int[argc];
 	delete[] array;
 	/* Access element of the deleted array. This will cause an memory error with
 	 * address sanitizer.
 	 */
 	return array[argc];
 }