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
   7 struct 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
  58 char i8;
  59 short i16;
  60 int i32;
  61 int __attribute__((vector_size(8))) i64;
  62 struct 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
 101 void 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;
 285 void PR12527() { int *b = PR12527_a; }
 286
 287 void 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
 293 void 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
 533 void 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 }