# CheckCompilerFlag

Added in version 3.19.

This module provides a command to check whether the compiler supports a given flag.

Load this module in a CMake project with:

    include(CheckCompilerFlag)

## Commands

This module provides the following command:

check_compiler_flag

  Checks once whether the compiler supports a given flag:

      check_compiler_flag(<lang> <flag> <variable>)

  This command checks once that the `<flag>` is accepted by the `<lang>` compiler without producing a diagnostic message. The result of the check is stored in the internal cache variable specified by `<variable>`.

  The arguments are:

  `<lang>`

    The language of the compiler used for the check. Supported languages are: `C`, `CXX`, `CUDA`, `Fortran`, `HIP`, `ISPC`, `OBJC`, and `OBJCXX`, and `Swift`.

    Added in version 3.21: Support for `HIP` language.

    Added in version 3.26: Support for `Swift` language.

  `<flag>`

    Compiler flag(s) to check. Multiple flags can be specified in one argument as a string using a semicolon-separated list.

  `<variable>`

    Variable name of an internal cache variable to store the result of the check, with boolean true for success and boolean false for failure.

  A successful result only indicates that the compiler did not report an error when given the flag. Whether the flag has any effect, or the intended one, is outside the scope of this module.

  Note

  Since the underlying `try_compile()` command also uses flags from variables like `CMAKE_<LANG>_FLAGS`, unknown or unsupported flags in those variables may result in a false negative for this check.

  Variables Affecting the Check

  The following variables may be set before calling this command to modify the way the check is run:

  `CMAKE_REQUIRED_FLAGS`

    A space-separated string of additional flags to pass to the compiler. A semicolon-separated list will not work. The contents of `CMAKE_<LANG>_FLAGS` and its associated configuration-specific `CMAKE_<LANG>_FLAGS_<CONFIG>` variables are automatically prepended to the compiler command before the contents of this variable.

  `CMAKE_REQUIRED_DEFINITIONS`

    A semicolon-separated list of compiler definitions, each of the form `-DFOO` or `-DFOO=bar`. A definition for the name specified by the result variable argument of the check command is also added automatically.

  `CMAKE_REQUIRED_INCLUDES`

    A semicolon-separated list of header search paths to pass to the compiler. These will be the only header search paths used; the contents of the `INCLUDE_DIRECTORIES` directory property will be ignored.

  `CMAKE_REQUIRED_LINK_OPTIONS`

    Added in version 3.14.

    A semicolon-separated list of options to add to the link command (see `try_compile()` for further details).

  `CMAKE_REQUIRED_LIBRARIES`

    A semicolon-separated list of libraries to add to the link command. These can be the names of system libraries, or they can be Imported Targets (see `try_compile()` for further details).

  `CMAKE_REQUIRED_LINK_DIRECTORIES`

    Added in version 3.31.

    A semicolon-separated list of library search paths to pass to the linker (see `try_compile()` for further details).

  `CMAKE_REQUIRED_QUIET`

    Added in version 3.1.

    If this variable evaluates to a boolean true value, all status messages associated with the check will be suppressed.

  `CMAKE_TRY_COMPILE_TARGET_TYPE`

    Internally, the `try_compile()` command is used to perform the check, and this variable controls the type of target it creates. If this variable is set to `EXECUTABLE` (the default), the check compiles and links the test source code as an executable program. If set to `STATIC_LIBRARY`, the test source code is compiled but not linked.

## Examples

The following example demonstrates how to use this module to check support for the C compiler flag `-fno-optimize-strlen`, which disables optimizations related to the `strlen()` C function in GCC and Clang compilers. The result of the check is stored in the internal cache variable `HAVE_FNO_OPTIMIZE_STRLEN`, and the flag is conditionally enabled using the `target_compile_options()` command. The `$<COMPILE_LANGUAGE:...>` generator expression ensures that the flag is added only to `C` source files.

    include(CheckCompilerFlag)
    check_compiler_flag(C -fno-optimize-strlen HAVE_FNO_OPTIMIZE_STRLEN)

    if(HAVE_FNO_OPTIMIZE_STRLEN)
      target_compile_options(
        example
        PRIVATE $<$<COMPILE_LANGUAGE:C>:-fno-optimize-strlen>
      )
    endif()

## See Also

- The `CheckLinkerFlag` module to check whether a linker flag is supported by the compiler.