CheckFunctionExists — CMake 4.4.20260621-gcc70e9e-dirty Documentation

# CheckFunctionExists

This module provides a command to check whether a C function exists.

Load this module in a CMake project with:

    include(CheckFunctionExists)

## Commands

This module provides the following command:

check_function_exists

  Checks once whether a C function can be linked from system libraries:

      check_function_exists(<function> <variable>)

  This command checks whether the `<function>` is provided by libraries on the system, and stores the result in an internal cache variable `<variable>`.

  Note

  Prefer using `CheckSymbolExists` or `CheckSourceCompiles` instead of this command, for the following reasons:

  - `check_function_exists()` can't detect functions that are inlined in headers or defined as preprocessor macros.

  - `check_function_exists()` can't detect anything in the 32-bit versions of the Win32 API, because of a mismatch in calling conventions.

  - `check_function_exists()` only verifies linking, it does not verify that the function is declared in system headers.

  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.

## Examples

### Example: Basic Usage

In the following example, a check is performed to determine whether the linker sees the C function `fopen()`, and the result is stored in the `HAVE_FOPEN` internal cache variable:

    include(CheckFunctionExists)

    check_function_exists(fopen HAVE_FOPEN)

### Example: Missing Declaration

As noted above, the `CheckSymbolExists` module is preferred for checking C functions, since it also verifies whether the function is declared or defined as a macro. In the following example, this module is used to check an edge case where a function may not be declared in system headers. For instance, on macOS, the `fdatasync()` function may be available in the C library, but its declaration is not provided in the `unistd.h` system header.

`CMakeLists.txt`

    include(CheckFunctionExists)
    include(CheckSymbolExists)

    check_symbol_exists(fdatasync "unistd.h" HAVE_FDATASYNC)

    # Check if fdatasync() is available in the C library.
    if(NOT HAVE_FDATASYNC)
      check_function_exists(fdatasync HAVE_FDATASYNC_WITHOUT_DECL)
    endif()

In such a case, the project can provide its own declaration if missing:

`example.c`

    #ifdef HAVE_FDATASYNC_WITHOUT_DECL
      extern int fdatasync(int);
    #endif

## See Also

- The `CheckSymbolExists` module to check whether a C symbol exists.

- The `CheckSourceCompiles` module to check whether a source code can be compiled.

- The `CheckFortranFunctionExists` module to check whether a Fortran function exists.