main () { v = 0; count = 0; if (__atomic_exchange_n (&v, count + 1, __ATOMIC_RELAXED) != count++) abort (); if (__atomic_exchange_n (&v, count + 1, __ATOMIC_ACQUIRE) != count++) abort (); if (__atomic_exchange_n (&v, count + 1, __ATOMIC_RELEASE) != count++) abort (); if (__atomic_exchange_n (&v, count + 1, __ATOMIC_ACQ_REL) != count++) abort (); if (__atomic_exchange_n (&v, count + 1, __ATOMIC_SEQ_CST) != count++) abort (); /* Now test the generic version. */ count++; __atomic_exchange (&v, &count, &ret, __ATOMIC_RELAXED); if (ret != count - 1 || v != count) abort (); count++; __atomic_exchange (&v, &count, &ret, __ATOMIC_ACQUIRE); if (ret != count - 1 || v != count) abort (); count++; __atomic_exchange (&v, &count, &ret, __ATOMIC_RELEASE); if (ret != count - 1 || v != count) abort (); count++; __atomic_exchange (&v, &count, &ret, __ATOMIC_ACQ_REL); if (ret != count - 1 || v != count) abort (); count++; __atomic_exchange (&v, &count, &ret, __ATOMIC_SEQ_CST); if (ret != count - 1 || v != count) abort (); count++; return 0; }
void test_atomic_bool (_Atomic _Bool *a) { enum { SEQ_CST = __ATOMIC_SEQ_CST }; __atomic_fetch_add (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_fetch_add." } */ __atomic_fetch_sub (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_fetch_sub." } */ __atomic_fetch_and (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_fetch_and." } */ __atomic_fetch_xor (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_fetch_xor." } */ __atomic_fetch_or (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_fetch_or." } */ __atomic_fetch_nand (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_fetch_nand." } */ __atomic_add_fetch (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_add_fetch." } */ __atomic_sub_fetch (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_sub_fetch." } */ __atomic_and_fetch (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_and_fetch." } */ __atomic_xor_fetch (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_xor_fetch." } */ __atomic_or_fetch (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_or_fetch." } */ __atomic_nand_fetch (a, 1, SEQ_CST); /* { dg-error "operand type ._Atomic _Bool \\*. is incompatible with argument 1 of .__atomic_nand_fetch." } */ /* The following are valid and must be accepted. */ _Bool val = 0, ret = 0; __atomic_exchange (a, &val, &ret, SEQ_CST); __atomic_exchange_n (a, val, SEQ_CST); __atomic_compare_exchange (a, &val, &ret, !1, SEQ_CST, SEQ_CST); __atomic_compare_exchange_n (a, &val, ret, !1, SEQ_CST, SEQ_CST); __atomic_test_and_set (a, SEQ_CST); __atomic_clear (a, SEQ_CST); }
/* Test for consistency on sizes 1, 2, 4, 8, 16 and 32. */ int main () { test_struct c; __atomic_store (&a, &zero, __ATOMIC_RELAXED); if (memcmp (&a, &zero, size)) abort (); __atomic_exchange (&a, &ones, &c, __ATOMIC_SEQ_CST); if (memcmp (&c, &zero, size)) abort (); if (memcmp (&a, &ones, size)) abort (); __atomic_load (&a, &b, __ATOMIC_RELAXED); if (memcmp (&b, &ones, size)) abort (); if (!__atomic_compare_exchange (&a, &b, &zero, false, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE)) abort(); if (memcmp (&a, &zero, size)) abort (); if (__atomic_compare_exchange (&a, &b, &ones, false, __ATOMIC_SEQ_CST, __ATOMIC_ACQUIRE)) abort(); if (memcmp (&b, &zero, size)) abort (); return 0; }
int simple(void) { ai += 1; bi = 3; _Atomic(int) tmp; tmp = ai; ai = bi; bi = tmp; printf("ai=%d bi=%d tmp=%d\n", ai, bi, tmp); __atomic_store_n(&i, -1, __ATOMIC_RELEASE); __atomic_store_n(&j, -2, __ATOMIC_SEQ_CST); //RELEASE); //__ATOMIC_SEQ_CST); __atomic_fetch_add(&i, 2, __ATOMIC_SEQ_CST); __atomic_fetch_add(&j, 1, __ATOMIC_SEQ_CST); //printf("before exchange j=%d i=%d\n", j, i); __atomic_exchange(&i, &j, &j, __ATOMIC_SEQ_CST); printf("after exchange j=%d i=%d\n", j, i); return 0; }