From cd8562e8c0dca84e5008171fb24a7fd5abfcc0ea Mon Sep 17 00:00:00 2001 From: Marian Buschsieweke Date: Tue, 22 Oct 2019 23:08:11 +0200 Subject: [PATCH 1/6] sys: Added basic C++ compat for C11 atomics Added a header to allow defining C interfaces using the default C11 atomic types. Those types are however fully opaque and inaccessible from C++, as C11 atomics are completely incompatible with C++. --- sys/include/c11_atomics_compat.hpp | 437 +++++++++++++++++++++++++++++ 1 file changed, 437 insertions(+) create mode 100644 sys/include/c11_atomics_compat.hpp diff --git a/sys/include/c11_atomics_compat.hpp b/sys/include/c11_atomics_compat.hpp new file mode 100644 index 0000000000..fbb6ef1aaf --- /dev/null +++ b/sys/include/c11_atomics_compat.hpp @@ -0,0 +1,437 @@ +/* + * Copyright (C) 2019 Otto-von-Guericke-Universität Magdeburg + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @defgroup sys_c11_atomics_cpp_compat C++ compatibility with C11 atomics + * @ingroup sys + * @brief C++ compatibility of default C11 atomics types + * + * This module provides opaque `typedef`s for each standard C11 atomic type with + * the same size and alignment requirements. The contents of types are not + * accessible to C++ code, but this allows `struct`s to be defined with the + * same memory layout as the C version, so that they can be allocated from C++. + * + * @{ + * + * @file + * @brief C++ compatibility of default C11 atomics types + * + * @author Marian Buschsieweke + */ + +#pragma once + +#include "c11_atomics_compat_cpu.hpp" + +/** + * @brief Initialize an atomic variable + * + * Usage (same syntax as the real C11 atomic initializer): + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * atomic_int foo = ATOMIC_VAR_INIT(42); + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + */ +#define ATOMIC_VAR_INIT(x) { x } + +/** + * @brief Type with the same alignment and size as `atomic_bool` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_BOOL_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_bool; + +/** + * @brief Type with the same alignment and size as `atomic_char` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_CHAR_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_char; + +/** + * @brief Type with the same alignment and size as `atomic_schar` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_SCHAR_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_schar; + +/** + * @brief Type with the same alignment and size as `atomic_uchar` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UCHAR_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uchar; + +/** + * @brief Type with the same alignment and size as `atomic_short` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_SHORT_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_short; + +/** + * @brief Type with the same alignment and size as `atomic_ushort` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_USHORT_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_ushort; + +/** + * @brief Type with the same alignment and size as `atomic_int` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INT_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_int; + +/** + * @brief Type with the same alignment and size as `atomic_uint` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINT_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uint; + +/** + * @brief Type with the same alignment and size as `atomic_long` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_LONG_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_long; + +/** + * @brief Type with the same alignment and size as `atomic_ulong` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_ULONG_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_ulong; + +/** + * @brief Type with the same alignment and size as `atomic_llong` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_LLONG_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_llong; + +/** + * @brief Type with the same alignment and size as `atomic_ullong` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_ULLONG_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_ullong; + +/** + * @brief Type with the same alignment and size as `atomic_int_least8_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_int_least8_t; + +/** + * @brief Type with the same alignment and size as `atomic_uint_least8_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uint_least8_t; + +/** + * @brief Type with the same alignment and size as `atomic_int_least16_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_int_least16_t; + +/** + * @brief Type with the same alignment and size as `atomic_uint_least16_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uint_least16_t; + +/** + * @brief Type with the same alignment and size as `atomic_int_least32_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_int_least32_t; + +/** + * @brief Type with the same alignment and size as `atomic_uint_least32_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uint_least32_t; + +/** + * @brief Type with the same alignment and size as `atomic_int_least64_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_int_least64_t; + +/** + * @brief Type with the same alignment and size as `atomic_uint_least64_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uint_least64_t; + +/** + * @brief Type with the same alignment and size as `atomic_int_fast8_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_int_fast8_t; + +/** + * @brief Type with the same alignment and size as `atomic_uint_fast8_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uint_fast8_t; + +/** + * @brief Type with the same alignment and size as `atomic_int_fast16_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_int_fast16_t; + +/** + * @brief Type with the same alignment and size as `atomic_uint_fast16_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uint_fast16_t; + +/** + * @brief Type with the same alignment and size as `atomic_int_fast32_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_int_fast32_t; + +/** + * @brief Type with the same alignment and size as `atomic_uint_fast32_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uint_fast32_t; + +/** + * @brief Type with the same alignment and size as `atomic_int_fast64_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_int_fast64_t; + +/** + * @brief Type with the same alignment and size as `atomic_uint_fast64_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uint_fast64_t; + +/** + * @brief Type with the same alignment and size as `atomic_intptr_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INTPTR_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_intptr_t; + +/** + * @brief Type with the same alignment and size as `atomic_uintptr_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINTPTR_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uintptr_t; + +/** + * @brief Type with the same alignment and size as `atomic_size_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_SIZE_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_size_t; + +/** + * @brief Type with the same alignment and size as `atomic_intmax_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_INTMAX_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_intmax_t; + +/** + * @brief Type with the same alignment and size as `atomic_uintmax_t` + */ +typedef struct { + /** + * @brief Opaque content placeholder + * + * Access only for initializing from C++ + */ + ATOMIC_UINTMAX_T_SAME_SIZED_TYPE do_not_access_from_cpp; +} atomic_uintmax_t; + +/** @} */ From 809d74bca68ac77faf7f09cf437c8a8299593681 Mon Sep 17 00:00:00 2001 From: Marian Buschsieweke Date: Tue, 22 Oct 2019 23:09:28 +0200 Subject: [PATCH 2/6] dist/tools: Added script for C11 atomics compat Added a script to determine the sizes of the default C11 atomic types and generate an C++ header with preprocessor defines to access the sizes of the types and an integer type of the same size (and therefore alignment requirements). --- .../README.md | 44 ++++++ .../generate_c11_atomics_cpp_compat_header.sh | 137 ++++++++++++++++++ 2 files changed, 181 insertions(+) create mode 100644 dist/tools/generate_c11_atomics_cpp_compat_header/README.md create mode 100755 dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh diff --git a/dist/tools/generate_c11_atomics_cpp_compat_header/README.md b/dist/tools/generate_c11_atomics_cpp_compat_header/README.md new file mode 100644 index 0000000000..8aacc682b5 --- /dev/null +++ b/dist/tools/generate_c11_atomics_cpp_compat_header/README.md @@ -0,0 +1,44 @@ +# Usage + +./generate_c11_atomics_cpp_compat_header.sh [CC [CFLAGS]] + +## Parameter CC + +The C compiler to use to determine the size of the C11 atomics types. If not +given, the environment variable CC is used instead. + +## Parameter CFLAGS + +The CFLAGS to pass to the C compiler during determination of the size of the +C11 atomic types. If not given, the environment variable CFLAGS is used instead. + +# Output + +The script will write the sizes of each type defined in C11 atomics and which +`uint_t` type has the same size as the atomic type. Note that C11 allows +to prefix any type with the `_Atomic` specifier to get an atomic version of it. +This script will only generate entries for the default `typedef`ed types like +`atomic_bool`, `atomic_int`, or `atomic_int_least16_t`. + +The output will look like this: + +``` C++ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh /* +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (4U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint32_t +... +``` diff --git a/dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh b/dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh new file mode 100755 index 0000000000..715a6f29ea --- /dev/null +++ b/dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh @@ -0,0 +1,137 @@ +#!/bin/sh + +TESTFILE=/tmp/riot_are_types_of_same_size_compilation_check.c + +ATOMIC_TYPES=" + atomic_bool + atomic_char + atomic_schar + atomic_uchar + atomic_short + atomic_ushort + atomic_int + atomic_uint + atomic_long + atomic_ulong + atomic_llong + atomic_ullong + atomic_int_least8_t + atomic_uint_least8_t + atomic_int_least16_t + atomic_uint_least16_t + atomic_int_least32_t + atomic_uint_least32_t + atomic_int_least64_t + atomic_uint_least64_t + atomic_int_fast8_t + atomic_uint_fast8_t + atomic_int_fast16_t + atomic_uint_fast16_t + atomic_int_fast32_t + atomic_uint_fast32_t + atomic_int_fast64_t + atomic_uint_fast64_t + atomic_intptr_t + atomic_uintptr_t + atomic_size_t + atomic_ptrdiff_t + atomic_intmax_t + atomic_uintmax_t + " + +are_types_of_same_size() { + cat > $TESTFILE << EOF +#include +#ifdef __msp430__ +#include +#endif +#include +int main(void) { + _Static_assert(sizeof($1) == sizeof($2), "Assert types are equally sized"); + return 0; +} +EOF + $CC $CFLAGS -o /dev/null -c $TESTFILE 2> /dev/null > /dev/null +} + +get_size() { + if $(are_types_of_same_size $1 uint8_t); then + echo "1" + return + fi + + if $(are_types_of_same_size $1 uint16_t); then + echo "2" + return + fi + + if $(are_types_of_same_size $1 uint32_t); then + echo "4" + return + fi + + if $(are_types_of_same_size $1 uint64_t); then + echo "8" + return + fi + + echo "Failed to determine size of $1" + exit 1 +} + +get_same_sized_type() { + if $(are_types_of_same_size $1 uint8_t); then + echo "uint8_t" + return + fi + + if $(are_types_of_same_size $1 uint16_t); then + echo "uint16_t" + return + fi + + if $(are_types_of_same_size $1 uint32_t); then + echo "uint32_t" + return + fi + + if $(are_types_of_same_size $1 uint64_t); then + echo "uint64_t" + return + fi + + echo "Failed to determine same sized type for $1" + exit 1 +} + +print_defines() { + printf "#define %-48s(%sU)\n" "$(echo $1 | tr [a-z] [A-Z])_SIZE" "$(get_size $1)" + printf "#define %-48s%s\n" "$(echo $1 | tr [a-z] [A-Z])_SAME_SIZED_TYPE" "$(get_same_sized_type $1)" +} + +if [ $# -ge 1 ]; then + if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then + echo "Usage: $0 [CC [CFLAGS]]" + echo "See README.md for more details" + exit 1 + fi + CC="$1" +fi + +if [ $# -ge 2 ]; then + CFLAGS="$2" +fi + +if [ -z "$CC" ]; then + echo "C compiler needs to be specified either as environment variable, or" + echo "as first argument. See README.md for documentation." + exit 1 +fi + +echo "/* This file was automatically generated using $0 */" +echo "#pragma once" +echo + +for atomic_type in $ATOMIC_TYPES; do + print_defines $atomic_type +done From 314184adb5e1690961f9792f13e223fa31c56360 Mon Sep 17 00:00:00 2001 From: Marian Buschsieweke Date: Tue, 22 Oct 2019 23:17:51 +0200 Subject: [PATCH 3/6] cpu: Platform specific C11 atomics compat headers Added headers to define platform specific sizes and types for the C11 atomics compatibility module for C++. --- .../include/c11_atomics_compat_cpu.hpp | 71 +++++++++++++++++++ .../include/c11_atomics_compat_cpu.hpp | 71 +++++++++++++++++++ .../include/c11_atomics_compat_cpu.hpp | 9 +++ .../include/c11_atomics_compat_cpu/gcc.hpp | 71 +++++++++++++++++++ .../include/c11_atomics_compat_cpu/llvm.hpp | 71 +++++++++++++++++++ cpu/esp32/include/c11_atomics_compat_cpu.hpp | 71 +++++++++++++++++++ .../include/c11_atomics_compat_cpu.hpp | 71 +++++++++++++++++++ cpu/fe310/include/c11_atomics_compat_cpu.hpp | 71 +++++++++++++++++++ .../include/c11_atomics_compat_cpu.hpp | 71 +++++++++++++++++++ .../include/c11_atomics_compat_cpu.hpp | 71 +++++++++++++++++++ cpu/native/include/c11_atomics_compat_cpu.hpp | 71 +++++++++++++++++++ 11 files changed, 719 insertions(+) create mode 100644 cpu/arm7_common/include/c11_atomics_compat_cpu.hpp create mode 100644 cpu/atmega_common/include/c11_atomics_compat_cpu.hpp create mode 100644 cpu/cortexm_common/include/c11_atomics_compat_cpu.hpp create mode 100644 cpu/cortexm_common/include/c11_atomics_compat_cpu/gcc.hpp create mode 100644 cpu/cortexm_common/include/c11_atomics_compat_cpu/llvm.hpp create mode 100644 cpu/esp32/include/c11_atomics_compat_cpu.hpp create mode 100644 cpu/esp8266/include/c11_atomics_compat_cpu.hpp create mode 100644 cpu/fe310/include/c11_atomics_compat_cpu.hpp create mode 100644 cpu/mips32r2_common/include/c11_atomics_compat_cpu.hpp create mode 100644 cpu/msp430_common/include/c11_atomics_compat_cpu.hpp create mode 100644 cpu/native/include/c11_atomics_compat_cpu.hpp diff --git a/cpu/arm7_common/include/c11_atomics_compat_cpu.hpp b/cpu/arm7_common/include/c11_atomics_compat_cpu.hpp new file mode 100644 index 0000000000..f6194c9cc4 --- /dev/null +++ b/cpu/arm7_common/include/c11_atomics_compat_cpu.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (4U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_SIZE (4U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (1U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_LEAST8_T_SIZE (1U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (4U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST8_T_SIZE (4U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST16_T_SIZE (4U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST16_T_SIZE (4U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (4U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINTPTR_T_SIZE (4U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_SIZE_T_SIZE (4U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_PTRDIFF_T_SIZE (4U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t diff --git a/cpu/atmega_common/include/c11_atomics_compat_cpu.hpp b/cpu/atmega_common/include/c11_atomics_compat_cpu.hpp new file mode 100644 index 0000000000..62f7386e90 --- /dev/null +++ b/cpu/atmega_common/include/c11_atomics_compat_cpu.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (2U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_SIZE (2U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (1U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_LEAST8_T_SIZE (1U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (1U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_FAST8_T_SIZE (1U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_FAST16_T_SIZE (2U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_FAST16_T_SIZE (2U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (2U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINTPTR_T_SIZE (2U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_SIZE_T_SIZE (2U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_PTRDIFF_T_SIZE (2U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t diff --git a/cpu/cortexm_common/include/c11_atomics_compat_cpu.hpp b/cpu/cortexm_common/include/c11_atomics_compat_cpu.hpp new file mode 100644 index 0000000000..1a259f35e0 --- /dev/null +++ b/cpu/cortexm_common/include/c11_atomics_compat_cpu.hpp @@ -0,0 +1,9 @@ +#pragma once + +#if defined(__clang__) +#include "c11_atomics_compat_cpu/llvm.hpp" +#elif defined(__GNUC__) +#include "c11_atomics_compat_cpu/gcc.hpp" +#else +#error "No support for C11 atomics compatibility with C++ for your compiler" +#endif diff --git a/cpu/cortexm_common/include/c11_atomics_compat_cpu/gcc.hpp b/cpu/cortexm_common/include/c11_atomics_compat_cpu/gcc.hpp new file mode 100644 index 0000000000..f6194c9cc4 --- /dev/null +++ b/cpu/cortexm_common/include/c11_atomics_compat_cpu/gcc.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (4U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_SIZE (4U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (1U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_LEAST8_T_SIZE (1U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (4U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST8_T_SIZE (4U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST16_T_SIZE (4U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST16_T_SIZE (4U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (4U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINTPTR_T_SIZE (4U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_SIZE_T_SIZE (4U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_PTRDIFF_T_SIZE (4U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t diff --git a/cpu/cortexm_common/include/c11_atomics_compat_cpu/llvm.hpp b/cpu/cortexm_common/include/c11_atomics_compat_cpu/llvm.hpp new file mode 100644 index 0000000000..58d71a9f23 --- /dev/null +++ b/cpu/cortexm_common/include/c11_atomics_compat_cpu/llvm.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (4U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_SIZE (4U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (1U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_LEAST8_T_SIZE (1U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (1U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_FAST8_T_SIZE (1U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_FAST16_T_SIZE (2U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_FAST16_T_SIZE (2U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (4U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINTPTR_T_SIZE (4U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_SIZE_T_SIZE (4U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_PTRDIFF_T_SIZE (4U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t diff --git a/cpu/esp32/include/c11_atomics_compat_cpu.hpp b/cpu/esp32/include/c11_atomics_compat_cpu.hpp new file mode 100644 index 0000000000..f6194c9cc4 --- /dev/null +++ b/cpu/esp32/include/c11_atomics_compat_cpu.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (4U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_SIZE (4U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (1U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_LEAST8_T_SIZE (1U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (4U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST8_T_SIZE (4U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST16_T_SIZE (4U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST16_T_SIZE (4U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (4U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINTPTR_T_SIZE (4U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_SIZE_T_SIZE (4U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_PTRDIFF_T_SIZE (4U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t diff --git a/cpu/esp8266/include/c11_atomics_compat_cpu.hpp b/cpu/esp8266/include/c11_atomics_compat_cpu.hpp new file mode 100644 index 0000000000..f6194c9cc4 --- /dev/null +++ b/cpu/esp8266/include/c11_atomics_compat_cpu.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (4U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_SIZE (4U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (1U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_LEAST8_T_SIZE (1U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (4U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST8_T_SIZE (4U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST16_T_SIZE (4U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST16_T_SIZE (4U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (4U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINTPTR_T_SIZE (4U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_SIZE_T_SIZE (4U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_PTRDIFF_T_SIZE (4U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t diff --git a/cpu/fe310/include/c11_atomics_compat_cpu.hpp b/cpu/fe310/include/c11_atomics_compat_cpu.hpp new file mode 100644 index 0000000000..f6194c9cc4 --- /dev/null +++ b/cpu/fe310/include/c11_atomics_compat_cpu.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (4U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_SIZE (4U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (1U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_LEAST8_T_SIZE (1U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (4U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST8_T_SIZE (4U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST16_T_SIZE (4U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST16_T_SIZE (4U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (4U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINTPTR_T_SIZE (4U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_SIZE_T_SIZE (4U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_PTRDIFF_T_SIZE (4U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t diff --git a/cpu/mips32r2_common/include/c11_atomics_compat_cpu.hpp b/cpu/mips32r2_common/include/c11_atomics_compat_cpu.hpp new file mode 100644 index 0000000000..f6194c9cc4 --- /dev/null +++ b/cpu/mips32r2_common/include/c11_atomics_compat_cpu.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (4U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_SIZE (4U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (1U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_LEAST8_T_SIZE (1U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (4U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST8_T_SIZE (4U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST16_T_SIZE (4U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST16_T_SIZE (4U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (4U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINTPTR_T_SIZE (4U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_SIZE_T_SIZE (4U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_PTRDIFF_T_SIZE (4U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t diff --git a/cpu/msp430_common/include/c11_atomics_compat_cpu.hpp b/cpu/msp430_common/include/c11_atomics_compat_cpu.hpp new file mode 100644 index 0000000000..eb6a8fc81e --- /dev/null +++ b/cpu/msp430_common/include/c11_atomics_compat_cpu.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (2U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint16_t +#define ATOMIC_CHAR_SIZE (2U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint16_t +#define ATOMIC_SCHAR_SIZE (2U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UCHAR_SIZE (2U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint16_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (2U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_SIZE (2U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (2U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST8_T_SIZE (2U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (2U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_FAST8_T_SIZE (2U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_FAST16_T_SIZE (2U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_FAST16_T_SIZE (2U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (2U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINTPTR_T_SIZE (2U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_SIZE_T_SIZE (2U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_PTRDIFF_T_SIZE (4U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t diff --git a/cpu/native/include/c11_atomics_compat_cpu.hpp b/cpu/native/include/c11_atomics_compat_cpu.hpp new file mode 100644 index 0000000000..3ac088a469 --- /dev/null +++ b/cpu/native/include/c11_atomics_compat_cpu.hpp @@ -0,0 +1,71 @@ +/* This file was automatically generated using ./dist/tools/generate_c11_atomics_cpp_compat_header/generate_c11_atomics_cpp_compat_header.sh */ +#pragma once + +#define ATOMIC_BOOL_SIZE (1U) +#define ATOMIC_BOOL_SAME_SIZED_TYPE uint8_t +#define ATOMIC_CHAR_SIZE (1U) +#define ATOMIC_CHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SCHAR_SIZE (1U) +#define ATOMIC_SCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UCHAR_SIZE (1U) +#define ATOMIC_UCHAR_SAME_SIZED_TYPE uint8_t +#define ATOMIC_SHORT_SIZE (2U) +#define ATOMIC_SHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_USHORT_SIZE (2U) +#define ATOMIC_USHORT_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_SIZE (4U) +#define ATOMIC_INT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_SIZE (4U) +#define ATOMIC_UINT_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LONG_SIZE (4U) +#define ATOMIC_LONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_ULONG_SIZE (4U) +#define ATOMIC_ULONG_SAME_SIZED_TYPE uint32_t +#define ATOMIC_LLONG_SIZE (8U) +#define ATOMIC_LLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_ULLONG_SIZE (8U) +#define ATOMIC_ULLONG_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_LEAST8_T_SIZE (1U) +#define ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_LEAST8_T_SIZE (1U) +#define ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_LEAST16_T_SIZE (2U) +#define ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_UINT_LEAST16_T_SIZE (2U) +#define ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE uint16_t +#define ATOMIC_INT_LEAST32_T_SIZE (4U) +#define ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_LEAST32_T_SIZE (4U) +#define ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_LEAST64_T_SIZE (8U) +#define ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_LEAST64_T_SIZE (8U) +#define ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INT_FAST8_T_SIZE (1U) +#define ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_UINT_FAST8_T_SIZE (1U) +#define ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE uint8_t +#define ATOMIC_INT_FAST16_T_SIZE (4U) +#define ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST16_T_SIZE (4U) +#define ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST32_T_SIZE (4U) +#define ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINT_FAST32_T_SIZE (4U) +#define ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_INT_FAST64_T_SIZE (8U) +#define ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINT_FAST64_T_SIZE (8U) +#define ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTPTR_T_SIZE (4U) +#define ATOMIC_INTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_UINTPTR_T_SIZE (4U) +#define ATOMIC_UINTPTR_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_SIZE_T_SIZE (4U) +#define ATOMIC_SIZE_T_SAME_SIZED_TYPE uint32_t +#define ATOMIC_PTRDIFF_T_SIZE (8U) +#define ATOMIC_PTRDIFF_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_INTMAX_T_SIZE (8U) +#define ATOMIC_INTMAX_T_SAME_SIZED_TYPE uint64_t +#define ATOMIC_UINTMAX_T_SIZE (8U) +#define ATOMIC_UINTMAX_T_SAME_SIZED_TYPE uint64_t From e0cec17ec8d0d9832fecc041f4ae6d5e48285c7c Mon Sep 17 00:00:00 2001 From: Marian Buschsieweke Date: Tue, 22 Oct 2019 23:36:53 +0200 Subject: [PATCH 4/6] core/rmutex: Made C++ compatible --- core/include/rmutex.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/core/include/rmutex.h b/core/include/rmutex.h index 77553fb405..fc5c67ee81 100644 --- a/core/include/rmutex.h +++ b/core/include/rmutex.h @@ -24,7 +24,11 @@ #define RMUTEX_H #include +#ifdef __cplusplus +#include "c11_atomics_compat.hpp" +#else #include +#endif #include "mutex.h" #include "kernel_types.h" From 707bacc1b733594f6c1899703677289051fe4e06 Mon Sep 17 00:00:00 2001 From: Marian Buschsieweke Date: Tue, 22 Oct 2019 23:37:09 +0200 Subject: [PATCH 5/6] tests/rmutex_cpp: Testing rmutex with C++ Copied test from tests/rmutex, but using C++ instead of C. --- tests/rmutex_cpp/Makefile | 5 ++ tests/rmutex_cpp/Makefile.ci | 16 ++++++ tests/rmutex_cpp/README.md | 86 ++++++++++++++++++++++++++++++ tests/rmutex_cpp/main.cpp | 91 ++++++++++++++++++++++++++++++++ tests/rmutex_cpp/tests/01-run.py | 49 +++++++++++++++++ 5 files changed, 247 insertions(+) create mode 100644 tests/rmutex_cpp/Makefile create mode 100644 tests/rmutex_cpp/Makefile.ci create mode 100644 tests/rmutex_cpp/README.md create mode 100644 tests/rmutex_cpp/main.cpp create mode 100755 tests/rmutex_cpp/tests/01-run.py diff --git a/tests/rmutex_cpp/Makefile b/tests/rmutex_cpp/Makefile new file mode 100644 index 0000000000..028c3d489a --- /dev/null +++ b/tests/rmutex_cpp/Makefile @@ -0,0 +1,5 @@ +include ../Makefile.tests_common + +FEATURES_REQUIRED += cpp + +include $(RIOTBASE)/Makefile.include diff --git a/tests/rmutex_cpp/Makefile.ci b/tests/rmutex_cpp/Makefile.ci new file mode 100644 index 0000000000..64ff268ad7 --- /dev/null +++ b/tests/rmutex_cpp/Makefile.ci @@ -0,0 +1,16 @@ +BOARD_INSUFFICIENT_MEMORY := \ + arduino-duemilanove \ + arduino-leonardo \ + arduino-nano \ + arduino-uno \ + atmega328p \ + i-nucleo-lrwan1 \ + nucleo-f030r8 \ + nucleo-f031k6 \ + nucleo-f042k6 \ + nucleo-l031k6 \ + nucleo-l053r8 \ + stm32f030f4-demo \ + stm32f0discovery \ + stm32l0538-disco \ + # diff --git a/tests/rmutex_cpp/README.md b/tests/rmutex_cpp/README.md new file mode 100644 index 0000000000..55854b418f --- /dev/null +++ b/tests/rmutex_cpp/README.md @@ -0,0 +1,86 @@ +Expected result +=============== + +When successful, you should see 5 different threads printing their +PID, priority and recursion depth. The thread with the lowest priority +should be able to lock (and unlock) the mutex first, followed by the +other threads in the order of their priority (highest next). If two +threads have the same priority the lower thread id should acquire the +lock. The output should look like the following: + +``` +main(): This is RIOT! (Version: xxx) +Recursive Mutex test +Please refer to the README.md for more information + +Recursive Mutex test +Please refer to the README.md for more information + +T3 (prio 6, depth 0): trying to lock rmutex now +T4 (prio 4, depth 0): trying to lock rmutex now +T5 (prio 5, depth 0): trying to lock rmutex now +T6 (prio 2, depth 0): trying to lock rmutex now +T7 (prio 3, depth 0): trying to lock rmutex now +main: unlocking recursive mutex +T6 (prio 2, depth 0): locked rmutex now +T6 (prio 2, depth 1): trying to lock rmutex now +T6 (prio 2, depth 1): locked rmutex now +T6 (prio 2, depth 2): trying to lock rmutex now +T6 (prio 2, depth 2): locked rmutex now +T6 (prio 2, depth 3): trying to lock rmutex now +T6 (prio 2, depth 3): locked rmutex now +T6 (prio 2, depth 3): unlocked rmutex +T6 (prio 2, depth 2): unlocked rmutex +T6 (prio 2, depth 1): unlocked rmutex +T6 (prio 2, depth 0): unlocked rmutex +T7 (prio 3, depth 0): locked rmutex now +T7 (prio 3, depth 1): trying to lock rmutex now +T7 (prio 3, depth 1): locked rmutex now +T7 (prio 3, depth 2): trying to lock rmutex now +T7 (prio 3, depth 2): locked rmutex now +T7 (prio 3, depth 3): trying to lock rmutex now +T7 (prio 3, depth 3): locked rmutex now +T7 (prio 3, depth 4): trying to lock rmutex now +T7 (prio 3, depth 4): locked rmutex now +T7 (prio 3, depth 4): unlocked rmutex +T7 (prio 3, depth 3): unlocked rmutex +T7 (prio 3, depth 2): unlocked rmutex +T7 (prio 3, depth 1): unlocked rmutex +T7 (prio 3, depth 0): unlocked rmutex +T4 (prio 4, depth 0): locked rmutex now +T4 (prio 4, depth 1): trying to lock rmutex now +T4 (prio 4, depth 1): locked rmutex now +T4 (prio 4, depth 2): trying to lock rmutex now +T4 (prio 4, depth 2): locked rmutex now +T4 (prio 4, depth 2): unlocked rmutex +T4 (prio 4, depth 1): unlocked rmutex +T4 (prio 4, depth 0): unlocked rmutex +T5 (prio 5, depth 0): locked rmutex now +T5 (prio 5, depth 1): trying to lock rmutex now +T5 (prio 5, depth 1): locked rmutex now +T5 (prio 5, depth 2): trying to lock rmutex now +T5 (prio 5, depth 2): locked rmutex now +T5 (prio 5, depth 2): unlocked rmutex +T5 (prio 5, depth 1): unlocked rmutex +T5 (prio 5, depth 0): unlocked rmutex +T3 (prio 6, depth 0): locked rmutex now +T3 (prio 6, depth 1): trying to lock rmutex now +T3 (prio 6, depth 1): locked rmutex now +T3 (prio 6, depth 2): trying to lock rmutex now +T3 (prio 6, depth 2): locked rmutex now +T3 (prio 6, depth 3): trying to lock rmutex now +T3 (prio 6, depth 3): locked rmutex now +T3 (prio 6, depth 4): trying to lock rmutex now +T3 (prio 6, depth 4): locked rmutex now +T3 (prio 6, depth 4): unlocked rmutex +T3 (prio 6, depth 3): unlocked rmutex +T3 (prio 6, depth 2): unlocked rmutex +T3 (prio 6, depth 1): unlocked rmutex +T3 (prio 6, depth 0): unlocked rmutex + +Test END, check the order of priorities above. +``` + +Background +========== +This test application stresses a mutex with a number of threads waiting on it. diff --git a/tests/rmutex_cpp/main.cpp b/tests/rmutex_cpp/main.cpp new file mode 100644 index 0000000000..03004ca933 --- /dev/null +++ b/tests/rmutex_cpp/main.cpp @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2016 Theobroma Systems Design & Consulting GmbH + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @ingroup tests + * @{ + * + * @file + * @brief Test application for testing recursive mutexes + * + * @author Hauke Petersen + * @author Martin Elshuber + * @} + */ + +#include + +#include "rmutex.h" +#include "thread.h" + +#define THREAD_NUMOF (5U) + +extern volatile thread_t *sched_active_thread; + +static char stacks[THREAD_NUMOF][THREAD_STACKSIZE_MAIN]; + +static const char prios[THREAD_NUMOF] = {THREAD_PRIORITY_MAIN - 1, 4, 5, 2, 4}; +static const char depth[THREAD_NUMOF] = {5, 3, 3, 4, 5}; + +static rmutex_t testlock; + +static void lock_recursive(char n, char depth) +{ + volatile thread_t *t = sched_active_thread; + + printf("T%i (prio %i, depth %i): trying to lock rmutex now\n", + (int)t->pid, (int)t->priority, (int)n); + rmutex_lock(&testlock); + + printf("T%i (prio %i, depth %i): locked rmutex now\n", + (int)t->pid, (int)t->priority, (int)n); + + if (n + 1 < depth) + lock_recursive(n + 1, depth); + + thread_yield(); + + rmutex_unlock(&testlock); + + printf("T%i (prio %i, depth %i): unlocked rmutex\n", + (int)t->pid, (int)t->priority, (int)n); +} + +static void *lockme(void *arg) +{ + intptr_t depth = (intptr_t)arg; + + lock_recursive(0, depth); + + return NULL; +} + +int main(void) +{ + puts("Recursive Mutex test"); + puts("Please refer to the README.md for more information\n"); + + rmutex_init(&testlock); + + /* lock mutex, so that spawned threads have to wait */ + rmutex_lock(&testlock); + /* create threads */ + for (unsigned i = 0; i < THREAD_NUMOF; i++) { + thread_create(stacks[i], sizeof(stacks[i]), prios[i], 0, + lockme, (void*)(intptr_t)depth[i], "t"); + } + /* allow threads to lock the mutex */ + printf("main: unlocking recursive mutex\n"); + + rmutex_unlock(&testlock); + + rmutex_lock(&testlock); + puts("\nTest END, check the order of priorities above."); + + return 0; +} diff --git a/tests/rmutex_cpp/tests/01-run.py b/tests/rmutex_cpp/tests/01-run.py new file mode 100755 index 0000000000..e481a2086e --- /dev/null +++ b/tests/rmutex_cpp/tests/01-run.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 + +# Copyright (C) 2016 Theobroma Systems Design & Consulting GmbH +# +# This file is subject to the terms and conditions of the GNU Lesser +# General Public License v2.1. See the file LICENSE in the top level +# directory for more details. + +# Author: Martin Elshuber + +import sys +from testrunner import run + + +thread_prio = { + 3: 6, + 4: 4, + 5: 5, + 6: 2, + 7: 4 + } + +lock_depth = { + 3: 5, + 4: 3, + 5: 3, + 6: 4, + 7: 5 + } + + +def thread_prio_sort(x): + return thread_prio.get(x)*1000 + x + + +def testfunc(child): + for k in thread_prio.keys(): + child.expect(u"T%i \(prio %i, depth 0\): trying to lock rmutex now" % + (k, thread_prio[k])) + + pri_sorted = sorted(thread_prio, key=thread_prio_sort) + for T in pri_sorted: + for depth in range(lock_depth[T]): + child.expect(u"T%i \(prio %i, depth %i\): locked rmutex now" % + (T, thread_prio[T], depth)) + + +if __name__ == "__main__": + sys.exit(run(testfunc)) From a770a919aa7ab0d924b90fc18e5a631498cc287a Mon Sep 17 00:00:00 2001 From: Marian Buschsieweke Date: Wed, 23 Oct 2019 11:00:30 +0200 Subject: [PATCH 6/6] tests/c11_atomics_cpp_compat: Added compile test --- tests/c11_atomics_cpp_compat/Makefile | 9 +++ tests/c11_atomics_cpp_compat/README.md | 7 ++ tests/c11_atomics_cpp_compat/main.c | 97 ++++++++++++++++++++++++++ 3 files changed, 113 insertions(+) create mode 100644 tests/c11_atomics_cpp_compat/Makefile create mode 100644 tests/c11_atomics_cpp_compat/README.md create mode 100644 tests/c11_atomics_cpp_compat/main.c diff --git a/tests/c11_atomics_cpp_compat/Makefile b/tests/c11_atomics_cpp_compat/Makefile new file mode 100644 index 0000000000..c13a51dabb --- /dev/null +++ b/tests/c11_atomics_cpp_compat/Makefile @@ -0,0 +1,9 @@ +include ../Makefile.tests_common + +# As it is a simple compilation test, only the basic modules are needed +DISABLE_MODULE := \ + auto_init \ + core_msg \ + # + +include $(RIOTBASE)/Makefile.include diff --git a/tests/c11_atomics_cpp_compat/README.md b/tests/c11_atomics_cpp_compat/README.md new file mode 100644 index 0000000000..2b062a75f4 --- /dev/null +++ b/tests/c11_atomics_cpp_compat/README.md @@ -0,0 +1,7 @@ +Description +=========== + +This is a simple compile test to verify that the values provided in +`c11_atomics_compat_cpu.hpp` for your CPU are correct. If the application +compiles, everything is fine. There is no point in flashing or running the +application. diff --git a/tests/c11_atomics_cpp_compat/main.c b/tests/c11_atomics_cpp_compat/main.c new file mode 100644 index 0000000000..003fa15974 --- /dev/null +++ b/tests/c11_atomics_cpp_compat/main.c @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2019 Otto-von-Guericke-Universität Magdeburg + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @ingroup tests + * @{ + * + * @file + * @brief Compile test to verify values in c11_atomics_compat_cpu.hpp + * + * @author Marian Buschsieweke + * @} + */ + +#include +#include +#include +#if defined(CPU_CC430) || defined(CPU_ESP8266) || defined(CPU_MSP430FXYZ) +#include +#endif + +/* This file contains only #defines, so it is fully compatible with C */ +#include "c11_atomics_compat_cpu.hpp" + +int main(void) +{ + _Static_assert(ATOMIC_BOOL_SIZE == sizeof(_Atomic(bool)), "Size of type must match define"); + _Static_assert(ATOMIC_CHAR_SIZE == sizeof(_Atomic(char)), "Size of type must match define"); + _Static_assert(ATOMIC_SCHAR_SIZE == sizeof(_Atomic(signed char)), "Size of type must match define"); + _Static_assert(ATOMIC_UCHAR_SIZE == sizeof(_Atomic(unsigned char)), "Size of type must match define"); + _Static_assert(ATOMIC_SHORT_SIZE == sizeof(_Atomic(short)), "Size of type must match define"); + _Static_assert(ATOMIC_USHORT_SIZE == sizeof(_Atomic(unsigned short)), "Size of type must match define"); + _Static_assert(ATOMIC_INT_SIZE == sizeof(_Atomic(int)), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_SIZE == sizeof(_Atomic(unsigned int)), "Size of type must match define"); + _Static_assert(ATOMIC_LONG_SIZE == sizeof(_Atomic(long)), "Size of type must match define"); + _Static_assert(ATOMIC_ULONG_SIZE == sizeof(_Atomic(unsigned long)), "Size of type must match define"); + _Static_assert(ATOMIC_LLONG_SIZE == sizeof(_Atomic(long long)), "Size of type must match define"); + _Static_assert(ATOMIC_ULLONG_SIZE == sizeof(_Atomic(unsigned long long)), "Size of type must match define"); + _Static_assert(ATOMIC_INT_LEAST8_T_SIZE == sizeof(_Atomic(int_least8_t)), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_LEAST8_T_SIZE == sizeof(_Atomic(uint_least8_t)), "Size of type must match define"); + _Static_assert(ATOMIC_INT_LEAST16_T_SIZE == sizeof(_Atomic(int_least16_t)), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_LEAST16_T_SIZE == sizeof(_Atomic(uint_least16_t)), "Size of type must match define"); + _Static_assert(ATOMIC_INT_LEAST32_T_SIZE == sizeof(_Atomic(int_least32_t)), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_LEAST32_T_SIZE == sizeof(_Atomic(uint_least32_t)), "Size of type must match define"); + _Static_assert(ATOMIC_INT_LEAST64_T_SIZE == sizeof(_Atomic(int_least64_t)), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_LEAST64_T_SIZE == sizeof(_Atomic(uint_least64_t)), "Size of type must match define"); + _Static_assert(ATOMIC_INT_FAST8_T_SIZE == sizeof(_Atomic(int_fast8_t)), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_FAST8_T_SIZE == sizeof(_Atomic(uint_fast8_t)), "Size of type must match define"); + _Static_assert(ATOMIC_INT_FAST16_T_SIZE == sizeof(_Atomic(int_fast16_t)), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_FAST16_T_SIZE == sizeof(_Atomic(uint_fast16_t)), "Size of type must match define"); + _Static_assert(ATOMIC_INT_FAST32_T_SIZE == sizeof(_Atomic(int_fast32_t)), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_FAST32_T_SIZE == sizeof(_Atomic(uint_fast32_t)), "Size of type must match define"); + _Static_assert(ATOMIC_INT_FAST64_T_SIZE == sizeof(_Atomic(int_fast64_t)), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_FAST64_T_SIZE == sizeof(_Atomic(uint_fast64_t)), "Size of type must match define"); + _Static_assert(ATOMIC_INTPTR_T_SIZE == sizeof(_Atomic(intptr_t)), "Size of type must match define"); + _Static_assert(ATOMIC_UINTPTR_T_SIZE == sizeof(_Atomic(uintptr_t)), "Size of type must match define"); + _Static_assert(ATOMIC_SIZE_T_SIZE == sizeof(_Atomic(size_t)), "Size of type must match define"); + + _Static_assert(ATOMIC_BOOL_SIZE == sizeof(ATOMIC_BOOL_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_CHAR_SIZE == sizeof(ATOMIC_CHAR_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_SCHAR_SIZE == sizeof(ATOMIC_SCHAR_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UCHAR_SIZE == sizeof(ATOMIC_UCHAR_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_SHORT_SIZE == sizeof(ATOMIC_SHORT_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_USHORT_SIZE == sizeof(ATOMIC_USHORT_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INT_SIZE == sizeof(ATOMIC_INT_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_SIZE == sizeof(ATOMIC_UINT_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_LONG_SIZE == sizeof(ATOMIC_LONG_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_ULONG_SIZE == sizeof(ATOMIC_ULONG_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_LLONG_SIZE == sizeof(ATOMIC_LLONG_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_ULLONG_SIZE == sizeof(ATOMIC_ULLONG_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INT_LEAST8_T_SIZE == sizeof(ATOMIC_INT_LEAST8_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_LEAST8_T_SIZE == sizeof(ATOMIC_UINT_LEAST8_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INT_LEAST16_T_SIZE == sizeof(ATOMIC_INT_LEAST16_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_LEAST16_T_SIZE == sizeof(ATOMIC_UINT_LEAST16_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INT_LEAST32_T_SIZE == sizeof(ATOMIC_INT_LEAST32_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_LEAST32_T_SIZE == sizeof(ATOMIC_UINT_LEAST32_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INT_LEAST64_T_SIZE == sizeof(ATOMIC_INT_LEAST64_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_LEAST64_T_SIZE == sizeof(ATOMIC_UINT_LEAST64_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INT_FAST8_T_SIZE == sizeof(ATOMIC_INT_FAST8_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_FAST8_T_SIZE == sizeof(ATOMIC_UINT_FAST8_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INT_FAST16_T_SIZE == sizeof(ATOMIC_INT_FAST16_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_FAST16_T_SIZE == sizeof(ATOMIC_UINT_FAST16_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INT_FAST32_T_SIZE == sizeof(ATOMIC_INT_FAST32_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_FAST32_T_SIZE == sizeof(ATOMIC_UINT_FAST32_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INT_FAST64_T_SIZE == sizeof(ATOMIC_INT_FAST64_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINT_FAST64_T_SIZE == sizeof(ATOMIC_UINT_FAST64_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_INTPTR_T_SIZE == sizeof(ATOMIC_INTPTR_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_UINTPTR_T_SIZE == sizeof(ATOMIC_UINTPTR_T_SAME_SIZED_TYPE), "Size of type must match define"); + _Static_assert(ATOMIC_SIZE_T_SIZE == sizeof(ATOMIC_SIZE_T_SAME_SIZED_TYPE), "Size of type must match define"); + + return 0; +}