[gcc(refs/vendors/ARM/heads/morello)] Add testcases that had been lost in a rebase

public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed

* [gcc(refs/vendors/ARM/heads/morello)] Add testcases that had been lost in a rebase
@ 2022-05-13 15:42 Matthew Malcomson
  0 siblings, 0 replies; only message in thread
From: Matthew Malcomson @ 2022-05-13 15:42 UTC (permalink / raw)
  To: gcc-cvs

https://gcc.gnu.org/g:a590c66eafa7cdb6ed7d2f8d65bfd0bad93938ca

commit a590c66eafa7cdb6ed7d2f8d65bfd0bad93938ca
Author: Matthew Malcomson <matthew.malcomson@arm.com>
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  <silviu.baranga@arm.com>
      Alex Richardson <alexrichardson@google.com>
    
    Modifications from those testcases, and the writing of the
    cheri-intrin.c and cheri-header.c testcases was done by:
      Stam Markianos-Wright <stam.markianos-wright@arm.com>
      Richard Sandiford <richard.sandiford@arm.com>
      Alex Coplan <alex.coplan@arm.com>

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 <stdatomic.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+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 <stdatomic.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+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 <stdatomic.h>
+#include <stdbool.h>
+#include <stddef.h>
+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 <stdatomic.h>
+#include <stdbool.h>
+#include <stddef.h>
+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 <cheri.h>
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 <cheriintrin.h>
+#include <assert.h>
+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;
+}


^ permalink raw reply	[flat|nested] only message in thread

only message in thread, other threads:[~2022-05-13 15:42 UTC | newest]

Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-05-13 15:42 [gcc(refs/vendors/ARM/heads/morello)] Add testcases that had been lost in a rebase Matthew Malcomson

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).