Home | History | Annotate | Download | only in Sema
      1 // RUN: %clang_cc1 %s -verify -fsyntax-only -triple=i686-linux-gnu -std=c11
      2 // RUN: %clang_cc1 %s -verify -fsyntax-only -triple=aarch64-linux-gnu -std=c11
      3 
      4 // Basic parsing/Sema tests for __c11_atomic_*
      5 
      6 typedef enum memory_order {
      7   memory_order_relaxed, memory_order_consume, memory_order_acquire,
      8   memory_order_release, memory_order_acq_rel, memory_order_seq_cst
      9 } memory_order;
     10 
     11 struct S { char c[3]; };
     12 
     13 _Static_assert(__GCC_ATOMIC_BOOL_LOCK_FREE == 2, "");
     14 _Static_assert(__GCC_ATOMIC_CHAR_LOCK_FREE == 2, "");
     15 _Static_assert(__GCC_ATOMIC_CHAR16_T_LOCK_FREE == 2, "");
     16 _Static_assert(__GCC_ATOMIC_CHAR32_T_LOCK_FREE == 2, "");
     17 _Static_assert(__GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2, "");
     18 _Static_assert(__GCC_ATOMIC_SHORT_LOCK_FREE == 2, "");
     19 _Static_assert(__GCC_ATOMIC_INT_LOCK_FREE == 2, "");
     20 _Static_assert(__GCC_ATOMIC_LONG_LOCK_FREE == 2, "");
     21 #ifdef __i386__
     22 _Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 1, "");
     23 #else
     24 _Static_assert(__GCC_ATOMIC_LLONG_LOCK_FREE == 2, "");
     25 #endif
     26 _Static_assert(__GCC_ATOMIC_POINTER_LOCK_FREE == 2, "");
     27 
     28 _Static_assert(__c11_atomic_is_lock_free(1), "");
     29 _Static_assert(__c11_atomic_is_lock_free(2), "");
     30 _Static_assert(__c11_atomic_is_lock_free(3), ""); // expected-error {{not an integral constant expression}}
     31 _Static_assert(__c11_atomic_is_lock_free(4), "");
     32 _Static_assert(__c11_atomic_is_lock_free(8), "");
     33 _Static_assert(__c11_atomic_is_lock_free(16), ""); // expected-error {{not an integral constant expression}}
     34 _Static_assert(__c11_atomic_is_lock_free(17), ""); // expected-error {{not an integral constant expression}}
     35 
     36 _Static_assert(__atomic_is_lock_free(1, 0), "");
     37 _Static_assert(__atomic_is_lock_free(2, 0), "");
     38 _Static_assert(__atomic_is_lock_free(3, 0), ""); // expected-error {{not an integral constant expression}}
     39 _Static_assert(__atomic_is_lock_free(4, 0), "");
     40 _Static_assert(__atomic_is_lock_free(8, 0), "");
     41 _Static_assert(__atomic_is_lock_free(16, 0), ""); // expected-error {{not an integral constant expression}}
     42 _Static_assert(__atomic_is_lock_free(17, 0), ""); // expected-error {{not an integral constant expression}}
     43 
     44 char i8;
     45 short i16;
     46 int i32;
     47 int __attribute__((vector_size(8))) i64;
     48 struct Incomplete *incomplete;
     49 
     50 _Static_assert(__atomic_is_lock_free(1, &i8), "");
     51 _Static_assert(__atomic_is_lock_free(1, &i64), "");
     52 _Static_assert(__atomic_is_lock_free(2, &i8), ""); // expected-error {{not an integral constant expression}}
     53 _Static_assert(__atomic_is_lock_free(2, &i16), "");
     54 _Static_assert(__atomic_is_lock_free(2, &i64), "");
     55 _Static_assert(__atomic_is_lock_free(4, &i16), ""); // expected-error {{not an integral constant expression}}
     56 _Static_assert(__atomic_is_lock_free(4, &i32), "");
     57 _Static_assert(__atomic_is_lock_free(4, &i64), "");
     58 _Static_assert(__atomic_is_lock_free(8, &i32), ""); // expected-error {{not an integral constant expression}}
     59 _Static_assert(__atomic_is_lock_free(8, &i64), "");
     60 
     61 _Static_assert(__atomic_always_lock_free(1, 0), "");
     62 _Static_assert(__atomic_always_lock_free(2, 0), "");
     63 _Static_assert(!__atomic_always_lock_free(3, 0), "");
     64 _Static_assert(__atomic_always_lock_free(4, 0), "");
     65 _Static_assert(__atomic_always_lock_free(8, 0), "");
     66 _Static_assert(!__atomic_always_lock_free(16, 0), "");
     67 _Static_assert(!__atomic_always_lock_free(17, 0), "");
     68 
     69 _Static_assert(__atomic_always_lock_free(1, incomplete), "");
     70 _Static_assert(!__atomic_always_lock_free(2, incomplete), "");
     71 _Static_assert(!__atomic_always_lock_free(4, incomplete), "");
     72 
     73 _Static_assert(__atomic_always_lock_free(1, &i8), "");
     74 _Static_assert(__atomic_always_lock_free(1, &i64), "");
     75 _Static_assert(!__atomic_always_lock_free(2, &i8), "");
     76 _Static_assert(__atomic_always_lock_free(2, &i16), "");
     77 _Static_assert(__atomic_always_lock_free(2, &i64), "");
     78 _Static_assert(!__atomic_always_lock_free(4, &i16), "");
     79 _Static_assert(__atomic_always_lock_free(4, &i32), "");
     80 _Static_assert(__atomic_always_lock_free(4, &i64), "");
     81 _Static_assert(!__atomic_always_lock_free(8, &i32), "");
     82 _Static_assert(__atomic_always_lock_free(8, &i64), "");
     83 
     84 void f(_Atomic(int) *i, _Atomic(int*) *p, _Atomic(float) *d,
     85        int *I, int **P, float *D, struct S *s1, struct S *s2) {
     86   __c11_atomic_init(I, 5); // expected-error {{pointer to _Atomic}}
     87   __c11_atomic_load(0); // expected-error {{too few arguments to function}}
     88   __c11_atomic_load(0,0,0); // expected-error {{too many arguments to function}}
     89   __c11_atomic_store(0,0,0); // expected-error {{first argument to atomic builtin must be a pointer}}
     90   __c11_atomic_store((int*)0,0,0); // expected-error {{first argument to atomic operation must be a pointer to _Atomic}}
     91 
     92   __c11_atomic_load(i, memory_order_seq_cst);
     93   __c11_atomic_load(p, memory_order_seq_cst);
     94   __c11_atomic_load(d, memory_order_seq_cst);
     95 
     96   int load_n_1 = __atomic_load_n(I, memory_order_relaxed);
     97   int *load_n_2 = __atomic_load_n(P, memory_order_relaxed);
     98   float load_n_3 = __atomic_load_n(D, memory_order_relaxed); // expected-error {{must be a pointer to integer or pointer}}
     99   __atomic_load_n(s1, memory_order_relaxed); // expected-error {{must be a pointer to integer or pointer}}
    100 
    101   __atomic_load(i, I, memory_order_relaxed); // expected-error {{must be a pointer to a trivially-copyable type}}
    102   __atomic_load(I, i, memory_order_relaxed); // expected-warning {{passing '_Atomic(int) *' to parameter of type 'int *'}}
    103   __atomic_load(I, *P, memory_order_relaxed);
    104   __atomic_load(I, *P, memory_order_relaxed, 42); // expected-error {{too many arguments}}
    105   (int)__atomic_load(I, I, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
    106   __atomic_load(s1, s2, memory_order_acquire);
    107 
    108   __c11_atomic_store(i, 1, memory_order_seq_cst);
    109   __c11_atomic_store(p, 1, memory_order_seq_cst); // expected-warning {{incompatible integer to pointer conversion}}
    110   (int)__c11_atomic_store(d, 1, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
    111 
    112   __atomic_store_n(I, 4, memory_order_release);
    113   __atomic_store_n(I, 4.0, memory_order_release);
    114   __atomic_store_n(I, P, memory_order_release); // expected-warning {{parameter of type 'int'}}
    115   __atomic_store_n(i, 1, memory_order_release); // expected-error {{must be a pointer to integer or pointer}}
    116   __atomic_store_n(s1, *s2, memory_order_release); // expected-error {{must be a pointer to integer or pointer}}
    117 
    118   __atomic_store(I, *P, memory_order_release);
    119   __atomic_store(s1, s2, memory_order_release);
    120   __atomic_store(i, I, memory_order_release); // expected-error {{trivially-copyable}}
    121 
    122   int exchange_1 = __c11_atomic_exchange(i, 1, memory_order_seq_cst);
    123   int exchange_2 = __c11_atomic_exchange(I, 1, memory_order_seq_cst); // expected-error {{must be a pointer to _Atomic}}
    124   int exchange_3 = __atomic_exchange_n(i, 1, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}}
    125   int exchange_4 = __atomic_exchange_n(I, 1, memory_order_seq_cst);
    126 
    127   __atomic_exchange(s1, s2, s2, memory_order_seq_cst);
    128   __atomic_exchange(s1, I, P, memory_order_seq_cst); // expected-warning 2{{parameter of type 'struct S *'}}
    129   (int)__atomic_exchange(s1, s2, s2, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
    130 
    131   __c11_atomic_fetch_add(i, 1, memory_order_seq_cst);
    132   __c11_atomic_fetch_add(p, 1, memory_order_seq_cst);
    133   __c11_atomic_fetch_add(d, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer or pointer}}
    134 
    135   __atomic_fetch_add(i, 3, memory_order_seq_cst); // expected-error {{pointer to integer or pointer}}
    136   __atomic_fetch_sub(I, 3, memory_order_seq_cst);
    137   __atomic_fetch_sub(P, 3, memory_order_seq_cst);
    138   __atomic_fetch_sub(D, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}}
    139   __atomic_fetch_sub(s1, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer or pointer}}
    140 
    141   __c11_atomic_fetch_and(i, 1, memory_order_seq_cst);
    142   __c11_atomic_fetch_and(p, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer}}
    143   __c11_atomic_fetch_and(d, 1, memory_order_seq_cst); // expected-error {{must be a pointer to atomic integer}}
    144 
    145   __atomic_fetch_and(i, 3, memory_order_seq_cst); // expected-error {{pointer to integer}}
    146   __atomic_fetch_or(I, 3, memory_order_seq_cst);
    147   __atomic_fetch_xor(P, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}}
    148   __atomic_fetch_or(D, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}}
    149   __atomic_fetch_and(s1, 3, memory_order_seq_cst); // expected-error {{must be a pointer to integer}}
    150 
    151   _Bool cmpexch_1 = __c11_atomic_compare_exchange_strong(i, 0, 1, memory_order_seq_cst, memory_order_seq_cst);
    152   _Bool cmpexch_2 = __c11_atomic_compare_exchange_strong(p, 0, (int*)1, memory_order_seq_cst, memory_order_seq_cst);
    153   _Bool cmpexch_3 = __c11_atomic_compare_exchange_strong(d, (int*)0, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{incompatible pointer types}}
    154 
    155   _Bool cmpexch_4 = __atomic_compare_exchange_n(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst);
    156   _Bool cmpexch_5 = __atomic_compare_exchange_n(I, P, 5, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{; dereference with *}}
    157   _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'}}
    158 
    159   _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 *'}}
    160   _Bool cmpexch_8 = __atomic_compare_exchange(I, P, I, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{; dereference with *}}
    161   _Bool cmpexch_9 = __atomic_compare_exchange(I, I, I, 0, memory_order_seq_cst, memory_order_seq_cst);
    162 
    163   const volatile int flag_k = 0;
    164   volatile int flag = 0;
    165   (void)(int)__atomic_test_and_set(&flag_k, memory_order_seq_cst); // expected-warning {{passing 'const volatile int *' to parameter of type 'volatile void *'}}
    166   (void)(int)__atomic_test_and_set(&flag, memory_order_seq_cst);
    167   __atomic_clear(&flag_k, memory_order_seq_cst); // expected-warning {{passing 'const volatile int *' to parameter of type 'volatile void *'}}
    168   __atomic_clear(&flag, memory_order_seq_cst);
    169   (int)__atomic_clear(&flag, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
    170 
    171   const _Atomic(int) const_atomic;
    172   __c11_atomic_init(&const_atomic, 0); // expected-error {{first argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}}
    173   __c11_atomic_store(&const_atomic, 0, memory_order_release); // expected-error {{first argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}}
    174   __c11_atomic_load(&const_atomic, memory_order_acquire); // expected-error {{first argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}}
    175 }
    176