From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2049) id BEC4939730F7; Fri, 13 May 2022 15:42:53 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org BEC4939730F7 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Matthew Malcomson To: gcc-cvs@gcc.gnu.org Subject: [gcc(refs/vendors/ARM/heads/morello)] Add testcases that had been lost in a rebase X-Act-Checkin: gcc X-Git-Author: Matthew Malcomson X-Git-Refname: refs/vendors/ARM/heads/morello X-Git-Oldrev: d04c8104f9bd992620dcc4b09b176a0c669d561c X-Git-Newrev: a590c66eafa7cdb6ed7d2f8d65bfd0bad93938ca Message-Id: <20220513154253.BEC4939730F7@sourceware.org> Date: Fri, 13 May 2022 15:42:53 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 13 May 2022 15:42:53 -0000 https://gcc.gnu.org/g:a590c66eafa7cdb6ed7d2f8d65bfd0bad93938ca commit a590c66eafa7cdb6ed7d2f8d65bfd0bad93938ca Author: Matthew Malcomson Date: Fri May 13 16:37:27 2022 +0100 Add testcases that had been lost in a rebase These testcases were added in earlier patches, they had been lost from our public branch in a rebase. N.b. core parts of the atomics tests have been taken from the Morello LLVM testsuite and adapted for the GCC testsuite. Specifically tests have been adapted from the files linked below. https://git.morello-project.org/morello/llvm-project/-/blob/morello/dev/clang/test/CodeGenCXX/morello-atomic-ops.cpp https://git.morello-project.org/morello/llvm-project/-/blob/morello/dev/clang/test/CodeGen/cheri/cheri-atomics.c Those original tests written by Silviu Baranga Alex Richardson Modifications from those testcases, and the writing of the cheri-intrin.c and cheri-header.c testcases was done by: Stam Markianos-Wright Richard Sandiford Alex Coplan Diff: --- .../aarch64/morello/atomics/fake_atomics_v8.c | 404 +++++++++++++++++++++ .../aarch64/morello/atomics/fake_atomics_v8_2.c | 404 +++++++++++++++++++++ .../aarch64/morello/atomics/fake_syncs_v8.c | 58 +++ .../aarch64/morello/atomics/fake_syncs_v8_2.c | 58 +++ .../gcc.target/aarch64/morello/cheri-header.c | 2 + .../gcc.target/aarch64/morello/cheri-intrin.c | 21 ++ 6 files changed, 947 insertions(+) diff --git a/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_atomics_v8.c b/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_atomics_v8.c new file mode 100644 index 00000000000..df7d6e97aa0 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_atomics_v8.c @@ -0,0 +1,404 @@ +/* { dg-do compile { target aarch64*-*-* } } */ +/* { dg-additional-options "-march=armv8-a -std=c11" { target { ! cheri_capability_pure } } } */ +/* { dg-additional-options "-std=c11" { target { cheri_capability_pure } } } */ + +#include +#include +#include + +void atomic_check_valid_1(int **intptrptr, int *intptr, int intval, + _Bool tempbool, _Bool* tempboolptr, size_t size, + void* voidptr) + { + intptr = __atomic_load_n(intptrptr, memory_order_relaxed); + intptr = __atomic_load_n(intptrptr, memory_order_acquire); + intptr = __atomic_load_n(intptrptr, memory_order_consume); + intptr = __atomic_load_n(intptrptr, memory_order_seq_cst); + + (void)__atomic_load(intptrptr, intptrptr, memory_order_relaxed); + (void)__atomic_load(intptrptr, intptrptr, memory_order_acquire); + (void)__atomic_load(intptrptr, intptrptr, memory_order_consume); + (void)__atomic_load(intptrptr, intptrptr, memory_order_seq_cst); + + (void)__atomic_store(intptrptr, intptrptr, memory_order_relaxed); + (void)__atomic_store(intptrptr, intptrptr, memory_order_release); + (void)__atomic_store(intptrptr, intptrptr, memory_order_seq_cst); + + (void)__atomic_store_n(intptrptr, intptr, memory_order_relaxed); + (void)__atomic_store_n(intptrptr, intptr, memory_order_release); + (void)__atomic_store_n(intptrptr, intptr, memory_order_seq_cst); + (void)__atomic_store_n(intptrptr, intval, memory_order_seq_cst); + (void)__atomic_store_n(intptrptr, 0, memory_order_seq_cst); + (void)__atomic_store_n(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_add(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_add(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_sub(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_sub(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_add_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_add_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_sub_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_sub_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_and(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_and(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_or(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_or(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_xor(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_xor(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_nand(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_nand(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_and_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_and_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_or_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_or_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_xor_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_xor_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_nand_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_nand_fetch(intptrptr, 1, memory_order_seq_cst); + + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_relaxed); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_acquire); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_consume); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_release); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_acq_rel); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_seq_cst); + (void) __atomic_exchange_n(intptrptr, 0, memory_order_seq_cst); + (void) __atomic_exchange_n(intptrptr, 1, memory_order_seq_cst); + + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_relaxed); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_acquire); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_consume); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_release); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_acq_rel); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_seq_cst); + + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_relaxed, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_acquire, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_consume, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_release, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_acq_rel, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_seq_cst, memory_order_relaxed); + + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_relaxed, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_acquire, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_consume, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_release, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_acq_rel, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_seq_cst, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, 0, 0, memory_order_relaxed, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, 1, 0, memory_order_acquire, memory_order_relaxed); + + tempbool = __atomic_test_and_set(voidptr, memory_order_relaxed); + tempbool = __atomic_test_and_set(voidptr, memory_order_acquire); + tempbool = __atomic_test_and_set(voidptr, memory_order_consume); + tempbool = __atomic_test_and_set(voidptr, memory_order_seq_cst); + + (void)__atomic_clear(tempboolptr, memory_order_relaxed); + (void)__atomic_clear(tempboolptr, memory_order_release); + (void)__atomic_clear(tempboolptr, memory_order_seq_cst); + + tempbool = __atomic_always_lock_free(sizeof (voidptr), voidptr); + tempbool = __atomic_always_lock_free(sizeof (voidptr), voidptr); + tempbool = __atomic_always_lock_free(sizeof (voidptr), voidptr); + tempbool = __atomic_always_lock_free(sizeof (voidptr), voidptr); + tempbool = __atomic_is_lock_free(size, voidptr); + tempbool = __atomic_is_lock_free(size, voidptr); + tempbool = __atomic_is_lock_free(size, voidptr); + tempbool = __atomic_is_lock_free(size, voidptr); + +} + +void atomic_check_valid_2(int **intptrptr, int *intptr, int intval, + _Bool tempbool, _Bool* tempboolptr, size_t size, + void* voidptr) + { + intptr = (int *) __atomic_load_capability(intptrptr, memory_order_relaxed); + intptr = (int *) __atomic_load_capability(intptrptr, memory_order_acquire); + intptr = (int *) __atomic_load_capability(intptrptr, memory_order_consume); + intptr = (int *) __atomic_load_capability(intptrptr, memory_order_seq_cst); + + (void)__atomic_store_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + (void)__atomic_store_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + (void)__atomic_store_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + (void) __atomic_exchange_capability(intptrptr, 0, memory_order_seq_cst); + (void) __atomic_exchange_capability(intptrptr, 1, memory_order_seq_cst); + + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_relaxed, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_acquire, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_consume, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_release, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_acq_rel, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_seq_cst, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, 0, 0, memory_order_seq_cst, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, 1, 0, memory_order_seq_cst, memory_order_relaxed); +} diff --git a/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_atomics_v8_2.c b/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_atomics_v8_2.c new file mode 100644 index 00000000000..e05e5471382 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_atomics_v8_2.c @@ -0,0 +1,404 @@ +/* { dg-do compile { target aarch64*-*-* } } */ +/* { dg-additional-options "-march=armv8.2-a -std=c11" { target { ! cheri_capability_pure } } } */ +/* { dg-additional-options "-std=c11" { target { cheri_capability_pure } } } */ + +#include +#include +#include + +void atomic_check_valid_1(int **intptrptr, int *intptr, int intval, + _Bool tempbool, _Bool* tempboolptr, size_t size, + void* voidptr) + { + intptr = __atomic_load_n(intptrptr, memory_order_relaxed); + intptr = __atomic_load_n(intptrptr, memory_order_acquire); + intptr = __atomic_load_n(intptrptr, memory_order_consume); + intptr = __atomic_load_n(intptrptr, memory_order_seq_cst); + + (void)__atomic_load(intptrptr, intptrptr, memory_order_relaxed); + (void)__atomic_load(intptrptr, intptrptr, memory_order_acquire); + (void)__atomic_load(intptrptr, intptrptr, memory_order_consume); + (void)__atomic_load(intptrptr, intptrptr, memory_order_seq_cst); + + (void)__atomic_store(intptrptr, intptrptr, memory_order_relaxed); + (void)__atomic_store(intptrptr, intptrptr, memory_order_release); + (void)__atomic_store(intptrptr, intptrptr, memory_order_seq_cst); + + (void)__atomic_store_n(intptrptr, intptr, memory_order_relaxed); + (void)__atomic_store_n(intptrptr, intptr, memory_order_release); + (void)__atomic_store_n(intptrptr, intptr, memory_order_seq_cst); + (void)__atomic_store_n(intptrptr, intval, memory_order_seq_cst); + (void)__atomic_store_n(intptrptr, 0, memory_order_seq_cst); + (void)__atomic_store_n(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_add(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_add(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_add(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_sub(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_sub(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_sub(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_add_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_add_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_add_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_sub_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_sub_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_sub_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_and(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_and(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_and(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_or(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_or(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_or(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_xor(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_xor(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_xor(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_acquire); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_consume); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_release); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_fetch_nand(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_fetch_nand(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_fetch_nand(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_and_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_and_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_and_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_or_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_or_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_or_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_xor_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_xor_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_xor_fetch(intptrptr, 1, memory_order_seq_cst); + + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_relaxed); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_acquire); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_consume); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_release); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_acq_rel); + intptr = __atomic_nand_fetch(intptrptr, intval, memory_order_seq_cst); + intptr = __atomic_nand_fetch(intptrptr, 0, memory_order_seq_cst); + intptr = __atomic_nand_fetch(intptrptr, 1, memory_order_seq_cst); + + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_relaxed); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_acquire); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_consume); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_release); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_acq_rel); + (void) __atomic_exchange_n(intptrptr, intptr, memory_order_seq_cst); + (void) __atomic_exchange_n(intptrptr, 0, memory_order_seq_cst); + (void) __atomic_exchange_n(intptrptr, 1, memory_order_seq_cst); + + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_relaxed); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_acquire); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_consume); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_release); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_acq_rel); + (void) __atomic_exchange(intptrptr, intptrptr, intptrptr, memory_order_seq_cst); + + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_relaxed, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_acquire, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_consume, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_release, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_acq_rel, memory_order_relaxed); + tempbool = __atomic_compare_exchange(intptrptr, intptrptr, intptrptr, 0, memory_order_seq_cst, memory_order_relaxed); + + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_relaxed, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_acquire, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_consume, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_release, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_acq_rel, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, intptr, 0, memory_order_seq_cst, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, 0, 0, memory_order_relaxed, memory_order_relaxed); + tempbool = __atomic_compare_exchange_n(intptrptr, intptrptr, 1, 0, memory_order_acquire, memory_order_relaxed); + + tempbool = __atomic_test_and_set(voidptr, memory_order_relaxed); + tempbool = __atomic_test_and_set(voidptr, memory_order_acquire); + tempbool = __atomic_test_and_set(voidptr, memory_order_consume); + tempbool = __atomic_test_and_set(voidptr, memory_order_seq_cst); + + (void)__atomic_clear(tempboolptr, memory_order_relaxed); + (void)__atomic_clear(tempboolptr, memory_order_release); + (void)__atomic_clear(tempboolptr, memory_order_seq_cst); + + tempbool = __atomic_always_lock_free(sizeof (voidptr), voidptr); + tempbool = __atomic_always_lock_free(sizeof (voidptr), voidptr); + tempbool = __atomic_always_lock_free(sizeof (voidptr), voidptr); + tempbool = __atomic_always_lock_free(sizeof (voidptr), voidptr); + tempbool = __atomic_is_lock_free(size, voidptr); + tempbool = __atomic_is_lock_free(size, voidptr); + tempbool = __atomic_is_lock_free(size, voidptr); + tempbool = __atomic_is_lock_free(size, voidptr); + +} + +void atomic_check_valid_2(int **intptrptr, int *intptr, int intval, + _Bool tempbool, _Bool* tempboolptr, size_t size, + void* voidptr) + { + intptr = (int *) __atomic_load_capability(intptrptr, memory_order_relaxed); + intptr = (int *) __atomic_load_capability(intptrptr, memory_order_acquire); + intptr = (int *) __atomic_load_capability(intptrptr, memory_order_consume); + intptr = (int *) __atomic_load_capability(intptrptr, memory_order_seq_cst); + + (void)__atomic_store_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + (void)__atomic_store_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + (void)__atomic_store_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_add_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_sub_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_add_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_sub_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_and_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_or_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_xor_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_fetch_nand_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_and_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_or_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_xor_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_relaxed); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_acquire); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_consume); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_release); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_acq_rel); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, intval, memory_order_seq_cst); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, 0, memory_order_seq_cst); + intptr = (int *) __atomic_nand_fetch_capability(intptrptr, 1, memory_order_seq_cst); + + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_relaxed); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_acquire); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_consume); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_release); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_acq_rel); + (void) __atomic_exchange_capability(intptrptr, (__intcap_t) intptr, memory_order_seq_cst); + (void) __atomic_exchange_capability(intptrptr, 0, memory_order_seq_cst); + (void) __atomic_exchange_capability(intptrptr, 1, memory_order_seq_cst); + + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_relaxed, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_acquire, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_consume, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_release, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_acq_rel, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, (__intcap_t) intptr, 0, memory_order_seq_cst, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, 0, 0, memory_order_seq_cst, memory_order_relaxed); + tempbool = __atomic_compare_exchange_capability(intptrptr, intptrptr, 1, 0, memory_order_seq_cst, memory_order_relaxed); +} diff --git a/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_syncs_v8.c b/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_syncs_v8.c new file mode 100644 index 00000000000..1539f259eb6 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_syncs_v8.c @@ -0,0 +1,58 @@ +/* { dg-do compile { target aarch64*-*-* } } */ +/* { dg-additional-options "-march=armv8-a -std=c11" { target { ! cheri_capability_pure } } } */ +/* { dg-additional-options "-std=c11" { target { cheri_capability_pure } } } */ + +#include +#include +#include +void atomic_check_valid_1(int **intptrptr, int *intptr, int intval, + _Bool tempbool, _Bool* tempboolptr, size_t size, + void* voidptr) { + intptr = __sync_fetch_and_add(intptrptr, intval); + intptr = __sync_fetch_and_sub(intptrptr, intval); + intptr = __sync_add_and_fetch(intptrptr, intval); + intptr = __sync_sub_and_fetch(intptrptr, intval); + intptr = __sync_fetch_and_and(intptrptr, intval); + intptr = __sync_fetch_and_or(intptrptr, intval); + intptr = __sync_fetch_and_xor(intptrptr, intval); + intptr = __sync_fetch_and_nand(intptrptr, intval); + intptr = __sync_and_and_fetch(intptrptr, intval); + intptr = __sync_or_and_fetch(intptrptr, intval); + intptr = __sync_xor_and_fetch(intptrptr, intval); + intptr = __sync_nand_and_fetch(intptrptr, intval); + + intptr = __sync_lock_test_and_set(intptrptr, intptr); + tempbool = __sync_bool_compare_and_swap (intptrptr, intptr, intptr); + intptr = __sync_val_compare_and_swap (intptrptr, intptr, intptr); +} + +void atomic_check_valid_2(int **intptrptr, int *intptr, int intval, _Bool tempbool) { + intptr = (int *)__sync_fetch_and_add_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_sub_capability(intptrptr, intval); + intptr = (int *)__sync_add_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_sub_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_and_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_or_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_xor_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_nand_capability(intptrptr, intval); + intptr = (int *)__sync_and_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_or_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_xor_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_nand_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_add_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_sub_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_add_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_sub_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_and_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_or_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_xor_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_nand_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_and_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_or_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_xor_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_nand_and_fetch_capability(intptrptr, (__intcap_t)intptr); + + intptr = (int *)__sync_lock_test_and_set_capability(intptrptr, (__intcap_t)intptr); + tempbool = __sync_bool_compare_and_swap_capability (intptrptr, (__intcap_t)intptr, (__intcap_t)intptr); + intptr = (int *)__sync_val_compare_and_swap_capability (intptrptr, (__intcap_t)intptr, (__intcap_t)intptr); +} diff --git a/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_syncs_v8_2.c b/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_syncs_v8_2.c new file mode 100644 index 00000000000..658ff23b361 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/morello/atomics/fake_syncs_v8_2.c @@ -0,0 +1,58 @@ +/* { dg-do compile { target aarch64*-*-* } } */ +/* { dg-additional-options "-march=armv8.2-a -std=c11" { target { ! cheri_capability_pure } } } */ +/* { dg-additional-options "-std=c11" { target { cheri_capability_pure } } } */ + +#include +#include +#include +void atomic_check_valid_1(int **intptrptr, int *intptr, int intval, + _Bool tempbool, _Bool* tempboolptr, size_t size, + void* voidptr) { + intptr = __sync_fetch_and_add(intptrptr, intval); + intptr = __sync_fetch_and_sub(intptrptr, intval); + intptr = __sync_add_and_fetch(intptrptr, intval); + intptr = __sync_sub_and_fetch(intptrptr, intval); + intptr = __sync_fetch_and_and(intptrptr, intval); + intptr = __sync_fetch_and_or(intptrptr, intval); + intptr = __sync_fetch_and_xor(intptrptr, intval); + intptr = __sync_fetch_and_nand(intptrptr, intval); + intptr = __sync_and_and_fetch(intptrptr, intval); + intptr = __sync_or_and_fetch(intptrptr, intval); + intptr = __sync_xor_and_fetch(intptrptr, intval); + intptr = __sync_nand_and_fetch(intptrptr, intval); + + intptr = __sync_lock_test_and_set(intptrptr, intptr); + tempbool = __sync_bool_compare_and_swap (intptrptr, intptr, intptr); + intptr = __sync_val_compare_and_swap (intptrptr, intptr, intptr); +} + +void atomic_check_valid_2(int **intptrptr, int *intptr, int intval, _Bool tempbool) { + intptr = (int *)__sync_fetch_and_add_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_sub_capability(intptrptr, intval); + intptr = (int *)__sync_add_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_sub_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_and_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_or_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_xor_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_nand_capability(intptrptr, intval); + intptr = (int *)__sync_and_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_or_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_xor_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_nand_and_fetch_capability(intptrptr, intval); + intptr = (int *)__sync_fetch_and_add_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_sub_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_add_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_sub_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_and_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_or_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_xor_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_fetch_and_nand_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_and_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_or_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_xor_and_fetch_capability(intptrptr, (__intcap_t)intptr); + intptr = (int *)__sync_nand_and_fetch_capability(intptrptr, (__intcap_t)intptr); + + intptr = (int *)__sync_lock_test_and_set_capability(intptrptr, (__intcap_t)intptr); + tempbool = __sync_bool_compare_and_swap_capability (intptrptr, (__intcap_t)intptr, (__intcap_t)intptr); + intptr = (int *)__sync_val_compare_and_swap_capability (intptrptr, (__intcap_t)intptr, (__intcap_t)intptr); +} diff --git a/gcc/testsuite/gcc.target/aarch64/morello/cheri-header.c b/gcc/testsuite/gcc.target/aarch64/morello/cheri-header.c new file mode 100644 index 00000000000..b5888e3543c --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/morello/cheri-header.c @@ -0,0 +1,2 @@ +/* { dg-do compile } */ +#include diff --git a/gcc/testsuite/gcc.target/aarch64/morello/cheri-intrin.c b/gcc/testsuite/gcc.target/aarch64/morello/cheri-intrin.c new file mode 100644 index 00000000000..e75ae43c09a --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/morello/cheri-intrin.c @@ -0,0 +1,21 @@ +/* { dg-do compile { target cheri_capability_any } } */ +#include +#include +int main() +{ + assert (CHERI_PERM_GLOBAL == 1); + assert (ARM_CAP_PERMISSION_EXECUTIVE == 2); + assert (ARM_CAP_PERMISSION_MUTABLE_LOAD == 64); + assert (ARM_CAP_PERMISSION_COMPARTMENT_ID == 128); + assert (ARM_CAP_PERMISSION_BRANCH_SEALED_PAIR == 256); + assert (CHERI_PERM_SYSTEM_REGS == 512); + assert (CHERI_PERM_UNSEAL == 1024); + assert (CHERI_PERM_SEAL == 2048); + assert (CHERI_PERM_STORE_LOCAL_CAP == 4096); + assert (CHERI_PERM_STORE_CAP == 8192); + assert (CHERI_PERM_LOAD_CAP == 16384); + assert (CHERI_PERM_EXECUTE == 32768); + assert (CHERI_PERM_STORE == 65536); + assert (CHERI_PERM_LOAD == 131072); + return 0; +}