CheckTypeSize — CMake 4.1.1 Documentation

# CheckTypeSize

This module provides a command to check the size of a C/C++ type or expression.

Load this module in a CMake project with:

    include(CheckTypeSize)

## Commands

This module provides the following command:

check_type_size

  Checks once whether the C/C++ type or expression exists and determines its size:

      check_type_size(<type> <variable> [BUILTIN_TYPES_ONLY] [LANGUAGE <language>])

  The arguments are:

  `<type>`

    The type or expression being checked.

  `<variable>`

    The name of the variable and a prefix used for storing the check results.

  `BUILTIN_TYPES_ONLY`

    If given, only compiler-builtin types will be supported in the check. If not given, the command checks for common headers `<sys/types.h>`, `<stdint.h>`, and `<stddef.h>`, and saves results in `HAVE_SYS_TYPES_H`, `HAVE_STDINT_H`, and `HAVE_STDDEF_H` internal cache variables. The type size check automatically includes the available headers, thus supporting checks of types defined in the headers.

  `LANGUAGE <language>`

    Uses the `<language>` compiler to perform the check. Acceptable values are `C` and `CXX`. If not specified, it defaults to `C`.

  Result Variables

  Results are reported in the following variables:

  `HAVE_<variable>`

    Internal cache variable that holds a boolean true or false value indicating whether the type or expression `<type>` exists.

  `<variable>`

    Internal cache variable that holds one of the following values:

    `<size>`

      If the type or expression exists, it will have a non-zero size `<size>` in bytes.

    `0`

      When type has architecture-dependent size; This may occur when `CMAKE_OSX_ARCHITECTURES` has multiple architectures. In this case `<variable>_CODE` contains preprocessor tests mapping from each architecture macro to the corresponding type size. The list of architecture macros is stored in `<variable>_KEYS`, and the value for each key is stored in `<variable>-<key>`.

    "" (empty string)

      When type or expression does not exist.

  `<variable>_CODE`

    CMake variable that holds preprocessor code to define the macro `<variable>` to the size of the type, or to leave the macro undefined if the type does not exist.

  Despite the name of this command, it may also be used to determine the size of more complex expressions. For example, to check the size of a struct member:

      check_type_size("((struct something*)0)->member" SIZEOF_MEMBER)

  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_EXTRA_INCLUDE_FILES`

    A semicolon-separated list of extra header files to include when performing the check.

## Examples

Consider the code:

    include(CheckTypeSize)

    # Check for size of long.
    check_type_size(long SIZEOF_LONG)
    message("HAVE_SIZEOF_LONG: ${HAVE_SIZEOF_LONG}")
    message("SIZEOF_LONG: ${SIZEOF_LONG}")
    message("SIZEOF_LONG_CODE: ${SIZEOF_LONG_CODE}")

On a 64-bit architecture, the output may look something like this:

    HAVE_SIZEOF_LONG: TRUE
    SIZEOF_LONG: 8
    SIZEOF_LONG_CODE: #define SIZEOF_LONG 8

On Apple platforms, when `CMAKE_OSX_ARCHITECTURES` has multiple architectures, types may have architecture-dependent sizes. For example, with the code

    include(CheckTypeSize)

    check_type_size(long SIZEOF_LONG)
    message("HAVE_SIZEOF_LONG: ${HAVE_SIZEOF_LONG}")
    message("SIZEOF_LONG: ${SIZEOF_LONG}")
    foreach(key IN LISTS SIZE_OF_LONG_KEYS)
      message("key: ${key}")
      message("value: ${SIZE_OF_LONG-${key}}")
    endforeach()
    message("SIZEOF_LONG_CODE:
    ${SIZEOF_LONG_CODE}")

the result may be:

    HAVE_SIZEOF_LONG: TRUE
    SIZEOF_LONG: 0
    key: __i386
    value: 4
    key: __x86_64
    value: 8
    SIZEOF_LONG_CODE:
    #if defined(__i386)
    # define SIZE_OF_LONG 4
    #elif defined(__x86_64)
    # define SIZE_OF_LONG 8
    #else
    # error SIZE_OF_LONG unknown
    #endif