CheckSourceCompiles

Added in version 3.19.

This module provides a command that checks whether a source code can be built for a given language.

Load this module in a CMake project with:

include(CheckSourceCompiles)

Commands

This module provides the following command:

check_source_compiles

Checks once whether the given source code can be built for the given language:

check_source_compiles(
  <lang>
  <code>
  <variable>
  [FAIL_REGEX <regexes>...]
  [SRC_EXT <extension>]
)

This command checks once that the source supplied in <code> can be compiled (and linked into an executable) for code language <lang>. The result of the check is stored in the internal cache variable specified by <variable>.

The arguments are:

<lang>

Language of the source code to check. Supported languages are: C, CXX, CUDA, Fortran, HIP, ISPC, OBJC, OBJCXX, and Swift.

Added in version 3.21: Support for HIP language.

Added in version 3.26: Support for Swift language.

<code>

The source code to check. This must be an entire program, as written in a file containing the body block. All symbols used in the source code are expected to be declared as usual in their corresponding headers.

<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.

FAIL_REGEX <regexes>...

If one or more regular expression patterns are provided, then failure is determined by checking if anything in the compiler output matches any of the specified regular expressions.

SRC_EXT <extension>

By default, the internal test source file used for the check will be given a file extension that matches the requested language (e.g., .c for C, .cxx for C++, .F90 for Fortran, etc.). This option can be used to override this with the .<extension> instead.

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

Example: Basic Usage

The following example demonstrates how to check whether the C++ compiler supports a specific language feature using this module. In this case, the check verifies if the compiler supports C++11 lambda expressions. The result is stored in the internal cache variable HAVE_CXX11_LAMBDAS:

include(CheckSourceCompiles)

check_source_compiles(CXX "
  int main()
  {
    auto lambda = []() { return 42; };
    return lambda();
  }
" HAVE_CXX11_LAMBDAS)

Example: Checking Code With Bracket Argument

The following example shows how to check whether the C compiler supports the noreturn attribute. Code is supplied using the Bracket Argument for easier embedded quotes handling:

include(CheckSourceCompiles)

check_source_compiles(C [[
  #if !__has_c_attribute(noreturn)
  #  error "No noreturn attribute"
  #endif
  int main(void) { return 0; }
]] HAVE_NORETURN)

Example: Performing a Check Without Linking

In the following example, this module is used to perform a compile-only check of Fortran source code, whether the compiler supports the pure procedure attribute:

include(CheckSourceCompiles)

block()
  set(CMAKE_TRY_COMPILE_TARGET_TYPE "STATIC_LIBRARY")

  check_source_compiles(
    Fortran
    "pure subroutine foo()
    end subroutine"
    HAVE_PURE
  )
endblock()

Example: Isolated Check

In the following example, this module is used in combination with the CMakePushCheckState module to modify required libraries when checking whether the PostgreSQL PGVerbosity enum contains PQERRORS_SQLSTATE (available as of PostgreSQL version 12):

include(CheckSourceCompiles)
include(CMakePushCheckState)

find_package(PostgreSQL)

if(TARGET PostgreSQL::PostgreSQL)
  cmake_push_check_state(RESET)
    set(CMAKE_REQUIRED_LIBRARIES PostgreSQL::PostgreSQL)

    check_source_compiles(C "
      #include <libpq-fe.h>
      int main(void)
      {
        PGVerbosity e = PQERRORS_SQLSTATE;
        (void)e;
        return 0;
      }
    " HAVE_PQERRORS_SQLSTATE)
  cmake_pop_check_state()
endif()

See Also

• The CheckSourceRuns module to check whether the source code can be built and also run.