CheckTypeSize — CMake 4.3.2 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>
        <size-var>
        [RESULT_VARIABLE <result-var>]
        [BUILTIN_TYPES_ONLY]
        [LANGUAGE <language>]
      )

  The arguments are:

  `<type>`

    The type or expression being checked.

  `<size-var>`

    The name of the internal cache variable for storing the size of the type or expression `<type>`. This name is also used as a prefix as explained below.

  `RESULT_VARIABLE <result-var>`

    Added in version 4.2.

    The name of the internal cache variable that holds a boolean value indicating whether the type or expression `<type>` exists. If not given, the command will by default define an internal cache variable named `HAVE_<size-var>` instead.

  `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. For C++ `std::` types, `<cstdint>` and `<cstddef>` are also checked with `HAVE_CSTDINT` and `HAVE_CSTDDEF` defined respectively. The command automatically includes the available headers in the type size check, 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:

  `<size-var>`

    Internal cache variable that holds one of the following values:

    `<size>`

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

    `0`

      When the type has an architecture-dependent size; This may occur when `CMAKE_OSX_ARCHITECTURES` has multiple architectures. In this case also the `<size-var>_KEYS` variable is defined and the `<size-var>_CODE` variable contains preprocessor tests mapping as explained below.

    "" (empty string)

      When the type or expression `<type>` does not exist.

  `HAVE_<size-var>`

    Internal cache variable that holds a boolean value indicating whether the type or expression `<type>` exists. This variable is defined when the `RESULT_VARIABLE` argument is not used.

  `<result-var>`

    Added in version 4.2.

    Internal cache variable defined when the `RESULT_VARIABLE` argument is used. It holds a boolean value indicating whether the type or expression `<type>` exists (same value as `HAVE_<size-var>`). In this case, the `HAVE_<size-var>` variable is not defined.

  `<size-var>_CODE`

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

    When the type has an architecture-dependent size (`<size-var>` value is `0`) this variable contains preprocessor tests mapping from each architecture macro to the corresponding type size.

  `<size-var>_KEYS`

    CMake variable that is defined only when the type has an architecture-dependent size (`<size-var>` value is `0`) and contains a list of architecture macros. The value for each key is stored in `<size-var>-<key>` variables.

  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 SIZEOF_LONG_KEYS)
      message("key: ${key}")
      message("value: ${SIZEOF_LONG-${key}}")
    endforeach()
    message("SIZEOF_LONG_CODE:\n${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 SIZEOF_LONG 4
    #elif defined(__x86_64)
    # define SIZEOF_LONG 8
    #else
    # error SIZEOF_LONG unknown
    #endif

### Example: Configuration Header

The next example demonstrates how the result variables can be used in a configuration header:

    include(CheckTypeSize)
    check_type_size(long SIZEOF_LONG)

    configure_file(config.h.in config.h @ONLY)

`config.h.in`

    /* Define whether the type 'long' exists. */
    #cmakedefine HAVE_SIZEOF_LONG

    /* The size of 'long', as computed by sizeof. */
    @SIZEOF_LONG_CODE@

### Example: Checking Complex Expressions

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

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

### Example: Isolated Check

In the following example, the check is performed with temporarily modified additional headers using the `CMAKE_EXTRA_INCLUDE_FILES` variable and `CMakePushCheckState` module. The result of the check is stored in `HAVE_SIZEOF_UNION_SEMUN`, and size is stored in `SIZEOF_UNION_SEMUN` internal cache variables.

    include(CheckTypeSize)
    include(CMakePushCheckState)

    cmake_push_check_state(RESET)
      set(CMAKE_EXTRA_INCLUDE_FILES sys/types.h sys/ipc.h sys/sem.h)
      check_type_size("union semun" SIZEOF_UNION_SEMUN)
    cmake_pop_check_state()

### Example: Customizing Result Variable

Since CMake 4.2, the `HAVE_<size-var>` variable name can be customized using the `RESULT_VARIABLE` argument. In the following example, this module is used to check whether the `struct flock` exists, and the result is stored in the `MyProj_HAVE_STRUCT_FLOCK` internal cache variable:

    cmake_minimum_required(VERSION 4.2)

    # ...

    include(CheckTypeSize)
    include(CMakePushCheckState)

    cmake_push_check_state(RESET)
      set(CMAKE_EXTRA_INCLUDE_FILES "fcntl.h")

      check_type_size(
        "struct flock"
        MyProj_SIZEOF_STRUCT_FLOCK
        RESULT_VARIABLE MyProj_HAVE_STRUCT_FLOCK
      )
    cmake_pop_check_state()