894 lines · c
1// RUN: %clang_cc1 %s -verify=expected,fp80,noi128 -fgnuc-version=4.2.1 -ffreestanding \2// RUN: -Wno-default-const-init-unsafe -fsyntax-only -triple=i686-linux-gnu -std=c113// RUN: %clang_cc1 %s -verify=expected,noi128 -fgnuc-version=4.2.1 -ffreestanding \4// RUN: -Wno-default-const-init-unsafe -fsyntax-only -triple=i686-linux-android -std=c115// RUN: %clang_cc1 %s -verify -fgnuc-version=4.2.1 -ffreestanding \6// RUN: -Wno-default-const-init-unsafe -fsyntax-only -triple=powerpc64-linux-gnu -std=c117// RUN: %clang_cc1 %s -verify -fgnuc-version=4.2.1 -ffreestanding \8// RUN: -Wno-default-const-init-unsafe -fsyntax-only -triple=powerpc64-linux-gnu -std=c11 \9// RUN: -target-cpu pwr710// RUN: %clang_cc1 %s -verify -fgnuc-version=4.2.1 -ffreestanding \11// RUN: -Wno-default-const-init-unsafe -fsyntax-only -triple=powerpc64le-linux-gnu -std=c11 \12// RUN: -target-cpu pwr8 -DPPC64_PWR813// RUN: %clang_cc1 %s -verify -fgnuc-version=4.2.1 -ffreestanding \14// RUN: -Wno-default-const-init-unsafe -fsyntax-only -triple=powerpc64-unknown-aix -std=c11 \15// RUN: -target-cpu pwr816// RUN: %clang_cc1 %s -verify -fgnuc-version=4.2.1 -ffreestanding \17// RUN: -Wno-default-const-init-unsafe -fsyntax-only -triple=powerpc64-unknown-aix -std=c11 \18// RUN: -mabi=quadword-atomics -target-cpu pwr8 -DPPC64_PWR819 20// Basic parsing/Sema tests for __c11_atomic_*21 22#include <stdatomic.h>23 24struct S { char c[3]; };25 26_Static_assert(__GCC_ATOMIC_BOOL_LOCK_FREE == 2, "");27_Static_assert(__GCC_ATOMIC_BOOL_LOCK_FREE == __CLANG_ATOMIC_BOOL_LOCK_FREE, "");28_Static_assert(__GCC_ATOMIC_CHAR_LOCK_FREE == 2, "");29_Static_assert(__GCC_ATOMIC_CHAR_LOCK_FREE == __CLANG_ATOMIC_CHAR_LOCK_FREE, "");30_Static_assert(__GCC_ATOMIC_CHAR16_T_LOCK_FREE == 2, "");31_Static_assert(__GCC_ATOMIC_CHAR16_T_LOCK_FREE == __CLANG_ATOMIC_CHAR16_T_LOCK_FREE, "");32_Static_assert(__GCC_ATOMIC_CHAR32_T_LOCK_FREE == 2, "");33_Static_assert(__GCC_ATOMIC_CHAR32_T_LOCK_FREE == __CLANG_ATOMIC_CHAR32_T_LOCK_FREE, "");34_Static_assert(__GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2, "");35_Static_assert(__GCC_ATOMIC_WCHAR_T_LOCK_FREE == __CLANG_ATOMIC_WCHAR_T_LOCK_FREE, "");36_Static_assert(__GCC_ATOMIC_SHORT_LOCK_FREE == 2, "");37_Static_assert(__GCC_ATOMIC_SHORT_LOCK_FREE == __CLANG_ATOMIC_SHORT_LOCK_FREE, "");38_Static_assert(__GCC_ATOMIC_INT_LOCK_FREE == 2, "");39_Static_assert(__GCC_ATOMIC_INT_LOCK_FREE == __CLANG_ATOMIC_INT_LOCK_FREE, "");40_Static_assert(__GCC_ATOMIC_LONG_LOCK_FREE == 2, "");41_Static_assert(__GCC_ATOMIC_LONG_LOCK_FREE == __CLANG_ATOMIC_LONG_LOCK_FREE, "");42_Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 2, "");43_Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == __CLANG_ATOMIC_LLONG_LOCK_FREE, "");44_Static_assert(__GCC_ATOMIC_POINTER_LOCK_FREE == 2, "");45_Static_assert(__GCC_ATOMIC_POINTER_LOCK_FREE == __CLANG_ATOMIC_POINTER_LOCK_FREE, "");46 47_Static_assert(__c11_atomic_is_lock_free(1), "");48_Static_assert(__c11_atomic_is_lock_free(2), "");49_Static_assert(__c11_atomic_is_lock_free(3), ""); // expected-error {{not an integral constant expression}}50_Static_assert(__c11_atomic_is_lock_free(4), "");51_Static_assert(__c11_atomic_is_lock_free(8), "");52#ifndef PPC64_PWR853_Static_assert(__c11_atomic_is_lock_free(16), ""); // expected-error {{not an integral constant expression}}54#else55_Static_assert(__c11_atomic_is_lock_free(16), ""); // expected-no-error56#endif57_Static_assert(__c11_atomic_is_lock_free(17), ""); // expected-error {{not an integral constant expression}}58 59_Static_assert(__atomic_is_lock_free(1, 0), "");60_Static_assert(__atomic_is_lock_free(2, 0), "");61_Static_assert(__atomic_is_lock_free(3, 0), ""); // expected-error {{not an integral constant expression}}62_Static_assert(__atomic_is_lock_free(4, 0), "");63_Static_assert(__atomic_is_lock_free(8, 0), "");64#ifndef PPC64_PWR865_Static_assert(__atomic_is_lock_free(16, 0), ""); // expected-error {{not an integral constant expression}}66#else67_Static_assert(__atomic_is_lock_free(16, 0), ""); // expected-no-error68#endif69_Static_assert(__atomic_is_lock_free(17, 0), ""); // expected-error {{not an integral constant expression}}70 71_Static_assert(atomic_is_lock_free((atomic_char*)0), "");72_Static_assert(atomic_is_lock_free((atomic_short*)0), "");73_Static_assert(atomic_is_lock_free((atomic_int*)0), "");74_Static_assert(atomic_is_lock_free((atomic_long*)0), "");75#ifndef PPC64_PWR876// noi128-error@+1 {{__int128 is not supported on this target}}77_Static_assert(atomic_is_lock_free((_Atomic(__int128)*)0), ""); // expected-error {{not an integral constant expression}}78#else79_Static_assert(atomic_is_lock_free((_Atomic(__int128)*)0), ""); // expected-no-error80#endif81_Static_assert(atomic_is_lock_free(0 + (atomic_char*)0), "");82 83char i8;84short i16;85int i32;86int __attribute__((vector_size(8))) i64;87struct Incomplete *incomplete; // expected-note {{forward declaration of 'struct Incomplete'}}88 89_Static_assert(__atomic_is_lock_free(1, &i8), "");90_Static_assert(__atomic_is_lock_free(1, &i64), "");91_Static_assert(__atomic_is_lock_free(2, &i8), ""); // expected-error {{not an integral constant expression}}92_Static_assert(__atomic_is_lock_free(2, &i16), "");93_Static_assert(__atomic_is_lock_free(2, &i64), "");94_Static_assert(__atomic_is_lock_free(4, &i16), ""); // expected-error {{not an integral constant expression}}95_Static_assert(__atomic_is_lock_free(4, &i32), "");96_Static_assert(__atomic_is_lock_free(4, &i64), "");97_Static_assert(__atomic_is_lock_free(8, &i32), ""); // expected-error {{not an integral constant expression}}98_Static_assert(__atomic_is_lock_free(8, &i64), "");99 100_Static_assert(__atomic_always_lock_free(1, 0), "");101_Static_assert(__atomic_always_lock_free(2, 0), "");102_Static_assert(!__atomic_always_lock_free(3, 0), "");103_Static_assert(__atomic_always_lock_free(4, 0), "");104_Static_assert(__atomic_always_lock_free(8, 0), "");105#ifndef PPC64_PWR8106_Static_assert(!__atomic_always_lock_free(16, 0), "");107#else108_Static_assert(__atomic_always_lock_free(16, 0), "");109#endif110_Static_assert(!__atomic_always_lock_free(17, 0), "");111 112_Static_assert(__atomic_always_lock_free(1, incomplete), "");113_Static_assert(!__atomic_always_lock_free(2, incomplete), "");114_Static_assert(!__atomic_always_lock_free(4, incomplete), "");115 116_Static_assert(__atomic_always_lock_free(1, &i8), "");117_Static_assert(__atomic_always_lock_free(1, &i64), "");118_Static_assert(!__atomic_always_lock_free(2, &i8), "");119_Static_assert(__atomic_always_lock_free(2, &i16), "");120_Static_assert(__atomic_always_lock_free(2, &i64), "");121_Static_assert(!__atomic_always_lock_free(4, &i16), "");122_Static_assert(__atomic_always_lock_free(4, &i32), "");123_Static_assert(__atomic_always_lock_free(4, &i64), "");124_Static_assert(!__atomic_always_lock_free(8, &i32), "");125_Static_assert(__atomic_always_lock_free(8, &i64), "");126 127// Validate use with fake pointers constants. This mechanism is used to allow128// validating atomicity of a given size and alignment.129_Static_assert(__atomic_is_lock_free(1, (void*)1), "");130_Static_assert(__atomic_is_lock_free(1, (void*)-1), "");131_Static_assert(__atomic_is_lock_free(4, (void*)2), ""); // expected-error {{not an integral constant expression}}132_Static_assert(__atomic_is_lock_free(4, (void*)-2), ""); // expected-error {{not an integral constant expression}}133_Static_assert(__atomic_is_lock_free(4, (void*)4), "");134_Static_assert(__atomic_is_lock_free(4, (void*)-4), "");135 136_Static_assert(__atomic_always_lock_free(1, (void*)1), "");137_Static_assert(__atomic_always_lock_free(1, (void*)-1), "");138_Static_assert(!__atomic_always_lock_free(4, (void*)2), "");139_Static_assert(!__atomic_always_lock_free(4, (void*)-2), "");140_Static_assert(__atomic_always_lock_free(4, (void*)4), "");141_Static_assert(__atomic_always_lock_free(4, (void*)-4), "");142 143// Ensure that "weird" constants don't cause trouble.144_Static_assert(__atomic_always_lock_free(1, "string"), "");145_Static_assert(!__atomic_always_lock_free(2, "string"), "");146_Static_assert(__atomic_always_lock_free(2, (int[2]){}), "");147void dummyfn();148_Static_assert(__atomic_always_lock_free(2, dummyfn) || 1, "");149 150 151 152#define _AS1 __attribute__((address_space(1)))153#define _AS2 __attribute__((address_space(2)))154 155void f(_Atomic(int) *i, const _Atomic(int) *ci,156 _Atomic(int*) *p, _Atomic(float) *f, _Atomic(double) *d,157 _Atomic(long double) *ld,158 int *I, const int *CI,159 int **P, float *F, double *D, struct S *s1, struct S *s2) {160 __c11_atomic_init(I, 5); // expected-error {{pointer to _Atomic}}161 __c11_atomic_init(ci, 5); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}}162 163 __c11_atomic_load(0); // expected-error {{too few arguments to function}}164 __c11_atomic_load(0,0,0); // expected-error {{too many arguments to function}}165 __c11_atomic_store(0,0,0); // expected-error {{address argument to atomic builtin must be a pointer}}166 __c11_atomic_store((int*)0,0,0); // expected-error {{address argument to atomic operation must be a pointer to _Atomic}}167 __c11_atomic_store(i, 0, memory_order_relaxed);168 __c11_atomic_store(ci, 0, memory_order_relaxed); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}}169 170 __c11_atomic_load(i, memory_order_seq_cst);171 __c11_atomic_load(p, memory_order_seq_cst);172 __c11_atomic_load(f, memory_order_seq_cst);173 __c11_atomic_load(ci, memory_order_seq_cst);174 175 int load_n_1 = __atomic_load_n(I, memory_order_relaxed);176 int *load_n_2 = __atomic_load_n(P, memory_order_relaxed);177 float load_n_3 = __atomic_load_n(D, memory_order_relaxed); // expected-error {{must be a pointer to integer or pointer}}178 __atomic_load_n(s1, memory_order_relaxed); // expected-error {{must be a pointer to integer or pointer}}179 load_n_1 = __atomic_load_n(CI, memory_order_relaxed);180 181 __atomic_load(i, I, memory_order_relaxed); // expected-error {{must be a pointer to a trivially-copyable type}}182 __atomic_load(CI, I, memory_order_relaxed);183 184 __atomic_load(I, i, memory_order_relaxed); // expected-error {{passing '_Atomic(int) *' to parameter of type 'int *'}}185 __atomic_load(I, *P, memory_order_relaxed);186 __atomic_load(I, *P, memory_order_relaxed, 42); // expected-error {{too many arguments}}187 (int)__atomic_load(I, I, memory_order_seq_cst); // expected-error {{operand of type 'void'}}188 __atomic_load(s1, s2, memory_order_acquire);189 __atomic_load(CI, I, memory_order_relaxed);190 __atomic_load(I, CI, memory_order_relaxed); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}191 __atomic_load(CI, CI, memory_order_relaxed); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}192 193 __c11_atomic_store(i, 1, memory_order_seq_cst);194 __c11_atomic_store(p, 1, memory_order_seq_cst); // expected-error {{incompatible integer to pointer conversion}}195 (int)__c11_atomic_store(f, 1, memory_order_seq_cst); // expected-error {{operand of type 'void'}}196 197 __atomic_store_n(I, 4, memory_order_release);198 __atomic_store_n(I, 4.0, memory_order_release);199 __atomic_store_n(CI, 4, memory_order_release); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const int *' invalid)}}200 __atomic_store_n(I, P, memory_order_release); // expected-error {{parameter of type 'int'}}201 __atomic_store_n(i, 1, memory_order_release); // expected-error {{must be a pointer to integer or pointer}}202 __atomic_store_n(s1, *s2, memory_order_release); // expected-error {{must be a pointer to integer or pointer}}203 __atomic_store_n(I, I, memory_order_release); // expected-error {{incompatible pointer to integer conversion passing 'int *' to parameter of type 'int'; dereference with *}}204 205 __atomic_store(I, *P, memory_order_release);206 __atomic_store(CI, I, memory_order_release); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const int *' invalid)}}207 __atomic_store(s1, s2, memory_order_release);208 __atomic_store(i, I, memory_order_release); // expected-error {{trivially-copyable}}209 210 int exchange_1 = __c11_atomic_exchange(i, 1, memory_order_seq_cst);211 int exchange_2 = __c11_atomic_exchange(I, 1, memory_order_seq_cst); // expected-error {{must be a pointer to _Atomic}}212 int exchange_3 = __atomic_exchange_n(i, 1, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}}213 int exchange_4 = __atomic_exchange_n(I, 1, memory_order_seq_cst);214 215 __atomic_exchange(s1, s2, s2, memory_order_seq_cst);216 __atomic_exchange(s1, I, P, memory_order_seq_cst); // expected-error 2{{parameter of type 'struct S *'}}217 (int)__atomic_exchange(s1, s2, s2, memory_order_seq_cst); // expected-error {{operand of type 'void'}}218 __atomic_exchange(I, I, I, memory_order_seq_cst);219 __atomic_exchange(CI, I, I, memory_order_seq_cst); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const int *' invalid)}}220 __atomic_exchange(I, I, CI, memory_order_seq_cst); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}221 222 __c11_atomic_fetch_add(i, 1, memory_order_seq_cst);223 __c11_atomic_fetch_add(p, 1, memory_order_seq_cst);224 __c11_atomic_fetch_add(f, 1.0f, memory_order_seq_cst);225 __c11_atomic_fetch_add(d, 1.0, memory_order_seq_cst);226 __c11_atomic_fetch_add(ld, 1.0, memory_order_seq_cst); // fp80-error {{must be a pointer to atomic integer, pointer or supported floating point type}}227 __c11_atomic_fetch_min(i, 1, memory_order_seq_cst);228 __c11_atomic_fetch_min(p, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer or supported floating point type}}229 __c11_atomic_fetch_min(f, 1.0f, memory_order_seq_cst);230 __c11_atomic_fetch_min(d, 1.0, memory_order_seq_cst);231 __c11_atomic_fetch_min(ld, 1.0, memory_order_seq_cst); // fp80-error {{must be a pointer to atomic integer or supported floating point type}}232 __c11_atomic_fetch_max(i, 1, memory_order_seq_cst);233 __c11_atomic_fetch_max(p, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer or supported floating point type}}234 __c11_atomic_fetch_max(f, 1.0f, memory_order_seq_cst);235 __c11_atomic_fetch_max(d, 1.0, memory_order_seq_cst);236 __c11_atomic_fetch_max(ld, 1.0, memory_order_seq_cst); // fp80-error {{must be a pointer to atomic integer or supported floating point type}}237 238 __atomic_fetch_add(i, 3, memory_order_seq_cst); // expected-error {{pointer to integer, pointer or supported floating point type}}239 __atomic_fetch_sub(I, 3, memory_order_seq_cst);240 __atomic_fetch_sub(P, 3, memory_order_seq_cst);241 __atomic_fetch_sub(F, 3, memory_order_seq_cst);242 __atomic_fetch_sub(s1, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer, pointer or supported floating point type}}243 __atomic_fetch_min(F, 3, memory_order_seq_cst);244 __atomic_fetch_min(D, 3, memory_order_seq_cst);245 __atomic_fetch_max(F, 3, memory_order_seq_cst);246 __atomic_fetch_max(D, 3, memory_order_seq_cst);247 __atomic_fetch_max(P, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer or supported floating point type}}248 __atomic_fetch_max(p, 3); // expected-error {{too few arguments to function call, expected 3, have 2}}249 250 __c11_atomic_fetch_and(i, 1, memory_order_seq_cst);251 __c11_atomic_fetch_and(p, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer}}252 __c11_atomic_fetch_and(f, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer}}253 254 __atomic_fetch_and(i, 3, memory_order_seq_cst); // expected-error {{pointer to integer}}255 __atomic_fetch_or(I, 3, memory_order_seq_cst);256 __atomic_fetch_xor(P, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}}257 __atomic_fetch_or(F, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}}258 __atomic_fetch_and(s1, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}}259 260 _Bool cmpexch_1 = __c11_atomic_compare_exchange_strong(i, I, 1, memory_order_seq_cst, memory_order_seq_cst);261 _Bool cmpexch_2 = __c11_atomic_compare_exchange_strong(p, P, (int*)1, memory_order_seq_cst, memory_order_seq_cst);262 _Bool cmpexch_3 = __c11_atomic_compare_exchange_strong(f, I, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{incompatible pointer types}}263 (void)__c11_atomic_compare_exchange_strong(i, CI, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}264 265 _Bool cmpexchw_1 = __c11_atomic_compare_exchange_weak(i, I, 1, memory_order_seq_cst, memory_order_seq_cst);266 _Bool cmpexchw_2 = __c11_atomic_compare_exchange_weak(p, P, (int*)1, memory_order_seq_cst, memory_order_seq_cst);267 _Bool cmpexchw_3 = __c11_atomic_compare_exchange_weak(f, I, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{incompatible pointer types}}268 (void)__c11_atomic_compare_exchange_weak(i, CI, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}269 270 _Bool cmpexch_4 = __atomic_compare_exchange_n(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst);271 _Bool cmpexch_5 = __atomic_compare_exchange_n(I, P, 5, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{; dereference with *}}272 _Bool cmpexch_6 = __atomic_compare_exchange_n(I, I, P, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{passing 'int **' to parameter of type 'int'}}273 (void)__atomic_compare_exchange_n(CI, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const int *' invalid)}}274 (void)__atomic_compare_exchange_n(I, CI, 5, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}275 276 _Bool cmpexch_7 = __atomic_compare_exchange(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{passing 'int' to parameter of type 'int *'}}277 _Bool cmpexch_8 = __atomic_compare_exchange(I, P, I, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{; dereference with *}}278 _Bool cmpexch_9 = __atomic_compare_exchange(I, I, I, 0, memory_order_seq_cst, memory_order_seq_cst);279 (void)__atomic_compare_exchange(CI, I, I, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const int *' invalid)}}280 (void)__atomic_compare_exchange(I, CI, I, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}281 282 // Pointers to different address spaces are allowed.283 _Bool cmpexch_10 = __c11_atomic_compare_exchange_strong((_Atomic int _AS1 *)0x308, (int _AS2 *)0x309, 1, memory_order_seq_cst, memory_order_seq_cst);284 285 const volatile int flag_k = 0;286 volatile int flag = 0;287 (void)(int)__atomic_test_and_set(&flag_k, memory_order_seq_cst); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const volatile int *' invalid)}}288 (void)(int)__atomic_test_and_set(&flag, memory_order_seq_cst);289 __atomic_clear(&flag_k, memory_order_seq_cst); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const volatile int *' invalid)}}290 __atomic_clear(&flag, memory_order_seq_cst);291 (int)__atomic_clear(&flag, memory_order_seq_cst); // expected-error {{operand of type 'void'}}292 __atomic_clear(0x8000, memory_order_seq_cst); // expected-error {{address argument to atomic builtin must be a pointer ('int' invalid)}}293 __atomic_clear(&flag, memory_order_consume); // expected-warning {{memory order argument to atomic operation is invalid}}294 __atomic_clear(&flag, memory_order_acquire); // expected-warning {{memory order argument to atomic operation is invalid}}295 __atomic_clear(&flag, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}296 _Bool lock;297 __atomic_test_and_set(lock, memory_order_acquire); // expected-error {{address argument to atomic builtin must be a pointer}}298 __atomic_clear(lock, memory_order_release); // expected-error {{address argument to atomic builtin must be a pointer}}299 300 // These intrinsics accept any non-const pointer type (including301 // pointer-to-incomplete), and access the first byte.302 __atomic_test_and_set((void*)0x8000, memory_order_seq_cst);303 __atomic_test_and_set((char*)0x8000, memory_order_seq_cst);304 __atomic_test_and_set((int*)0x8000, memory_order_seq_cst);305 __atomic_test_and_set((struct incomplete*)0x8000, memory_order_seq_cst);306 __atomic_clear((void*)0x8000, memory_order_seq_cst);307 __atomic_clear((char*)0x8000, memory_order_seq_cst);308 __atomic_clear((int*)0x8000, memory_order_seq_cst);309 __atomic_clear((struct incomplete*)0x8000, memory_order_seq_cst);310 311 __c11_atomic_init(ci, 0); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}}312 __c11_atomic_store(ci, 0, memory_order_release); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}}313 __c11_atomic_load(ci, memory_order_acquire);314 315 // Ensure the <stdatomic.h> macros behave appropriately.316 atomic_int n = ATOMIC_VAR_INIT(123);317 atomic_init(&n, 456);318 atomic_init(&n, (void*)0); // expected-error {{passing 'void *' to parameter of type 'int'}}319 320 const atomic_wchar_t cawt;321 atomic_init(&cawt, L'x'); // expected-error {{non-const}}322 atomic_wchar_t awt;323 atomic_init(&awt, L'x');324 325 int x = kill_dependency(12);326 327 atomic_thread_fence(); // expected-error {{too few arguments to function call}}328 atomic_thread_fence(memory_order_seq_cst);329 atomic_signal_fence(memory_order_seq_cst);330 void (*pfn)(memory_order) = &atomic_thread_fence;331 pfn = &atomic_signal_fence;332 333 int k = atomic_load_explicit(&n, memory_order_relaxed);334 atomic_store_explicit(&n, k, memory_order_relaxed);335 atomic_store(&n, atomic_load(&n));336 337 k = atomic_exchange(&n, 72);338 k = atomic_exchange_explicit(&n, k, memory_order_release);339 340 atomic_compare_exchange_strong(&n, k, k); // expected-error {{take the address with &}}341 atomic_compare_exchange_weak(&n, &k, k);342 atomic_compare_exchange_strong_explicit(&n, &k, k, memory_order_seq_cst); // expected-error {{too few arguments}}343 atomic_compare_exchange_weak_explicit(&n, &k, k, memory_order_seq_cst, memory_order_acquire);344 345 atomic_fetch_add(&k, n); // expected-error {{must be a pointer to _Atomic}}346 k = atomic_fetch_add(&n, k);347 k = atomic_fetch_sub(&n, k);348 k = atomic_fetch_and(&n, k);349 k = atomic_fetch_or(&n, k);350 k = atomic_fetch_xor(&n, k);351 k = atomic_fetch_add_explicit(&n, k, memory_order_acquire);352 k = atomic_fetch_sub_explicit(&n, k, memory_order_release);353 k = atomic_fetch_and_explicit(&n, k, memory_order_acq_rel);354 k = atomic_fetch_or_explicit(&n, k, memory_order_consume);355 k = atomic_fetch_xor_explicit(&n, k, memory_order_relaxed);356 357 // C11 7.17.1/4: atomic_flag is a structure type.358 struct atomic_flag must_be_struct = ATOMIC_FLAG_INIT;359 // C11 7.17.8/5 implies that it is also a typedef type.360 atomic_flag guard = ATOMIC_FLAG_INIT;361 _Bool old_val = atomic_flag_test_and_set(&guard);362 if (old_val) atomic_flag_clear(&guard);363 364 old_val = (atomic_flag_test_and_set)(&guard);365 if (old_val) (atomic_flag_clear)(&guard);366 367 const atomic_flag const_guard;368 atomic_flag_test_and_set(&const_guard); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const atomic_bool *' (aka 'const _Atomic(_Bool) *') invalid)}}369 atomic_flag_clear(&const_guard); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const atomic_bool *' (aka 'const _Atomic(_Bool) *') invalid)}}370}371 372_Atomic(int*) PR12527_a;373void PR12527(void) { int *b = PR12527_a; }374 375void PR16931(int* x) { // expected-note {{passing argument to parameter 'x' here}}376 typedef struct { _Atomic(_Bool) flag; } flag;377 flag flagvar = { 0 };378 PR16931(&flagvar); // expected-error {{incompatible pointer types}}379}380 381void memory_checks(_Atomic(int) *Ap, int *p, int val) {382 (void)__c11_atomic_load(Ap, memory_order_relaxed);383 (void)__c11_atomic_load(Ap, memory_order_acquire);384 (void)__c11_atomic_load(Ap, memory_order_consume);385 (void)__c11_atomic_load(Ap, memory_order_release); // expected-warning-re {{{{^}}memory order argument to atomic operation is invalid}}386 (void)__c11_atomic_load(Ap, memory_order_acq_rel); // expected-warning-re {{{{^}}memory order argument to atomic operation is invalid}}387 (void)__c11_atomic_load(Ap, memory_order_seq_cst);388 (void)__c11_atomic_load(Ap, val);389 (void)__c11_atomic_load(Ap, -1); // expected-warning-re {{{{^}}memory order argument to atomic operation is invalid}}390 (void)__c11_atomic_load(Ap, 42); // expected-warning-re {{{{^}}memory order argument to atomic operation is invalid}}391 392 (void)__c11_atomic_store(Ap, val, memory_order_relaxed);393 (void)__c11_atomic_store(Ap, val, memory_order_acquire); // expected-warning-re {{{{^}}memory order argument to atomic operation is invalid}}394 (void)__c11_atomic_store(Ap, val, memory_order_consume); // expected-warning-re {{{{^}}memory order argument to atomic operation is invalid}}395 (void)__c11_atomic_store(Ap, val, memory_order_release);396 (void)__c11_atomic_store(Ap, val, memory_order_acq_rel); // expected-warning-re {{{{^}}memory order argument to atomic operation is invalid}}397 (void)__c11_atomic_store(Ap, val, memory_order_seq_cst);398 399 (void)__c11_atomic_fetch_add(Ap, 1, memory_order_relaxed);400 (void)__c11_atomic_fetch_add(Ap, 1, memory_order_acquire);401 (void)__c11_atomic_fetch_add(Ap, 1, memory_order_consume);402 (void)__c11_atomic_fetch_add(Ap, 1, memory_order_release);403 (void)__c11_atomic_fetch_add(Ap, 1, memory_order_acq_rel);404 (void)__c11_atomic_fetch_add(Ap, 1, memory_order_seq_cst);405 406 (void)__c11_atomic_fetch_add(407 (struct Incomplete * _Atomic *)0, // expected-error {{incomplete type 'struct Incomplete'}}408 1, memory_order_seq_cst);409 410 (void)__c11_atomic_init(Ap, val);411 (void)__c11_atomic_init(Ap, val);412 (void)__c11_atomic_init(Ap, val);413 (void)__c11_atomic_init(Ap, val);414 (void)__c11_atomic_init(Ap, val);415 (void)__c11_atomic_init(Ap, val);416 417 (void)__c11_atomic_fetch_sub(Ap, val, memory_order_relaxed);418 (void)__c11_atomic_fetch_sub(Ap, val, memory_order_acquire);419 (void)__c11_atomic_fetch_sub(Ap, val, memory_order_consume);420 (void)__c11_atomic_fetch_sub(Ap, val, memory_order_release);421 (void)__c11_atomic_fetch_sub(Ap, val, memory_order_acq_rel);422 (void)__c11_atomic_fetch_sub(Ap, val, memory_order_seq_cst);423 424 (void)__c11_atomic_fetch_and(Ap, val, memory_order_relaxed);425 (void)__c11_atomic_fetch_and(Ap, val, memory_order_acquire);426 (void)__c11_atomic_fetch_and(Ap, val, memory_order_consume);427 (void)__c11_atomic_fetch_and(Ap, val, memory_order_release);428 (void)__c11_atomic_fetch_and(Ap, val, memory_order_acq_rel);429 (void)__c11_atomic_fetch_and(Ap, val, memory_order_seq_cst);430 431 (void)__c11_atomic_fetch_or(Ap, val, memory_order_relaxed);432 (void)__c11_atomic_fetch_or(Ap, val, memory_order_acquire);433 (void)__c11_atomic_fetch_or(Ap, val, memory_order_consume);434 (void)__c11_atomic_fetch_or(Ap, val, memory_order_release);435 (void)__c11_atomic_fetch_or(Ap, val, memory_order_acq_rel);436 (void)__c11_atomic_fetch_or(Ap, val, memory_order_seq_cst);437 438 (void)__c11_atomic_fetch_xor(Ap, val, memory_order_relaxed);439 (void)__c11_atomic_fetch_xor(Ap, val, memory_order_acquire);440 (void)__c11_atomic_fetch_xor(Ap, val, memory_order_consume);441 (void)__c11_atomic_fetch_xor(Ap, val, memory_order_release);442 (void)__c11_atomic_fetch_xor(Ap, val, memory_order_acq_rel);443 (void)__c11_atomic_fetch_xor(Ap, val, memory_order_seq_cst);444 445 (void)__c11_atomic_fetch_nand(Ap, val, memory_order_relaxed);446 (void)__c11_atomic_fetch_nand(Ap, val, memory_order_acquire);447 (void)__c11_atomic_fetch_nand(Ap, val, memory_order_consume);448 (void)__c11_atomic_fetch_nand(Ap, val, memory_order_release);449 (void)__c11_atomic_fetch_nand(Ap, val, memory_order_acq_rel);450 (void)__c11_atomic_fetch_nand(Ap, val, memory_order_seq_cst);451 452 (void)__c11_atomic_fetch_min(Ap, val, memory_order_relaxed);453 (void)__c11_atomic_fetch_min(Ap, val, memory_order_acquire);454 (void)__c11_atomic_fetch_min(Ap, val, memory_order_consume);455 (void)__c11_atomic_fetch_min(Ap, val, memory_order_release);456 (void)__c11_atomic_fetch_min(Ap, val, memory_order_acq_rel);457 (void)__c11_atomic_fetch_min(Ap, val, memory_order_seq_cst);458 459 (void)__c11_atomic_fetch_max(Ap, val, memory_order_relaxed);460 (void)__c11_atomic_fetch_max(Ap, val, memory_order_acquire);461 (void)__c11_atomic_fetch_max(Ap, val, memory_order_consume);462 (void)__c11_atomic_fetch_max(Ap, val, memory_order_release);463 (void)__c11_atomic_fetch_max(Ap, val, memory_order_acq_rel);464 (void)__c11_atomic_fetch_max(Ap, val, memory_order_seq_cst);465 466 (void)__c11_atomic_exchange(Ap, val, memory_order_relaxed);467 (void)__c11_atomic_exchange(Ap, val, memory_order_acquire);468 (void)__c11_atomic_exchange(Ap, val, memory_order_consume);469 (void)__c11_atomic_exchange(Ap, val, memory_order_release);470 (void)__c11_atomic_exchange(Ap, val, memory_order_acq_rel);471 (void)__c11_atomic_exchange(Ap, val, memory_order_seq_cst);472 473 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, -1, memory_order_relaxed); // expected-warning {{success memory order argument to atomic operation is invalid}}474 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_relaxed, memory_order_relaxed);475 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_acquire, memory_order_relaxed);476 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_consume, memory_order_relaxed);477 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_release, memory_order_relaxed);478 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_acq_rel, memory_order_relaxed);479 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_seq_cst, memory_order_acquire);480 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_seq_cst, memory_order_consume);481 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_seq_cst, memory_order_release); // expected-warning {{failure memory order argument to atomic operation is invalid}}482 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_seq_cst, memory_order_acq_rel); // expected-warning {{failure memory order argument to atomic operation is invalid}}483 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_seq_cst, memory_order_seq_cst);484 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_seq_cst, -1); // expected-warning {{failure memory order argument to atomic operation is invalid}}485 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_relaxed, memory_order_acquire);486 (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_acquire, memory_order_seq_cst);487 488 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, -1, memory_order_relaxed); // expected-warning {{success memory order argument to atomic operation is invalid}}489 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_relaxed, memory_order_relaxed);490 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_acquire, memory_order_relaxed);491 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_consume, memory_order_relaxed);492 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_release, memory_order_relaxed);493 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_acq_rel, memory_order_relaxed);494 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_seq_cst, memory_order_acquire);495 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_seq_cst, memory_order_consume);496 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_seq_cst, memory_order_release); // expected-warning {{failure memory order argument to atomic operation is invalid}}497 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_seq_cst, memory_order_acq_rel); // expected-warning {{failure memory order argument to atomic operation is invalid}}498 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_seq_cst, memory_order_seq_cst);499 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_seq_cst, -1); // expected-warning {{failure memory order argument to atomic operation is invalid}}500 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_relaxed, memory_order_acquire);501 (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_acquire, memory_order_seq_cst);502 503 (void)__atomic_load_n(p, memory_order_relaxed);504 (void)__atomic_load_n(p, memory_order_acquire);505 (void)__atomic_load_n(p, memory_order_consume);506 (void)__atomic_load_n(p, memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}507 (void)__atomic_load_n(p, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}508 (void)__atomic_load_n(p, memory_order_seq_cst);509 510 (void)__atomic_load(p, p, memory_order_relaxed);511 (void)__atomic_load(p, p, memory_order_acquire);512 (void)__atomic_load(p, p, memory_order_consume);513 (void)__atomic_load(p, p, memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}514 (void)__atomic_load(p, p, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}515 (void)__atomic_load(p, p, memory_order_seq_cst);516 517 (void)__atomic_store(p, p, memory_order_relaxed);518 (void)__atomic_store(p, p, memory_order_acquire); // expected-warning {{memory order argument to atomic operation is invalid}}519 (void)__atomic_store(p, p, memory_order_consume); // expected-warning {{memory order argument to atomic operation is invalid}}520 (void)__atomic_store(p, p, memory_order_release);521 (void)__atomic_store(p, p, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}522 (void)__atomic_store(p, p, memory_order_seq_cst);523 524 (void)__atomic_store_n(p, val, memory_order_relaxed);525 (void)__atomic_store_n(p, val, memory_order_acquire); // expected-warning {{memory order argument to atomic operation is invalid}}526 (void)__atomic_store_n(p, val, memory_order_consume); // expected-warning {{memory order argument to atomic operation is invalid}}527 (void)__atomic_store_n(p, val, memory_order_release);528 (void)__atomic_store_n(p, val, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}529 (void)__atomic_store_n(p, val, memory_order_seq_cst);530 531 (void)__atomic_fetch_add(p, val, memory_order_relaxed);532 (void)__atomic_fetch_add(p, val, memory_order_acquire);533 (void)__atomic_fetch_add(p, val, memory_order_consume);534 (void)__atomic_fetch_add(p, val, memory_order_release);535 (void)__atomic_fetch_add(p, val, memory_order_acq_rel);536 (void)__atomic_fetch_add(p, val, memory_order_seq_cst);537 538 (void)__atomic_fetch_sub(p, val, memory_order_relaxed);539 (void)__atomic_fetch_sub(p, val, memory_order_acquire);540 (void)__atomic_fetch_sub(p, val, memory_order_consume);541 (void)__atomic_fetch_sub(p, val, memory_order_release);542 (void)__atomic_fetch_sub(p, val, memory_order_acq_rel);543 (void)__atomic_fetch_sub(p, val, memory_order_seq_cst);544 545 (void)__atomic_add_fetch(p, val, memory_order_relaxed);546 (void)__atomic_add_fetch(p, val, memory_order_acquire);547 (void)__atomic_add_fetch(p, val, memory_order_consume);548 (void)__atomic_add_fetch(p, val, memory_order_release);549 (void)__atomic_add_fetch(p, val, memory_order_acq_rel);550 (void)__atomic_add_fetch(p, val, memory_order_seq_cst);551 552 (void)__atomic_sub_fetch(p, val, memory_order_relaxed);553 (void)__atomic_sub_fetch(p, val, memory_order_acquire);554 (void)__atomic_sub_fetch(p, val, memory_order_consume);555 (void)__atomic_sub_fetch(p, val, memory_order_release);556 (void)__atomic_sub_fetch(p, val, memory_order_acq_rel);557 (void)__atomic_sub_fetch(p, val, memory_order_seq_cst);558 559 (void)__atomic_fetch_and(p, val, memory_order_relaxed);560 (void)__atomic_fetch_and(p, val, memory_order_acquire);561 (void)__atomic_fetch_and(p, val, memory_order_consume);562 (void)__atomic_fetch_and(p, val, memory_order_release);563 (void)__atomic_fetch_and(p, val, memory_order_acq_rel);564 (void)__atomic_fetch_and(p, val, memory_order_seq_cst);565 566 (void)__atomic_fetch_or(p, val, memory_order_relaxed);567 (void)__atomic_fetch_or(p, val, memory_order_acquire);568 (void)__atomic_fetch_or(p, val, memory_order_consume);569 (void)__atomic_fetch_or(p, val, memory_order_release);570 (void)__atomic_fetch_or(p, val, memory_order_acq_rel);571 (void)__atomic_fetch_or(p, val, memory_order_seq_cst);572 573 (void)__atomic_fetch_xor(p, val, memory_order_relaxed);574 (void)__atomic_fetch_xor(p, val, memory_order_acquire);575 (void)__atomic_fetch_xor(p, val, memory_order_consume);576 (void)__atomic_fetch_xor(p, val, memory_order_release);577 (void)__atomic_fetch_xor(p, val, memory_order_acq_rel);578 (void)__atomic_fetch_xor(p, val, memory_order_seq_cst);579 580 (void)__atomic_fetch_nand(p, val, memory_order_relaxed);581 (void)__atomic_fetch_nand(p, val, memory_order_acquire);582 (void)__atomic_fetch_nand(p, val, memory_order_consume);583 (void)__atomic_fetch_nand(p, val, memory_order_release);584 (void)__atomic_fetch_nand(p, val, memory_order_acq_rel);585 (void)__atomic_fetch_nand(p, val, memory_order_seq_cst);586 587 (void)__atomic_fetch_min(p, val, memory_order_relaxed);588 (void)__atomic_fetch_min(p, val, memory_order_acquire);589 (void)__atomic_fetch_min(p, val, memory_order_consume);590 (void)__atomic_fetch_min(p, val, memory_order_release);591 (void)__atomic_fetch_min(p, val, memory_order_acq_rel);592 (void)__atomic_fetch_min(p, val, memory_order_seq_cst);593 594 (void)__atomic_fetch_max(p, val, memory_order_relaxed);595 (void)__atomic_fetch_max(p, val, memory_order_acquire);596 (void)__atomic_fetch_max(p, val, memory_order_consume);597 (void)__atomic_fetch_max(p, val, memory_order_release);598 (void)__atomic_fetch_max(p, val, memory_order_acq_rel);599 (void)__atomic_fetch_max(p, val, memory_order_seq_cst);600 601 (void)__atomic_and_fetch(p, val, memory_order_relaxed);602 (void)__atomic_and_fetch(p, val, memory_order_acquire);603 (void)__atomic_and_fetch(p, val, memory_order_consume);604 (void)__atomic_and_fetch(p, val, memory_order_release);605 (void)__atomic_and_fetch(p, val, memory_order_acq_rel);606 (void)__atomic_and_fetch(p, val, memory_order_seq_cst);607 608 (void)__atomic_or_fetch(p, val, memory_order_relaxed);609 (void)__atomic_or_fetch(p, val, memory_order_acquire);610 (void)__atomic_or_fetch(p, val, memory_order_consume);611 (void)__atomic_or_fetch(p, val, memory_order_release);612 (void)__atomic_or_fetch(p, val, memory_order_acq_rel);613 (void)__atomic_or_fetch(p, val, memory_order_seq_cst);614 615 (void)__atomic_xor_fetch(p, val, memory_order_relaxed);616 (void)__atomic_xor_fetch(p, val, memory_order_acquire);617 (void)__atomic_xor_fetch(p, val, memory_order_consume);618 (void)__atomic_xor_fetch(p, val, memory_order_release);619 (void)__atomic_xor_fetch(p, val, memory_order_acq_rel);620 (void)__atomic_xor_fetch(p, val, memory_order_seq_cst);621 622 (void)__atomic_nand_fetch(p, val, memory_order_relaxed);623 (void)__atomic_nand_fetch(p, val, memory_order_acquire);624 (void)__atomic_nand_fetch(p, val, memory_order_consume);625 (void)__atomic_nand_fetch(p, val, memory_order_release);626 (void)__atomic_nand_fetch(p, val, memory_order_acq_rel);627 (void)__atomic_nand_fetch(p, val, memory_order_seq_cst);628 629 (void)__atomic_max_fetch(p, val, memory_order_relaxed);630 (void)__atomic_max_fetch(p, val, memory_order_acquire);631 (void)__atomic_max_fetch(p, val, memory_order_consume);632 (void)__atomic_max_fetch(p, val, memory_order_release);633 (void)__atomic_max_fetch(p, val, memory_order_acq_rel);634 (void)__atomic_max_fetch(p, val, memory_order_seq_cst);635 636 (void)__atomic_min_fetch(p, val, memory_order_relaxed);637 (void)__atomic_min_fetch(p, val, memory_order_acquire);638 (void)__atomic_min_fetch(p, val, memory_order_consume);639 (void)__atomic_min_fetch(p, val, memory_order_release);640 (void)__atomic_min_fetch(p, val, memory_order_acq_rel);641 (void)__atomic_min_fetch(p, val, memory_order_seq_cst);642 643 (void)__atomic_exchange_n(p, val, memory_order_relaxed);644 (void)__atomic_exchange_n(p, val, memory_order_acquire);645 (void)__atomic_exchange_n(p, val, memory_order_consume);646 (void)__atomic_exchange_n(p, val, memory_order_release);647 (void)__atomic_exchange_n(p, val, memory_order_acq_rel);648 (void)__atomic_exchange_n(p, val, memory_order_seq_cst);649 650 (void)__atomic_exchange(p, p, p, memory_order_relaxed);651 (void)__atomic_exchange(p, p, p, memory_order_acquire);652 (void)__atomic_exchange(p, p, p, memory_order_consume);653 (void)__atomic_exchange(p, p, p, memory_order_release);654 (void)__atomic_exchange(p, p, p, memory_order_acq_rel);655 (void)__atomic_exchange(p, p, p, memory_order_seq_cst);656 657 (void)__atomic_compare_exchange(p, p, p, 0, -1, memory_order_relaxed); // expected-warning {{success memory order argument to atomic operation is invalid}}658 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_relaxed, memory_order_relaxed);659 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_acquire, memory_order_relaxed);660 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_consume, memory_order_relaxed);661 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_release, memory_order_relaxed);662 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_acq_rel, memory_order_relaxed);663 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_seq_cst, memory_order_acquire);664 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_seq_cst, memory_order_consume);665 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_seq_cst, memory_order_release); // expected-warning {{failure memory order argument to atomic operation is invalid}}666 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_seq_cst, memory_order_acq_rel); // expected-warning {{failure memory order argument to atomic operation is invalid}}667 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_seq_cst, memory_order_seq_cst);668 (void)__atomic_compare_exchange(p, p, p, 0, memory_order_seq_cst, -1); // expected-warning {{memory order argument to atomic operation is invalid}}669 670 (void)__atomic_compare_exchange_n(p, p, val, 0, -1, memory_order_relaxed); // expected-warning {{success memory order argument to atomic operation is invalid}}671 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_relaxed, memory_order_relaxed);672 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_acquire, memory_order_relaxed);673 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_consume, memory_order_relaxed);674 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_release, memory_order_relaxed);675 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_acq_rel, memory_order_relaxed);676 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_seq_cst, memory_order_relaxed);677 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_seq_cst, memory_order_acquire);678 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_seq_cst, memory_order_consume);679 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_seq_cst, memory_order_release); // expected-warning {{failure memory order argument to atomic operation is invalid}}680 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_seq_cst, memory_order_acq_rel); // expected-warning {{failure memory order argument to atomic operation is invalid}}681 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_seq_cst, memory_order_seq_cst);682 (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_seq_cst, -1); // expected-warning {{memory order argument to atomic operation is invalid}}683}684 685struct Z {686 char z[];687};688 689void zeroSizeArgError(struct Z *a, struct Z *b, struct Z *c) {690 __atomic_exchange(b, b, c, memory_order_relaxed); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}691 __atomic_exchange(b, b, c, memory_order_acq_rel); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}692 __atomic_exchange(b, b, c, memory_order_acquire); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}693 __atomic_exchange(b, b, c, memory_order_consume); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}694 __atomic_exchange(b, b, c, memory_order_release); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}695 __atomic_exchange(b, b, c, memory_order_seq_cst); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}696 __atomic_load(a, b, memory_order_relaxed); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}697 __atomic_load(a, b, memory_order_acq_rel); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}698 __atomic_load(a, b, memory_order_acquire); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}699 __atomic_load(a, b, memory_order_consume); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}700 __atomic_load(a, b, memory_order_release); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}701 __atomic_load(a, b, memory_order_seq_cst); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}702 __atomic_store(a, b, memory_order_relaxed); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}703 __atomic_store(a, b, memory_order_acq_rel); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}704 __atomic_store(a, b, memory_order_acquire); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}705 __atomic_store(a, b, memory_order_consume); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}706 __atomic_store(a, b, memory_order_release); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}707 __atomic_store(a, b, memory_order_seq_cst); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}708 __atomic_compare_exchange(a, b, c, 0, memory_order_relaxed, memory_order_relaxed); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}709 __atomic_compare_exchange(a, b, c, 0, memory_order_acq_rel, memory_order_acq_rel); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}710 __atomic_compare_exchange(a, b, c, 0, memory_order_acquire, memory_order_acquire); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}711 __atomic_compare_exchange(a, b, c, 0, memory_order_consume, memory_order_consume); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}712 __atomic_compare_exchange(a, b, c, 0, memory_order_release, memory_order_release); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}713 __atomic_compare_exchange(a, b, c, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{address argument to atomic builtin must be a pointer to a non-zero-sized object}}714 715}716 717struct IncompleteTy IncA, IncB, IncC; // expected-error 3{{tentative definition has type 'struct IncompleteTy' that is never completed}} \718 // expected-note 27{{forward declaration of 'struct IncompleteTy'}}719void incompleteTypeArgError() {720 __atomic_exchange(&IncB, &IncB, &IncC, memory_order_relaxed); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}721 __atomic_exchange(&IncB, &IncB, &IncC, memory_order_acq_rel); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}722 __atomic_exchange(&IncB, &IncB, &IncC, memory_order_acquire); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}723 __atomic_exchange(&IncB, &IncB, &IncC, memory_order_consume); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}724 __atomic_exchange(&IncB, &IncB, &IncC, memory_order_release); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}725 __atomic_exchange(&IncB, &IncB, &IncC, memory_order_seq_cst); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}726 __atomic_load(&IncA, &IncB, memory_order_relaxed); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}727 __atomic_load(&IncA, &IncB, memory_order_acq_rel); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}728 __atomic_load(&IncA, &IncB, memory_order_acquire); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}729 __atomic_load(&IncA, &IncB, memory_order_consume); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}730 __atomic_load(&IncA, &IncB, memory_order_release); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}731 __atomic_load(&IncA, &IncB, memory_order_seq_cst); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}732 __atomic_store(&IncA, &IncB, memory_order_relaxed); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}733 __atomic_store(&IncA, &IncB, memory_order_acq_rel); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}734 __atomic_store(&IncA, &IncB, memory_order_acquire); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}735 __atomic_store(&IncA, &IncB, memory_order_consume); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}736 __atomic_store(&IncA, &IncB, memory_order_release); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}737 __atomic_store(&IncA, &IncB, memory_order_seq_cst); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}738 __atomic_compare_exchange(&IncA, &IncB, &IncC, 0, memory_order_relaxed, memory_order_relaxed); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}739 __atomic_compare_exchange(&IncA, &IncB, &IncC, 0, memory_order_acq_rel, memory_order_acq_rel); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}740 __atomic_compare_exchange(&IncA, &IncB, &IncC, 0, memory_order_acquire, memory_order_acquire); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}741 __atomic_compare_exchange(&IncA, &IncB, &IncC, 0, memory_order_consume, memory_order_consume); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}742 __atomic_compare_exchange(&IncA, &IncB, &IncC, 0, memory_order_release, memory_order_release); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}743 __atomic_compare_exchange(&IncA, &IncB, &IncC, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{incomplete type 'struct IncompleteTy' where a complete type is required}}744 745}746 747void nullPointerWarning(void) {748 volatile _Atomic(int) vai;749 _Atomic(int) ai;750 volatile int vi = 42;751 int i = 42;752 volatile _Atomic(int*) vap;753 _Atomic(int*) ap;754 volatile int* vp = NULL;755 int* p = NULL;756 757 __c11_atomic_init((volatile _Atomic(int)*)0, 42); // expected-warning {{null passed to a callee that requires a non-null argument}}758 __c11_atomic_init((_Atomic(int)*)0, 42); // expected-warning {{null passed to a callee that requires a non-null argument}}759 __c11_atomic_store((volatile _Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}760 __c11_atomic_store((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}761 (void)__c11_atomic_load((volatile _Atomic(int)*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}762 (void)__c11_atomic_load((_Atomic(int)*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}763 (void)__c11_atomic_exchange((volatile _Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}764 (void)__c11_atomic_exchange((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}765 (void)__c11_atomic_compare_exchange_weak((volatile _Atomic(int)*)0, &i, 42, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}766 (void)__c11_atomic_compare_exchange_weak((_Atomic(int)*)0, &i, 42, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}767 (void)__c11_atomic_compare_exchange_weak(&vai, (int*)0, 42, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}768 (void)__c11_atomic_compare_exchange_weak(&ai, (int*)0, 42, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}769 (void)__c11_atomic_compare_exchange_strong((volatile _Atomic(int)*)0, &i, 42, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}770 (void)__c11_atomic_compare_exchange_strong((_Atomic(int)*)0, &i, 42, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}771 (void)__c11_atomic_compare_exchange_strong(&vai, (int*)0, 42, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}772 (void)__c11_atomic_compare_exchange_strong(&ai, (int*)0, 42, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}773 (void)__c11_atomic_fetch_add((volatile _Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}774 (void)__c11_atomic_fetch_add((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}775 (void)__c11_atomic_fetch_sub((volatile _Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}776 (void)__c11_atomic_fetch_sub((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}777 (void)__c11_atomic_fetch_and((volatile _Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}778 (void)__c11_atomic_fetch_and((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}779 (void)__c11_atomic_fetch_or((volatile _Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}780 (void)__c11_atomic_fetch_or((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}781 (void)__c11_atomic_fetch_xor((volatile _Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}782 (void)__c11_atomic_fetch_xor((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}783 (void)__c11_atomic_fetch_nand((volatile _Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}784 (void)__c11_atomic_fetch_nand((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}785 786 __atomic_store_n((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}787 __atomic_store_n((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}788 __atomic_store((volatile int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}789 __atomic_store((int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}790 __atomic_store(&vi, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}791 __atomic_store(&i, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}792 (void)__atomic_load_n((volatile int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}793 (void)__atomic_load_n((int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}794 __atomic_load((volatile int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}795 __atomic_load((int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}796 __atomic_load(&vi, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}797 __atomic_load(&i, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}798 (void)__atomic_exchange_n((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}799 (void)__atomic_exchange_n((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}800 __atomic_exchange((volatile int*)0, &i, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}801 __atomic_exchange((int*)0, &i, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}802 __atomic_exchange(&vi, (int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}803 __atomic_exchange(&i, (int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}804 __atomic_exchange(&vi, &i, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}805 __atomic_exchange(&i, &i, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}806 (void)__atomic_compare_exchange_n((volatile int*)0, &i, 42, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}807 (void)__atomic_compare_exchange_n((int*)0, &i, 42, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}808 (void)__atomic_compare_exchange_n(&vi, (int*)0, 42, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}809 (void)__atomic_compare_exchange_n(&i, (int*)0, 42, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}810 (void)__atomic_compare_exchange((volatile int*)0, &i, &i, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}811 (void)__atomic_compare_exchange((int*)0, &i, &i, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}812 (void)__atomic_compare_exchange(&vi, (int*)0, &i, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}813 (void)__atomic_compare_exchange(&i, (int*)0, &i, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}814 (void)__atomic_compare_exchange(&vi, &i, (int*)0, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}815 (void)__atomic_compare_exchange(&i, &i, (int*)0, /*weak=*/0, memory_order_relaxed, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}816 (void)__atomic_fetch_add((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}817 (void)__atomic_fetch_add((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}818 (void)__atomic_fetch_sub((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}819 (void)__atomic_fetch_sub((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}820 (void)__atomic_fetch_and((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}821 (void)__atomic_fetch_and((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}822 (void)__atomic_fetch_or((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}823 (void)__atomic_fetch_or((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}824 (void)__atomic_fetch_xor((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}825 (void)__atomic_fetch_xor((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}826 (void)__atomic_fetch_min((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}827 (void)__atomic_fetch_min((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}828 (void)__atomic_fetch_max((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}829 (void)__atomic_fetch_max((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}830 831 // These don't warn: the "desired" parameter is passed by value. Even for832 // atomic pointers the "desired" result can be NULL.833 __c11_atomic_init(&vai, 0);834 __c11_atomic_init(&ai, 0);835 __c11_atomic_init(&vap, NULL);836 __c11_atomic_init(&ap, NULL);837 __c11_atomic_store(&vai, 0, memory_order_relaxed);838 __c11_atomic_store(&ai, 0, memory_order_relaxed);839 __c11_atomic_store(&vap, NULL, memory_order_relaxed);840 __c11_atomic_store(&ap, NULL, memory_order_relaxed);841 (void)__c11_atomic_exchange(&vai, 0, memory_order_relaxed);842 (void)__c11_atomic_exchange(&ai, 0, memory_order_relaxed);843 (void)__c11_atomic_exchange(&vap, NULL, memory_order_relaxed);844 (void)__c11_atomic_exchange(&ap, NULL, memory_order_relaxed);845 (void)__c11_atomic_compare_exchange_weak(&vai, &i, 0, memory_order_relaxed, memory_order_relaxed);846 (void)__c11_atomic_compare_exchange_weak(&ai, &i, 0, memory_order_relaxed, memory_order_relaxed);847 (void)__c11_atomic_compare_exchange_weak(&vap, &p, NULL, memory_order_relaxed, memory_order_relaxed);848 (void)__c11_atomic_compare_exchange_weak(&ap, &p, NULL, memory_order_relaxed, memory_order_relaxed);849 (void)__c11_atomic_compare_exchange_strong(&vai, &i, 0, memory_order_relaxed, memory_order_relaxed);850 (void)__c11_atomic_compare_exchange_strong(&ai, &i, 0, memory_order_relaxed, memory_order_relaxed);851 (void)__c11_atomic_compare_exchange_strong(&vap, &p, NULL, memory_order_relaxed, memory_order_relaxed);852 (void)__c11_atomic_compare_exchange_strong(&ap, &p, NULL, memory_order_relaxed, memory_order_relaxed);853 (void)__c11_atomic_fetch_add(&vai, 0, memory_order_relaxed);854 (void)__c11_atomic_fetch_add(&ai, 0, memory_order_relaxed);855 (void)__c11_atomic_fetch_sub(&vai, 0, memory_order_relaxed);856 (void)__c11_atomic_fetch_sub(&ai, 0, memory_order_relaxed);857 (void)__c11_atomic_fetch_and(&vai, 0, memory_order_relaxed);858 (void)__c11_atomic_fetch_and(&ai, 0, memory_order_relaxed);859 (void)__c11_atomic_fetch_or(&vai, 0, memory_order_relaxed);860 (void)__c11_atomic_fetch_or(&ai, 0, memory_order_relaxed);861 (void)__c11_atomic_fetch_xor(&vai, 0, memory_order_relaxed);862 (void)__c11_atomic_fetch_xor(&ai, 0, memory_order_relaxed);863 (void)__c11_atomic_fetch_nand(&vai, 0, memory_order_relaxed);864 (void)__c11_atomic_fetch_nand(&ai, 0, memory_order_relaxed);865 866 // Ditto.867 __atomic_store_n(&vi, 0, memory_order_relaxed);868 __atomic_store_n(&i, 0, memory_order_relaxed);869 __atomic_store_n(&vp, NULL, memory_order_relaxed);870 __atomic_store_n(&p, NULL, memory_order_relaxed);871 (void)__atomic_exchange_n(&vi, 0, memory_order_relaxed);872 (void)__atomic_exchange_n(&i, 0, memory_order_relaxed);873 (void)__atomic_exchange_n(&vp, NULL, memory_order_relaxed);874 (void)__atomic_exchange_n(&p, NULL, memory_order_relaxed);875 (void)__atomic_compare_exchange_n(&vi, &i, 0, /*weak=*/0, memory_order_relaxed, memory_order_relaxed);876 (void)__atomic_compare_exchange_n(&i, &i, 0, /*weak=*/0, memory_order_relaxed, memory_order_relaxed);877 (void)__atomic_compare_exchange_n(&vp, &vp, NULL, /*weak=*/0, memory_order_relaxed, memory_order_relaxed);878 (void)__atomic_compare_exchange_n(&p, &p, NULL, /*weak=*/0, memory_order_relaxed, memory_order_relaxed);879 (void)__atomic_fetch_add(&vi, 0, memory_order_relaxed);880 (void)__atomic_fetch_add(&i, 0, memory_order_relaxed);881 (void)__atomic_fetch_sub(&vi, 0, memory_order_relaxed);882 (void)__atomic_fetch_sub(&i, 0, memory_order_relaxed);883 (void)__atomic_fetch_and(&vi, 0, memory_order_relaxed);884 (void)__atomic_fetch_and(&i, 0, memory_order_relaxed);885 (void)__atomic_fetch_or(&vi, 0, memory_order_relaxed);886 (void)__atomic_fetch_or(&i, 0, memory_order_relaxed);887 (void)__atomic_fetch_xor(&vi, 0, memory_order_relaxed);888 (void)__atomic_fetch_xor(&i, 0, memory_order_relaxed);889 (void)__atomic_fetch_min(&vi, 0, memory_order_relaxed);890 (void)__atomic_fetch_min(&i, 0, memory_order_relaxed);891 (void)__atomic_fetch_max(&vi, 0, memory_order_relaxed);892 (void)__atomic_fetch_max(&i, 0, memory_order_relaxed);893}894