Clang Project

clang_source_code/test/Sema/atomic-ops.c
1// RUN: %clang_cc1 %s -verify -ffreestanding -fsyntax-only -triple=i686-linux-gnu -std=c11
2
3// Basic parsing/Sema tests for __c11_atomic_*
4
5#include <stdatomic.h>
6
7struct S { char c[3]; };
8
9_Static_assert(__GCC_ATOMIC_BOOL_LOCK_FREE == 2, "");
10_Static_assert(__GCC_ATOMIC_BOOL_LOCK_FREE == __CLANG_ATOMIC_BOOL_LOCK_FREE, "");
11_Static_assert(__GCC_ATOMIC_CHAR_LOCK_FREE == 2, "");
12_Static_assert(__GCC_ATOMIC_CHAR_LOCK_FREE == __CLANG_ATOMIC_CHAR_LOCK_FREE, "");
13_Static_assert(__GCC_ATOMIC_CHAR16_T_LOCK_FREE == 2, "");
14_Static_assert(__GCC_ATOMIC_CHAR16_T_LOCK_FREE == __CLANG_ATOMIC_CHAR16_T_LOCK_FREE, "");
15_Static_assert(__GCC_ATOMIC_CHAR32_T_LOCK_FREE == 2, "");
16_Static_assert(__GCC_ATOMIC_CHAR32_T_LOCK_FREE == __CLANG_ATOMIC_CHAR32_T_LOCK_FREE, "");
17_Static_assert(__GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2, "");
18_Static_assert(__GCC_ATOMIC_WCHAR_T_LOCK_FREE == __CLANG_ATOMIC_WCHAR_T_LOCK_FREE, "");
19_Static_assert(__GCC_ATOMIC_SHORT_LOCK_FREE == 2, "");
20_Static_assert(__GCC_ATOMIC_SHORT_LOCK_FREE == __CLANG_ATOMIC_SHORT_LOCK_FREE, "");
21_Static_assert(__GCC_ATOMIC_INT_LOCK_FREE == 2, "");
22_Static_assert(__GCC_ATOMIC_INT_LOCK_FREE == __CLANG_ATOMIC_INT_LOCK_FREE, "");
23_Static_assert(__GCC_ATOMIC_LONG_LOCK_FREE == 2, "");
24_Static_assert(__GCC_ATOMIC_LONG_LOCK_FREE == __CLANG_ATOMIC_LONG_LOCK_FREE, "");
25#ifdef __i386__
26_Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 1, "");
27#else
28_Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 2, "");
29#endif
30_Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == __CLANG_ATOMIC_LLONG_LOCK_FREE, "");
31_Static_assert(__GCC_ATOMIC_POINTER_LOCK_FREE == 2, "");
32_Static_assert(__GCC_ATOMIC_POINTER_LOCK_FREE == __CLANG_ATOMIC_POINTER_LOCK_FREE, "");
33
34_Static_assert(__c11_atomic_is_lock_free(1), "");
35_Static_assert(__c11_atomic_is_lock_free(2), "");
36_Static_assert(__c11_atomic_is_lock_free(3), ""); // expected-error {{not an integral constant expression}}
37_Static_assert(__c11_atomic_is_lock_free(4), "");
38_Static_assert(__c11_atomic_is_lock_free(8), "");
39_Static_assert(__c11_atomic_is_lock_free(16), ""); // expected-error {{not an integral constant expression}}
40_Static_assert(__c11_atomic_is_lock_free(17), ""); // expected-error {{not an integral constant expression}}
41
42_Static_assert(__atomic_is_lock_free(1, 0), "");
43_Static_assert(__atomic_is_lock_free(2, 0), "");
44_Static_assert(__atomic_is_lock_free(3, 0), ""); // expected-error {{not an integral constant expression}}
45_Static_assert(__atomic_is_lock_free(4, 0), "");
46_Static_assert(__atomic_is_lock_free(8, 0), "");
47_Static_assert(__atomic_is_lock_free(16, 0), ""); // expected-error {{not an integral constant expression}}
48_Static_assert(__atomic_is_lock_free(17, 0), ""); // expected-error {{not an integral constant expression}}
49
50_Static_assert(atomic_is_lock_free((atomic_char*)0), "");
51_Static_assert(atomic_is_lock_free((atomic_short*)0), "");
52_Static_assert(atomic_is_lock_free((atomic_int*)0), "");
53_Static_assert(atomic_is_lock_free((atomic_long*)0), "");
54// expected-error@+1 {{__int128 is not supported on this target}}
55_Static_assert(atomic_is_lock_free((_Atomic(__int128)*)0), ""); // expected-error {{not an integral constant expression}}
56_Static_assert(atomic_is_lock_free(0 + (atomic_char*)0), "");
57
58char i8;
59short i16;
60int i32;
61int __attribute__((vector_size(8))) i64;
62struct Incomplete *incomplete; // expected-note {{forward declaration of 'struct Incomplete'}}
63
64_Static_assert(__atomic_is_lock_free(1, &i8), "");
65_Static_assert(__atomic_is_lock_free(1, &i64), "");
66_Static_assert(__atomic_is_lock_free(2, &i8), ""); // expected-error {{not an integral constant expression}}
67_Static_assert(__atomic_is_lock_free(2, &i16), "");
68_Static_assert(__atomic_is_lock_free(2, &i64), "");
69_Static_assert(__atomic_is_lock_free(4, &i16), ""); // expected-error {{not an integral constant expression}}
70_Static_assert(__atomic_is_lock_free(4, &i32), "");
71_Static_assert(__atomic_is_lock_free(4, &i64), "");
72_Static_assert(__atomic_is_lock_free(8, &i32), ""); // expected-error {{not an integral constant expression}}
73_Static_assert(__atomic_is_lock_free(8, &i64), "");
74
75_Static_assert(__atomic_always_lock_free(1, 0), "");
76_Static_assert(__atomic_always_lock_free(2, 0), "");
77_Static_assert(!__atomic_always_lock_free(3, 0), "");
78_Static_assert(__atomic_always_lock_free(4, 0), "");
79_Static_assert(__atomic_always_lock_free(8, 0), "");
80_Static_assert(!__atomic_always_lock_free(16, 0), "");
81_Static_assert(!__atomic_always_lock_free(17, 0), "");
82
83_Static_assert(__atomic_always_lock_free(1, incomplete), "");
84_Static_assert(!__atomic_always_lock_free(2, incomplete), "");
85_Static_assert(!__atomic_always_lock_free(4, incomplete), "");
86
87_Static_assert(__atomic_always_lock_free(1, &i8), "");
88_Static_assert(__atomic_always_lock_free(1, &i64), "");
89_Static_assert(!__atomic_always_lock_free(2, &i8), "");
90_Static_assert(__atomic_always_lock_free(2, &i16), "");
91_Static_assert(__atomic_always_lock_free(2, &i64), "");
92_Static_assert(!__atomic_always_lock_free(4, &i16), "");
93_Static_assert(__atomic_always_lock_free(4, &i32), "");
94_Static_assert(__atomic_always_lock_free(4, &i64), "");
95_Static_assert(!__atomic_always_lock_free(8, &i32), "");
96_Static_assert(__atomic_always_lock_free(8, &i64), "");
97
98#define _AS1 __attribute__((address_space(1)))
99#define _AS2 __attribute__((address_space(2)))
100
101void f(_Atomic(int) *i, const _Atomic(int) *ci,
102       _Atomic(int*) *p, _Atomic(float) *d,
103       int *I, const int *CI,
104       int **P, float *D, struct S *s1, struct S *s2) {
105  __c11_atomic_init(I, 5); // expected-error {{pointer to _Atomic}}
106  __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)}}
107
108  __c11_atomic_load(0); // expected-error {{too few arguments to function}}
109  __c11_atomic_load(0,0,0); // expected-error {{too many arguments to function}}
110  __c11_atomic_store(0,0,0); // expected-error {{address argument to atomic builtin must be a pointer}}
111  __c11_atomic_store((int*)0,0,0); // expected-error {{address argument to atomic operation must be a pointer to _Atomic}}
112  __c11_atomic_store(i, 0, memory_order_relaxed);
113  __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)}}
114
115  __c11_atomic_load(i, memory_order_seq_cst);
116  __c11_atomic_load(p, memory_order_seq_cst);
117  __c11_atomic_load(d, memory_order_seq_cst);
118  __c11_atomic_load(ci, memory_order_seq_cst);
119
120  int load_n_1 = __atomic_load_n(I, memory_order_relaxed);
121  int *load_n_2 = __atomic_load_n(P, memory_order_relaxed);
122  float load_n_3 = __atomic_load_n(D, memory_order_relaxed); // expected-error {{must be a pointer to integer or pointer}}
123  __atomic_load_n(s1, memory_order_relaxed); // expected-error {{must be a pointer to integer or pointer}}
124  load_n_1 = __atomic_load_n(CI, memory_order_relaxed);
125
126  __atomic_load(i, I, memory_order_relaxed); // expected-error {{must be a pointer to a trivially-copyable type}}
127  __atomic_load(CI, I, memory_order_relaxed);
128
129  __atomic_load(I, i, memory_order_relaxed); // expected-warning {{passing '_Atomic(int) *' to parameter of type 'int *'}}
130  __atomic_load(I, *P, memory_order_relaxed);
131  __atomic_load(I, *P, memory_order_relaxed, 42); // expected-error {{too many arguments}}
132  (int)__atomic_load(I, I, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
133  __atomic_load(s1, s2, memory_order_acquire);
134  __atomic_load(CI, I, memory_order_relaxed);
135  __atomic_load(I, CI, memory_order_relaxed); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}
136  __atomic_load(CI, CI, memory_order_relaxed); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}
137
138  __c11_atomic_store(i, 1, memory_order_seq_cst);
139  __c11_atomic_store(p, 1, memory_order_seq_cst); // expected-warning {{incompatible integer to pointer conversion}}
140  (int)__c11_atomic_store(d, 1, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
141
142  __atomic_store_n(I, 4, memory_order_release);
143  __atomic_store_n(I, 4.0, memory_order_release);
144  __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)}}
145  __atomic_store_n(I, P, memory_order_release); // expected-warning {{parameter of type 'int'}}
146  __atomic_store_n(i, 1, memory_order_release); // expected-error {{must be a pointer to integer or pointer}}
147  __atomic_store_n(s1, *s2, memory_order_release); // expected-error {{must be a pointer to integer or pointer}}
148  __atomic_store_n(I, I, memory_order_release); // expected-warning {{incompatible pointer to integer conversion passing 'int *' to parameter of type 'int'; dereference with *}}
149
150  __atomic_store(I, *P, memory_order_release);
151  __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)}}
152  __atomic_store(s1, s2, memory_order_release);
153  __atomic_store(i, I, memory_order_release); // expected-error {{trivially-copyable}}
154
155  int exchange_1 = __c11_atomic_exchange(i, 1, memory_order_seq_cst);
156  int exchange_2 = __c11_atomic_exchange(I, 1, memory_order_seq_cst); // expected-error {{must be a pointer to _Atomic}}
157  int exchange_3 = __atomic_exchange_n(i, 1, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}}
158  int exchange_4 = __atomic_exchange_n(I, 1, memory_order_seq_cst);
159
160  __atomic_exchange(s1, s2, s2, memory_order_seq_cst);
161  __atomic_exchange(s1, I, P, memory_order_seq_cst); // expected-warning 2{{parameter of type 'struct S *'}}
162  (int)__atomic_exchange(s1, s2, s2, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
163  __atomic_exchange(I, I, I, memory_order_seq_cst);
164  __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)}}
165  __atomic_exchange(I, I, CI, memory_order_seq_cst); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}
166
167  __c11_atomic_fetch_add(i, 1, memory_order_seq_cst);
168  __c11_atomic_fetch_add(p, 1, memory_order_seq_cst);
169  __c11_atomic_fetch_add(d, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer or pointer}}
170
171  __atomic_fetch_add(i, 3, memory_order_seq_cst); // expected-error {{pointer to integer or pointer}}
172  __atomic_fetch_sub(I, 3, memory_order_seq_cst);
173  __atomic_fetch_sub(P, 3, memory_order_seq_cst);
174  __atomic_fetch_sub(D, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}}
175  __atomic_fetch_sub(s1, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}}
176  __atomic_fetch_min(D, 3, memory_order_seq_cst); // expected-error {{must be a pointer to signed or unsigned 32-bit integer}}
177  __atomic_fetch_max(P, 3, memory_order_seq_cst); // expected-error {{must be a pointer to signed or unsigned 32-bit integer}}
178  __atomic_fetch_max(p, 3);                       // expected-error {{too few arguments to function call, expected 3, have 2}}
179
180  __c11_atomic_fetch_and(i, 1, memory_order_seq_cst);
181  __c11_atomic_fetch_and(p, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer}}
182  __c11_atomic_fetch_and(d, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer}}
183
184  __atomic_fetch_and(i, 3, memory_order_seq_cst); // expected-error {{pointer to integer}}
185  __atomic_fetch_or(I, 3, memory_order_seq_cst);
186  __atomic_fetch_xor(P, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}}
187  __atomic_fetch_or(D, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}}
188  __atomic_fetch_and(s1, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}}
189
190  _Bool cmpexch_1 = __c11_atomic_compare_exchange_strong(i, I, 1, memory_order_seq_cst, memory_order_seq_cst);
191  _Bool cmpexch_2 = __c11_atomic_compare_exchange_strong(p, P, (int*)1, memory_order_seq_cst, memory_order_seq_cst);
192  _Bool cmpexch_3 = __c11_atomic_compare_exchange_strong(d, I, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{incompatible pointer types}}
193  (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}}
194
195  _Bool cmpexchw_1 = __c11_atomic_compare_exchange_weak(i, I, 1, memory_order_seq_cst, memory_order_seq_cst);
196  _Bool cmpexchw_2 = __c11_atomic_compare_exchange_weak(p, P, (int*)1, memory_order_seq_cst, memory_order_seq_cst);
197  _Bool cmpexchw_3 = __c11_atomic_compare_exchange_weak(d, I, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{incompatible pointer types}}
198  (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}}
199
200  _Bool cmpexch_4 = __atomic_compare_exchange_n(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst);
201  _Bool cmpexch_5 = __atomic_compare_exchange_n(I, P, 5, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{; dereference with *}}
202  _Bool cmpexch_6 = __atomic_compare_exchange_n(I, I, P, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'int **' to parameter of type 'int'}}
203  (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)}}
204  (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}}
205
206  _Bool cmpexch_7 = __atomic_compare_exchange(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'int' to parameter of type 'int *'}}
207  _Bool cmpexch_8 = __atomic_compare_exchange(I, P, I, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{; dereference with *}}
208  _Bool cmpexch_9 = __atomic_compare_exchange(I, I, I, 0, memory_order_seq_cst, memory_order_seq_cst);
209  (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)}}
210  (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}}
211
212  // Pointers to different address spaces are allowed.
213  _Bool cmpexch_10 = __c11_atomic_compare_exchange_strong((_Atomic int _AS1 *)0x308, (int _AS2 *)0x309, 1, memory_order_seq_cst, memory_order_seq_cst);
214
215  const volatile int flag_k = 0;
216  volatile int flag = 0;
217  (void)(int)__atomic_test_and_set(&flag_k, memory_order_seq_cst); // expected-warning {{passing 'const volatile int *' to parameter of type 'volatile void *'}}
218  (void)(int)__atomic_test_and_set(&flag, memory_order_seq_cst);
219  __atomic_clear(&flag_k, memory_order_seq_cst); // expected-warning {{passing 'const volatile int *' to parameter of type 'volatile void *'}}
220  __atomic_clear(&flag, memory_order_seq_cst);
221  (int)__atomic_clear(&flag, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
222
223  __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)}}
224  __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)}}
225  __c11_atomic_load(ci, memory_order_acquire);
226
227  // Ensure the <stdatomic.h> macros behave appropriately.
228  atomic_int n = ATOMIC_VAR_INIT(123);
229  atomic_init(&n, 456);
230  atomic_init(&n, (void*)0); // expected-warning {{passing 'void *' to parameter of type 'int'}}
231
232  const atomic_wchar_t cawt;
233  atomic_init(&cawt, L'x'); // expected-error {{non-const}}
234  atomic_wchar_t awt;
235  atomic_init(&awt, L'x');
236
237  int x = kill_dependency(12);
238
239  atomic_thread_fence(); // expected-error {{too few arguments to function call}}
240  atomic_thread_fence(memory_order_seq_cst);
241  atomic_signal_fence(memory_order_seq_cst);
242  void (*pfn)(memory_order) = &atomic_thread_fence;
243  pfn = &atomic_signal_fence;
244
245  int k = atomic_load_explicit(&n, memory_order_relaxed);
246  atomic_store_explicit(&n, k, memory_order_relaxed);
247  atomic_store(&n, atomic_load(&n));
248
249  k = atomic_exchange(&n, 72);
250  k = atomic_exchange_explicit(&n, k, memory_order_release);
251
252  atomic_compare_exchange_strong(&n, k, k); // expected-warning {{take the address with &}}
253  atomic_compare_exchange_weak(&n, &k, k);
254  atomic_compare_exchange_strong_explicit(&n, &k, k, memory_order_seq_cst); // expected-error {{too few arguments}}
255  atomic_compare_exchange_weak_explicit(&n, &k, k, memory_order_seq_cst, memory_order_acquire);
256
257  atomic_fetch_add(&k, n); // expected-error {{must be a pointer to _Atomic}}
258  k = atomic_fetch_add(&n, k);
259  k = atomic_fetch_sub(&n, k);
260  k = atomic_fetch_and(&n, k);
261  k = atomic_fetch_or(&n, k);
262  k = atomic_fetch_xor(&n, k);
263  k = atomic_fetch_add_explicit(&n, k, memory_order_acquire);
264  k = atomic_fetch_sub_explicit(&n, k, memory_order_release);
265  k = atomic_fetch_and_explicit(&n, k, memory_order_acq_rel);
266  k = atomic_fetch_or_explicit(&n, k, memory_order_consume);
267  k = atomic_fetch_xor_explicit(&n, k, memory_order_relaxed);
268
269  // C11 7.17.1/4: atomic_flag is a structure type.
270  struct atomic_flag must_be_struct = ATOMIC_FLAG_INIT;
271  // C11 7.17.8/5 implies that it is also a typedef type.
272  atomic_flag guard = ATOMIC_FLAG_INIT;
273  _Bool old_val = atomic_flag_test_and_set(&guard);
274  if (old_val) atomic_flag_clear(&guard);
275
276  old_val = (atomic_flag_test_and_set)(&guard);
277  if (old_val) (atomic_flag_clear)(&guard);
278
279  const atomic_flag const_guard;
280  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)}}
281  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)}}
282}
283
284_Atomic(int*) PR12527_a;
285void PR12527() { int *b = PR12527_a; }
286
287void PR16931(int* x) { // expected-note {{passing argument to parameter 'x' here}}
288  typedef struct { _Atomic(_Bool) flag; } flag;
289  flag flagvar = { 0 };
290  PR16931(&flagvar); // expected-warning {{incompatible pointer types}}
291}
292
293void memory_checks(_Atomic(int) *Ap, int *p, int val) {
294  (void)__c11_atomic_load(Ap, memory_order_relaxed);
295  (void)__c11_atomic_load(Ap, memory_order_acquire);
296  (void)__c11_atomic_load(Ap, memory_order_consume);
297  (void)__c11_atomic_load(Ap, memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}
298  (void)__c11_atomic_load(Ap, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
299  (void)__c11_atomic_load(Ap, memory_order_seq_cst);
300  (void)__c11_atomic_load(Ap, val);
301  (void)__c11_atomic_load(Ap, -1); // expected-warning {{memory order argument to atomic operation is invalid}}
302  (void)__c11_atomic_load(Ap, 42); // expected-warning {{memory order argument to atomic operation is invalid}}
303
304  (void)__c11_atomic_store(Ap, val, memory_order_relaxed);
305  (void)__c11_atomic_store(Ap, val, memory_order_acquire); // expected-warning {{memory order argument to atomic operation is invalid}}
306  (void)__c11_atomic_store(Ap, val, memory_order_consume); // expected-warning {{memory order argument to atomic operation is invalid}}
307  (void)__c11_atomic_store(Ap, val, memory_order_release);
308  (void)__c11_atomic_store(Ap, val, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
309  (void)__c11_atomic_store(Ap, val, memory_order_seq_cst);
310
311  (void)__c11_atomic_fetch_add(Ap, 1, memory_order_relaxed);
312  (void)__c11_atomic_fetch_add(Ap, 1, memory_order_acquire);
313  (void)__c11_atomic_fetch_add(Ap, 1, memory_order_consume);
314  (void)__c11_atomic_fetch_add(Ap, 1, memory_order_release);
315  (void)__c11_atomic_fetch_add(Ap, 1, memory_order_acq_rel);
316  (void)__c11_atomic_fetch_add(Ap, 1, memory_order_seq_cst);
317
318  (void)__c11_atomic_fetch_add(
319      (struct Incomplete * _Atomic *)0, // expected-error {{incomplete type 'struct Incomplete'}}
320      1, memory_order_seq_cst);
321
322  (void)__c11_atomic_init(Ap, val);
323  (void)__c11_atomic_init(Ap, val);
324  (void)__c11_atomic_init(Ap, val);
325  (void)__c11_atomic_init(Ap, val);
326  (void)__c11_atomic_init(Ap, val);
327  (void)__c11_atomic_init(Ap, val);
328
329  (void)__c11_atomic_fetch_sub(Ap, val, memory_order_relaxed);
330  (void)__c11_atomic_fetch_sub(Ap, val, memory_order_acquire);
331  (void)__c11_atomic_fetch_sub(Ap, val, memory_order_consume);
332  (void)__c11_atomic_fetch_sub(Ap, val, memory_order_release);
333  (void)__c11_atomic_fetch_sub(Ap, val, memory_order_acq_rel);
334  (void)__c11_atomic_fetch_sub(Ap, val, memory_order_seq_cst);
335
336  (void)__c11_atomic_fetch_and(Ap, val, memory_order_relaxed);
337  (void)__c11_atomic_fetch_and(Ap, val, memory_order_acquire);
338  (void)__c11_atomic_fetch_and(Ap, val, memory_order_consume);
339  (void)__c11_atomic_fetch_and(Ap, val, memory_order_release);
340  (void)__c11_atomic_fetch_and(Ap, val, memory_order_acq_rel);
341  (void)__c11_atomic_fetch_and(Ap, val, memory_order_seq_cst);
342
343  (void)__c11_atomic_fetch_or(Ap, val, memory_order_relaxed);
344  (void)__c11_atomic_fetch_or(Ap, val, memory_order_acquire);
345  (void)__c11_atomic_fetch_or(Ap, val, memory_order_consume);
346  (void)__c11_atomic_fetch_or(Ap, val, memory_order_release);
347  (void)__c11_atomic_fetch_or(Ap, val, memory_order_acq_rel);
348  (void)__c11_atomic_fetch_or(Ap, val, memory_order_seq_cst);
349
350  (void)__c11_atomic_fetch_xor(Ap, val, memory_order_relaxed);
351  (void)__c11_atomic_fetch_xor(Ap, val, memory_order_acquire);
352  (void)__c11_atomic_fetch_xor(Ap, val, memory_order_consume);
353  (void)__c11_atomic_fetch_xor(Ap, val, memory_order_release);
354  (void)__c11_atomic_fetch_xor(Ap, val, memory_order_acq_rel);
355  (void)__c11_atomic_fetch_xor(Ap, val, memory_order_seq_cst);
356
357  (void)__c11_atomic_exchange(Ap, val, memory_order_relaxed);
358  (void)__c11_atomic_exchange(Ap, val, memory_order_acquire);
359  (void)__c11_atomic_exchange(Ap, val, memory_order_consume);
360  (void)__c11_atomic_exchange(Ap, val, memory_order_release);
361  (void)__c11_atomic_exchange(Ap, val, memory_order_acq_rel);
362  (void)__c11_atomic_exchange(Ap, val, memory_order_seq_cst);
363
364  (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_relaxed, memory_order_relaxed);
365  (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_acquire, memory_order_relaxed);
366  (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_consume, memory_order_relaxed);
367  (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_release, memory_order_relaxed);
368  (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_acq_rel, memory_order_relaxed);
369  (void)__c11_atomic_compare_exchange_strong(Ap, p, val, memory_order_seq_cst, memory_order_relaxed);
370
371  (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_relaxed, memory_order_relaxed);
372  (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_acquire, memory_order_relaxed);
373  (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_consume, memory_order_relaxed);
374  (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_release, memory_order_relaxed);
375  (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_acq_rel, memory_order_relaxed);
376  (void)__c11_atomic_compare_exchange_weak(Ap, p, val, memory_order_seq_cst, memory_order_relaxed);
377
378  (void)__atomic_load_n(p, memory_order_relaxed);
379  (void)__atomic_load_n(p, memory_order_acquire);
380  (void)__atomic_load_n(p, memory_order_consume);
381  (void)__atomic_load_n(p, memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}
382  (void)__atomic_load_n(p, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
383  (void)__atomic_load_n(p, memory_order_seq_cst);
384
385  (void)__atomic_load(p, p, memory_order_relaxed);
386  (void)__atomic_load(p, p, memory_order_acquire);
387  (void)__atomic_load(p, p, memory_order_consume);
388  (void)__atomic_load(p, p, memory_order_release); // expected-warning {{memory order argument to atomic operation is invalid}}
389  (void)__atomic_load(p, p, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
390  (void)__atomic_load(p, p, memory_order_seq_cst);
391
392  (void)__atomic_store(p, p, memory_order_relaxed);
393  (void)__atomic_store(p, p, memory_order_acquire); // expected-warning {{memory order argument to atomic operation is invalid}}
394  (void)__atomic_store(p, p, memory_order_consume); // expected-warning {{memory order argument to atomic operation is invalid}}
395  (void)__atomic_store(p, p, memory_order_release);
396  (void)__atomic_store(p, p, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
397  (void)__atomic_store(p, p, memory_order_seq_cst);
398
399  (void)__atomic_store_n(p, val, memory_order_relaxed);
400  (void)__atomic_store_n(p, val, memory_order_acquire); // expected-warning {{memory order argument to atomic operation is invalid}}
401  (void)__atomic_store_n(p, val, memory_order_consume); // expected-warning {{memory order argument to atomic operation is invalid}}
402  (void)__atomic_store_n(p, val, memory_order_release);
403  (void)__atomic_store_n(p, val, memory_order_acq_rel); // expected-warning {{memory order argument to atomic operation is invalid}}
404  (void)__atomic_store_n(p, val, memory_order_seq_cst);
405
406  (void)__atomic_fetch_add(p, val, memory_order_relaxed);
407  (void)__atomic_fetch_add(p, val, memory_order_acquire);
408  (void)__atomic_fetch_add(p, val, memory_order_consume);
409  (void)__atomic_fetch_add(p, val, memory_order_release);
410  (void)__atomic_fetch_add(p, val, memory_order_acq_rel);
411  (void)__atomic_fetch_add(p, val, memory_order_seq_cst);
412
413  (void)__atomic_fetch_sub(p, val, memory_order_relaxed);
414  (void)__atomic_fetch_sub(p, val, memory_order_acquire);
415  (void)__atomic_fetch_sub(p, val, memory_order_consume);
416  (void)__atomic_fetch_sub(p, val, memory_order_release);
417  (void)__atomic_fetch_sub(p, val, memory_order_acq_rel);
418  (void)__atomic_fetch_sub(p, val, memory_order_seq_cst);
419
420  (void)__atomic_add_fetch(p, val, memory_order_relaxed);
421  (void)__atomic_add_fetch(p, val, memory_order_acquire);
422  (void)__atomic_add_fetch(p, val, memory_order_consume);
423  (void)__atomic_add_fetch(p, val, memory_order_release);
424  (void)__atomic_add_fetch(p, val, memory_order_acq_rel);
425  (void)__atomic_add_fetch(p, val, memory_order_seq_cst);
426
427  (void)__atomic_sub_fetch(p, val, memory_order_relaxed);
428  (void)__atomic_sub_fetch(p, val, memory_order_acquire);
429  (void)__atomic_sub_fetch(p, val, memory_order_consume);
430  (void)__atomic_sub_fetch(p, val, memory_order_release);
431  (void)__atomic_sub_fetch(p, val, memory_order_acq_rel);
432  (void)__atomic_sub_fetch(p, val, memory_order_seq_cst);
433
434  (void)__atomic_fetch_and(p, val, memory_order_relaxed);
435  (void)__atomic_fetch_and(p, val, memory_order_acquire);
436  (void)__atomic_fetch_and(p, val, memory_order_consume);
437  (void)__atomic_fetch_and(p, val, memory_order_release);
438  (void)__atomic_fetch_and(p, val, memory_order_acq_rel);
439  (void)__atomic_fetch_and(p, val, memory_order_seq_cst);
440
441  (void)__atomic_fetch_or(p, val, memory_order_relaxed);
442  (void)__atomic_fetch_or(p, val, memory_order_acquire);
443  (void)__atomic_fetch_or(p, val, memory_order_consume);
444  (void)__atomic_fetch_or(p, val, memory_order_release);
445  (void)__atomic_fetch_or(p, val, memory_order_acq_rel);
446  (void)__atomic_fetch_or(p, val, memory_order_seq_cst);
447
448  (void)__atomic_fetch_xor(p, val, memory_order_relaxed);
449  (void)__atomic_fetch_xor(p, val, memory_order_acquire);
450  (void)__atomic_fetch_xor(p, val, memory_order_consume);
451  (void)__atomic_fetch_xor(p, val, memory_order_release);
452  (void)__atomic_fetch_xor(p, val, memory_order_acq_rel);
453  (void)__atomic_fetch_xor(p, val, memory_order_seq_cst);
454
455  (void)__atomic_fetch_nand(p, val, memory_order_relaxed);
456  (void)__atomic_fetch_nand(p, val, memory_order_acquire);
457  (void)__atomic_fetch_nand(p, val, memory_order_consume);
458  (void)__atomic_fetch_nand(p, val, memory_order_release);
459  (void)__atomic_fetch_nand(p, val, memory_order_acq_rel);
460  (void)__atomic_fetch_nand(p, val, memory_order_seq_cst);
461
462  (void)__atomic_fetch_min(p, val, memory_order_relaxed);
463  (void)__atomic_fetch_min(p, val, memory_order_acquire);
464  (void)__atomic_fetch_min(p, val, memory_order_consume);
465  (void)__atomic_fetch_min(p, val, memory_order_release);
466  (void)__atomic_fetch_min(p, val, memory_order_acq_rel);
467  (void)__atomic_fetch_min(p, val, memory_order_seq_cst);
468
469  (void)__atomic_fetch_max(p, val, memory_order_relaxed);
470  (void)__atomic_fetch_max(p, val, memory_order_acquire);
471  (void)__atomic_fetch_max(p, val, memory_order_consume);
472  (void)__atomic_fetch_max(p, val, memory_order_release);
473  (void)__atomic_fetch_max(p, val, memory_order_acq_rel);
474  (void)__atomic_fetch_max(p, val, memory_order_seq_cst);
475
476  (void)__atomic_and_fetch(p, val, memory_order_relaxed);
477  (void)__atomic_and_fetch(p, val, memory_order_acquire);
478  (void)__atomic_and_fetch(p, val, memory_order_consume);
479  (void)__atomic_and_fetch(p, val, memory_order_release);
480  (void)__atomic_and_fetch(p, val, memory_order_acq_rel);
481  (void)__atomic_and_fetch(p, val, memory_order_seq_cst);
482
483  (void)__atomic_or_fetch(p, val, memory_order_relaxed);
484  (void)__atomic_or_fetch(p, val, memory_order_acquire);
485  (void)__atomic_or_fetch(p, val, memory_order_consume);
486  (void)__atomic_or_fetch(p, val, memory_order_release);
487  (void)__atomic_or_fetch(p, val, memory_order_acq_rel);
488  (void)__atomic_or_fetch(p, val, memory_order_seq_cst);
489
490  (void)__atomic_xor_fetch(p, val, memory_order_relaxed);
491  (void)__atomic_xor_fetch(p, val, memory_order_acquire);
492  (void)__atomic_xor_fetch(p, val, memory_order_consume);
493  (void)__atomic_xor_fetch(p, val, memory_order_release);
494  (void)__atomic_xor_fetch(p, val, memory_order_acq_rel);
495  (void)__atomic_xor_fetch(p, val, memory_order_seq_cst);
496
497  (void)__atomic_nand_fetch(p, val, memory_order_relaxed);
498  (void)__atomic_nand_fetch(p, val, memory_order_acquire);
499  (void)__atomic_nand_fetch(p, val, memory_order_consume);
500  (void)__atomic_nand_fetch(p, val, memory_order_release);
501  (void)__atomic_nand_fetch(p, val, memory_order_acq_rel);
502  (void)__atomic_nand_fetch(p, val, memory_order_seq_cst);
503
504  (void)__atomic_exchange_n(p, val, memory_order_relaxed);
505  (void)__atomic_exchange_n(p, val, memory_order_acquire);
506  (void)__atomic_exchange_n(p, val, memory_order_consume);
507  (void)__atomic_exchange_n(p, val, memory_order_release);
508  (void)__atomic_exchange_n(p, val, memory_order_acq_rel);
509  (void)__atomic_exchange_n(p, val, memory_order_seq_cst);
510
511  (void)__atomic_exchange(p, p, p, memory_order_relaxed);
512  (void)__atomic_exchange(p, p, p, memory_order_acquire);
513  (void)__atomic_exchange(p, p, p, memory_order_consume);
514  (void)__atomic_exchange(p, p, p, memory_order_release);
515  (void)__atomic_exchange(p, p, p, memory_order_acq_rel);
516  (void)__atomic_exchange(p, p, p, memory_order_seq_cst);
517
518  (void)__atomic_compare_exchange(p, p, p, 0, memory_order_relaxed, memory_order_relaxed);
519  (void)__atomic_compare_exchange(p, p, p, 0, memory_order_acquire, memory_order_relaxed);
520  (void)__atomic_compare_exchange(p, p, p, 0, memory_order_consume, memory_order_relaxed);
521  (void)__atomic_compare_exchange(p, p, p, 0, memory_order_release, memory_order_relaxed);
522  (void)__atomic_compare_exchange(p, p, p, 0, memory_order_acq_rel, memory_order_relaxed);
523  (void)__atomic_compare_exchange(p, p, p, 0, memory_order_seq_cst, memory_order_relaxed);
524
525  (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_relaxed, memory_order_relaxed);
526  (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_acquire, memory_order_relaxed);
527  (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_consume, memory_order_relaxed);
528  (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_release, memory_order_relaxed);
529  (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_acq_rel, memory_order_relaxed);
530  (void)__atomic_compare_exchange_n(p, p, val, 0, memory_order_seq_cst, memory_order_relaxed);
531}
532
533void nullPointerWarning() {
534  volatile _Atomic(int) vai;
535  _Atomic(int) ai;
536  volatile int vi = 42;
537  int i = 42;
538  volatile _Atomic(int*) vap;
539  _Atomic(int*) ap;
540  volatile int* vp = NULL;
541  int* p = NULL;
542
543  __c11_atomic_init((volatile _Atomic(int)*)0, 42); // expected-warning {{null passed to a callee that requires a non-null argument}}
544  __c11_atomic_init((_Atomic(int)*)0, 42); // expected-warning {{null passed to a callee that requires a non-null argument}}
545  __c11_atomic_store((volatile _Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
546  __c11_atomic_store((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
547  (void)__c11_atomic_load((volatile _Atomic(int)*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
548  (void)__c11_atomic_load((_Atomic(int)*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
549  (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}}
550  (void)__c11_atomic_exchange((_Atomic(int)*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
551  (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}}
552  (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}}
553  (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}}
554  (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}}
555  (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}}
556  (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}}
557  (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}}
558  (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}}
559  (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}}
560  (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}}
561  (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}}
562  (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}}
563  (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}}
564  (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}}
565  (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}}
566  (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}}
567  (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}}
568  (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}}
569
570  __atomic_store_n((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
571  __atomic_store_n((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
572  __atomic_store((volatile int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
573  __atomic_store((int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
574  __atomic_store(&vi, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
575  __atomic_store(&i, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
576  (void)__atomic_load_n((volatile int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
577  (void)__atomic_load_n((int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
578  __atomic_load((volatile int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
579  __atomic_load((int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
580  __atomic_load(&vi, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
581  __atomic_load(&i, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
582  (void)__atomic_exchange_n((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
583  (void)__atomic_exchange_n((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
584  __atomic_exchange((volatile int*)0, &i, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
585  __atomic_exchange((int*)0, &i, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
586  __atomic_exchange(&vi, (int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
587  __atomic_exchange(&i, (int*)0, &i, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
588  __atomic_exchange(&vi, &i, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
589  __atomic_exchange(&i, &i, (int*)0, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
590  (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}}
591  (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}}
592  (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}}
593  (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}}
594  (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}}
595  (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}}
596  (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}}
597  (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}}
598  (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}}
599  (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}}
600  (void)__atomic_fetch_add((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
601  (void)__atomic_fetch_add((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
602  (void)__atomic_fetch_sub((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
603  (void)__atomic_fetch_sub((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
604  (void)__atomic_fetch_and((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
605  (void)__atomic_fetch_and((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
606  (void)__atomic_fetch_or((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
607  (void)__atomic_fetch_or((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
608  (void)__atomic_fetch_xor((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
609  (void)__atomic_fetch_xor((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
610  (void)__atomic_fetch_min((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
611  (void)__atomic_fetch_min((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
612  (void)__atomic_fetch_max((volatile int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
613  (void)__atomic_fetch_max((int*)0, 42, memory_order_relaxed); // expected-warning {{null passed to a callee that requires a non-null argument}}
614
615  // These don't warn: the "desired" parameter is passed by value. Even for
616  // atomic pointers the "desired" result can be NULL.
617  __c11_atomic_init(&vai, 0);
618  __c11_atomic_init(&ai, 0);
619  __c11_atomic_init(&vap, NULL);
620  __c11_atomic_init(&ap, NULL);
621  __c11_atomic_store(&vai, 0, memory_order_relaxed);
622  __c11_atomic_store(&ai, 0, memory_order_relaxed);
623  __c11_atomic_store(&vap, NULL, memory_order_relaxed);
624  __c11_atomic_store(&ap, NULL, memory_order_relaxed);
625  (void)__c11_atomic_exchange(&vai, 0, memory_order_relaxed);
626  (void)__c11_atomic_exchange(&ai, 0, memory_order_relaxed);
627  (void)__c11_atomic_exchange(&vap, NULL, memory_order_relaxed);
628  (void)__c11_atomic_exchange(&ap, NULL, memory_order_relaxed);
629  (void)__c11_atomic_compare_exchange_weak(&vai, &i, 0, memory_order_relaxed, memory_order_relaxed);
630  (void)__c11_atomic_compare_exchange_weak(&ai, &i, 0, memory_order_relaxed, memory_order_relaxed);
631  (void)__c11_atomic_compare_exchange_weak(&vap, &p, NULL, memory_order_relaxed, memory_order_relaxed);
632  (void)__c11_atomic_compare_exchange_weak(&ap, &p, NULL, memory_order_relaxed, memory_order_relaxed);
633  (void)__c11_atomic_compare_exchange_strong(&vai, &i, 0, memory_order_relaxed, memory_order_relaxed);
634  (void)__c11_atomic_compare_exchange_strong(&ai, &i, 0, memory_order_relaxed, memory_order_relaxed);
635  (void)__c11_atomic_compare_exchange_strong(&vap, &p, NULL, memory_order_relaxed, memory_order_relaxed);
636  (void)__c11_atomic_compare_exchange_strong(&ap, &p, NULL, memory_order_relaxed, memory_order_relaxed);
637  (void)__c11_atomic_fetch_add(&vai, 0, memory_order_relaxed);
638  (void)__c11_atomic_fetch_add(&ai, 0, memory_order_relaxed);
639  (void)__c11_atomic_fetch_sub(&vai, 0, memory_order_relaxed);
640  (void)__c11_atomic_fetch_sub(&ai, 0, memory_order_relaxed);
641  (void)__c11_atomic_fetch_and(&vai, 0, memory_order_relaxed);
642  (void)__c11_atomic_fetch_and(&ai, 0, memory_order_relaxed);
643  (void)__c11_atomic_fetch_or(&vai, 0, memory_order_relaxed);
644  (void)__c11_atomic_fetch_or(&ai, 0, memory_order_relaxed);
645  (void)__c11_atomic_fetch_xor(&vai, 0, memory_order_relaxed);
646  (void)__c11_atomic_fetch_xor(&ai, 0, memory_order_relaxed);
647
648  // Ditto.
649  __atomic_store_n(&vi, 0, memory_order_relaxed);
650  __atomic_store_n(&i, 0, memory_order_relaxed);
651  __atomic_store_n(&vp, NULL, memory_order_relaxed);
652  __atomic_store_n(&p, NULL, memory_order_relaxed);
653  (void)__atomic_exchange_n(&vi, 0, memory_order_relaxed);
654  (void)__atomic_exchange_n(&i, 0, memory_order_relaxed);
655  (void)__atomic_exchange_n(&vp, NULL, memory_order_relaxed);
656  (void)__atomic_exchange_n(&p, NULL, memory_order_relaxed);
657  (void)__atomic_compare_exchange_n(&vi, &i, 0, /*weak=*/0, memory_order_relaxed, memory_order_relaxed);
658  (void)__atomic_compare_exchange_n(&i, &i, 0, /*weak=*/0, memory_order_relaxed, memory_order_relaxed);
659  (void)__atomic_compare_exchange_n(&vp, &vp, NULL, /*weak=*/0, memory_order_relaxed, memory_order_relaxed);
660  (void)__atomic_compare_exchange_n(&p, &p, NULL, /*weak=*/0, memory_order_relaxed, memory_order_relaxed);
661  (void)__atomic_fetch_add(&vi, 0, memory_order_relaxed);
662  (void)__atomic_fetch_add(&i, 0, memory_order_relaxed);
663  (void)__atomic_fetch_sub(&vi, 0, memory_order_relaxed);
664  (void)__atomic_fetch_sub(&i, 0, memory_order_relaxed);
665  (void)__atomic_fetch_and(&vi, 0, memory_order_relaxed);
666  (void)__atomic_fetch_and(&i, 0, memory_order_relaxed);
667  (void)__atomic_fetch_or(&vi, 0, memory_order_relaxed);
668  (void)__atomic_fetch_or(&i, 0, memory_order_relaxed);
669  (void)__atomic_fetch_xor(&vi, 0, memory_order_relaxed);
670  (void)__atomic_fetch_xor(&i, 0, memory_order_relaxed);
671  (void)__atomic_fetch_min(&vi, 0, memory_order_relaxed);
672  (void)__atomic_fetch_min(&i, 0, memory_order_relaxed);
673  (void)__atomic_fetch_max(&vi, 0, memory_order_relaxed);
674  (void)__atomic_fetch_max(&i, 0, memory_order_relaxed);
675}
676
CodeThinker, Enjoy your reading code