[clang] [clang][PAC] Sign and authenticate atomics on __ptrauth types (PR #240090)

JF Bastien via cfe-commits cfe-commits at lists.llvm.org
Mon Nov 9 00:33:41 PST 2026


https://github.com/jfbastien updated https://github.com/llvm/llvm-project/pull/240090

>From 72e68330f1f812608a57e33e3dd9b1ef3aa0e26f Mon Sep 17 00:00:00 2001
From: JF Bastien <github at jfbastien.com>
Date: Mon, 9 Nov 2026 15:03:07 +0900
Subject: [PATCH 1/2] [clang][PAC] Fix crashes on _Atomic __ptrauth-qualified
 objects

Implicit _Atomic operations on a __ptrauth-qualified object assert in
CodeGen, because the pointer-authentication helpers do not look through
AtomicType: https://godbolt.org/z/6KE7Ez5P4 (a trunk build, so the link
stops crashing once this lands).

Fix the crashes. In a build without assertions the same code miscompiled
an _Atomic function pointer under -fptrauth-calls, signing it twice or
leaving it unsigned. Nothing else changes: the tests simply document
current behavior, with a FIXME on what I propose fixing in follow-ups,
for example https://godbolt.org/z/hGosq14ea.

Assisted-by: AI
---
 clang/lib/CodeGen/CGExprScalar.cpp            |   2 +-
 clang/lib/CodeGen/CGPointerAuth.cpp           |   3 +-
 clang/test/CodeGen/ptrauth-qualifier-atomic.c | 277 ++++++++++++++++++
 3 files changed, 280 insertions(+), 2 deletions(-)
 create mode 100644 clang/test/CodeGen/ptrauth-qualifier-atomic.c

diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp
index 0e2e29f0745d27..57f8367d367892 100644
--- a/clang/lib/CodeGen/CGExprScalar.cpp
+++ b/clang/lib/CodeGen/CGExprScalar.cpp
@@ -2513,7 +2513,7 @@ static bool isLValueKnownNonNull(CodeGenFunction &CGF, const Expr *E) {
 }
 
 bool CodeGenFunction::isPointerKnownNonNull(const Expr *E) {
-  assert(E->getType()->isSignableType(getContext()));
+  assert(E->getType().getAtomicUnqualifiedType()->isSignableType(getContext()));
 
   E = E->IgnoreParens();
 
diff --git a/clang/lib/CodeGen/CGPointerAuth.cpp b/clang/lib/CodeGen/CGPointerAuth.cpp
index 438d08b53a742c..62697b317f9126 100644
--- a/clang/lib/CodeGen/CGPointerAuth.cpp
+++ b/clang/lib/CodeGen/CGPointerAuth.cpp
@@ -191,6 +191,7 @@ CGPointerAuthInfo CodeGenModule::getPointerAuthInfoForPointeeType(QualType T) {
 /// pointer type.
 static CGPointerAuthInfo getPointerAuthInfoForType(CodeGenModule &CGM,
                                                    QualType PointerType) {
+  PointerType = PointerType.getAtomicUnqualifiedType();
   assert(PointerType->isSignableType(CGM.getContext()));
 
   // Block pointers are currently not signed.
@@ -225,7 +226,7 @@ emitLoadOfOrigPointerRValue(CodeGenFunction &CGF, const LValue &LV,
 /// needlessly resigning the pointer.
 std::pair<llvm::Value *, CGPointerAuthInfo>
 CodeGenFunction::EmitOrigPointerRValue(const Expr *E) {
-  assert(E->getType()->isSignableType(getContext()));
+  assert(E->getType().getAtomicUnqualifiedType()->isSignableType(getContext()));
 
   E = E->IgnoreParens();
   if (const auto *Load = dyn_cast<ImplicitCastExpr>(E)) {
diff --git a/clang/test/CodeGen/ptrauth-qualifier-atomic.c b/clang/test/CodeGen/ptrauth-qualifier-atomic.c
new file mode 100644
index 00000000000000..dc939dfd710684
--- /dev/null
+++ b/clang/test/CodeGen/ptrauth-qualifier-atomic.c
@@ -0,0 +1,277 @@
+// RUN: %clang_cc1 -triple arm64e-apple-ios -fptrauth-calls -fptrauth-intrinsics -emit-llvm %s -o - | FileCheck %s
+
+typedef int *__ptrauth(2, 0, 50) UniformPtr;
+typedef int *__ptrauth(2, 1, 100) AuthPtr;
+typedef long __ptrauth(2, 0, 200) UniformInt;
+typedef void Fn(void);
+typedef Fn *__ptrauth(0, 0, 300) UniformFn;
+
+_Atomic UniformPtr atomic_ptr, atomic_src;
+_Atomic AuthPtr atomic_auth, atomic_auth_src;
+UniformPtr qualified_ptr;
+_Atomic UniformInt atomic_int;
+UniformInt qualified_int;
+_Atomic(Fn *) plain_fn;
+_Atomic UniformFn atomic_fn;
+
+// CHECK-LABEL: define {{.*}}ptr @load_implicit()
+// CHECK:         [[SIGNED:%.*]] = load atomic ptr, ptr @atomic_ptr
+// CHECK:         [[INT:%.*]] = ptrtoint ptr [[SIGNED]] to i64
+// CHECK-NEXT:    call i64 @llvm.ptrauth.auth(i64 [[INT]], i32 2, i64 50)
+int *load_implicit(void) { return atomic_ptr; }
+
+// CHECK-LABEL: define {{.*}}void @store_implicit(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
+// CHECK:         [[SIGNED:%.*]] = phi ptr
+// CHECK-NEXT:    store atomic ptr [[SIGNED]], ptr @atomic_ptr
+void store_implicit(int *p) { atomic_ptr = p; }
+
+// FIXME: authenticates and re-signs under the same schema.
+// CHECK-LABEL: define {{.*}}void @copy_implicit()
+// CHECK:         load atomic ptr, ptr @atomic_src
+// CHECK:         call i64 @llvm.ptrauth.auth(i64 {{.*}}, i32 2, i64 50)
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
+// CHECK:         [[SIGNED:%.*]] = phi ptr
+// CHECK-NEXT:    store atomic ptr [[SIGNED]], ptr @atomic_ptr
+void copy_implicit(void) { atomic_ptr = atomic_src; }
+
+// CHECK-LABEL: define {{.*}}ptr @load_implicit_auth()
+// CHECK:         [[SIGNED:%.*]] = load atomic ptr, ptr @atomic_auth
+// CHECK-NEXT:    [[DISC:%.*]] = call i64 @llvm.ptrauth.blend(i64 ptrtoint (ptr @atomic_auth to i64), i64 100)
+// CHECK:         [[INT:%.*]] = ptrtoint ptr [[SIGNED]] to i64
+// CHECK-NEXT:    call i64 @llvm.ptrauth.auth(i64 [[INT]], i32 2, i64 [[DISC]])
+int *load_implicit_auth(void) { return atomic_auth; }
+
+// CHECK-LABEL: define {{.*}}void @store_implicit_auth(
+// CHECK:         [[DISC:%.*]] = call i64 @llvm.ptrauth.blend(i64 ptrtoint (ptr @atomic_auth to i64), i64 100)
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 [[DISC]])
+// CHECK:         [[SIGNED:%.*]] = phi ptr
+// CHECK-NEXT:    store atomic ptr [[SIGNED]], ptr @atomic_auth
+void store_implicit_auth(int *p) { atomic_auth = p; }
+
+// FIXME: authenticates and re-signs instead of one resign.
+// CHECK-LABEL: define {{.*}}void @copy_implicit_auth()
+// CHECK:         [[SRC:%.*]] = call i64 @llvm.ptrauth.blend(i64 ptrtoint (ptr @atomic_auth_src to i64), i64 100)
+// CHECK:         call i64 @llvm.ptrauth.auth(i64 {{.*}}, i32 2, i64 [[SRC]])
+// CHECK:         [[DST:%.*]] = call i64 @llvm.ptrauth.blend(i64 ptrtoint (ptr @atomic_auth to i64), i64 100)
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 [[DST]])
+// CHECK:         [[SIGNED:%.*]] = phi ptr
+// CHECK-NEXT:    store atomic ptr [[SIGNED]], ptr @atomic_auth
+void copy_implicit_auth(void) { atomic_auth = atomic_auth_src; }
+
+// CHECK-LABEL: define {{.*}}void @store_fn_implicit(
+// CHECK:         call i64 @llvm.ptrauth.resign(i64 {{.*}}, i32 0, i64 0, i32 0, i64 300)
+// CHECK:         [[SIGNED:%.*]] = phi ptr
+// CHECK-NEXT:    store atomic ptr [[SIGNED]], ptr @atomic_fn
+void store_fn_implicit(Fn *p) { atomic_fn = p; }
+
+// CHECK-LABEL: define {{.*}}ptr @load_fn_implicit()
+// CHECK:         [[SIGNED:%.*]] = load atomic ptr, ptr @atomic_fn
+// CHECK:         [[INT:%.*]] = ptrtoint ptr [[SIGNED]] to i64
+// CHECK-NEXT:    call i64 @llvm.ptrauth.resign(i64 [[INT]], i32 0, i64 300, i32 0, i64 0)
+Fn *load_fn_implicit(void) { return atomic_fn; }
+
+// CHECK-LABEL: define {{.*}}void @init_decl(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
+// CHECK:         [[SIGNED:%.*]] = phi ptr
+// CHECK-NEXT:    store ptr [[SIGNED]], ptr %l
+void init_decl(int *p) { _Atomic UniformPtr l = p; }
+
+// FIXME: stores the raw pointer.
+// CHECK-LABEL: define {{.*}}void @init_c11(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         store ptr {{.*}}, ptr @atomic_ptr
+void init_c11(int *p) { __c11_atomic_init(&atomic_ptr, p); }
+
+// FIXME: returns the signed pointer.
+// CHECK-LABEL: define {{.*}}ptr @load_c11()
+// CHECK:         load atomic ptr, ptr @atomic_ptr
+// CHECK-NOT:     @llvm.ptrauth
+int *load_c11(void) { return __c11_atomic_load(&atomic_ptr, __ATOMIC_SEQ_CST); }
+
+// FIXME: stores the raw pointer.
+// CHECK-LABEL: define {{.*}}void @store_c11(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         store atomic ptr {{.*}}, ptr @atomic_ptr
+void store_c11(int *p) { __c11_atomic_store(&atomic_ptr, p, __ATOMIC_SEQ_CST); }
+
+// FIXME: stores the raw pointer and returns the signed one.
+// CHECK-LABEL: define {{.*}}ptr @exchange_c11(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         atomicrmw xchg ptr @atomic_ptr, ptr {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+int *exchange_c11(int *p) {
+  return __c11_atomic_exchange(&atomic_ptr, p, __ATOMIC_SEQ_CST);
+}
+
+// FIXME: compares the raw expected and stores the raw desired.
+// CHECK-LABEL: define {{.*}}i1 @cmpxchg_c11(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         cmpxchg ptr @atomic_ptr, ptr {{.*}}, ptr {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+_Bool cmpxchg_c11(int **expected, int *desired) {
+  return __c11_atomic_compare_exchange_strong(&atomic_ptr, expected, desired,
+                                              __ATOMIC_SEQ_CST,
+                                              __ATOMIC_SEQ_CST);
+}
+
+// FIXME: compares the raw expected and stores the raw desired.
+// CHECK-LABEL: define {{.*}}i1 @cmpxchg_weak_c11(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         cmpxchg weak ptr @atomic_ptr, ptr {{.*}}, ptr {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+_Bool cmpxchg_weak_c11(int **expected, int *desired) {
+  return __c11_atomic_compare_exchange_weak(&atomic_ptr, expected, desired,
+                                            __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+}
+
+// FIXME: returns the signed pointer.
+// CHECK-LABEL: define {{.*}}ptr @load_n()
+// CHECK:         load atomic ptr, ptr @qualified_ptr
+// CHECK-NOT:     @llvm.ptrauth
+int *load_n(void) { return __atomic_load_n(&qualified_ptr, __ATOMIC_SEQ_CST); }
+
+// FIXME: stores the raw pointer.
+// CHECK-LABEL: define {{.*}}void @store_n(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         store atomic ptr {{.*}}, ptr @qualified_ptr
+void store_n(int *p) { __atomic_store_n(&qualified_ptr, p, __ATOMIC_SEQ_CST); }
+
+// FIXME: stores the raw pointer and returns the signed one.
+// CHECK-LABEL: define {{.*}}ptr @exchange_n(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         atomicrmw xchg ptr @qualified_ptr, ptr {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+int *exchange_n(int *p) {
+  return __atomic_exchange_n(&qualified_ptr, p, __ATOMIC_SEQ_CST);
+}
+
+// FIXME: compares the raw expected and stores the raw desired.
+// CHECK-LABEL: define {{.*}}i1 @cmpxchg_n(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         cmpxchg ptr @qualified_ptr, ptr {{.*}}, ptr {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+_Bool cmpxchg_n(int **expected, int *desired) {
+  return __atomic_compare_exchange_n(&qualified_ptr, expected, desired, 0,
+                                     __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+}
+
+// FIXME: compares the raw expected.
+// CHECK-LABEL: define {{.*}}i1 @cmpxchg_generic(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         cmpxchg ptr @qualified_ptr, ptr {{.*}}, ptr {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+_Bool cmpxchg_generic(int **expected, UniformPtr *desired) {
+  return __atomic_compare_exchange(&qualified_ptr, expected, desired, 0,
+                                   __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+}
+
+// FIXME: stores the signed bits into a raw pointer.
+// CHECK-LABEL: define {{.*}}void @load_generic(
+// CHECK:         [[SIGNED:%.*]] = load atomic ptr, ptr @qualified_ptr
+// CHECK-NEXT:    store ptr [[SIGNED]], ptr
+void load_generic(int **out) {
+  __atomic_load(&qualified_ptr, out, __ATOMIC_SEQ_CST);
+}
+
+// CHECK-LABEL: define {{.*}}void @store_generic(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         store atomic ptr {{.*}}, ptr @qualified_ptr
+void store_generic(UniformPtr *in) {
+  __atomic_store(&qualified_ptr, in, __ATOMIC_SEQ_CST);
+}
+
+// FIXME: stores the raw pointer.
+// CHECK-LABEL: define {{.*}}void @exchange_generic(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         atomicrmw xchg ptr @qualified_ptr, ptr {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+void exchange_generic(int **in, UniformPtr *out) {
+  __atomic_exchange(&qualified_ptr, in, out, __ATOMIC_SEQ_CST);
+}
+
+// CHECK-LABEL: define {{.*}}i1 @cmpxchg_plain_fn(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         cmpxchg ptr @plain_fn, ptr {{.*}}, ptr {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+_Bool cmpxchg_plain_fn(Fn **expected, Fn *desired) {
+  return __c11_atomic_compare_exchange_strong(&plain_fn, expected, desired,
+                                              __ATOMIC_SEQ_CST,
+                                              __ATOMIC_SEQ_CST);
+}
+
+// FIXME: compares and stores pointers signed under the function pointer schema.
+// CHECK-LABEL: define {{.*}}i1 @cmpxchg_fn(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         cmpxchg ptr @atomic_fn, ptr {{.*}}, ptr {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+_Bool cmpxchg_fn(Fn **expected, Fn *desired) {
+  return __c11_atomic_compare_exchange_strong(&atomic_fn, expected, desired,
+                                              __ATOMIC_SEQ_CST,
+                                              __ATOMIC_SEQ_CST);
+}
+
+// FIXME: returns the signed integer.
+// CHECK-LABEL: define {{.*}}i64 @load_int()
+// CHECK:         load atomic i64, ptr @atomic_int
+// CHECK-NOT:     @llvm.ptrauth
+long load_int(void) { return __c11_atomic_load(&atomic_int, __ATOMIC_SEQ_CST); }
+
+// FIXME: stores the raw integer.
+// CHECK-LABEL: define {{.*}}void @store_int(
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         store atomic i64 {{.*}}, ptr @atomic_int
+void store_int(long v) { __c11_atomic_store(&atomic_int, v, __ATOMIC_SEQ_CST); }
+
+// FIXME: adds to the signed bits.
+// CHECK-LABEL: define {{.*}}i64 @fetch_add_int()
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         atomicrmw add ptr @atomic_int, i64 {{.*}}
+// CHECK-NOT:     @llvm.ptrauth
+long fetch_add_int(void) {
+  return __c11_atomic_fetch_add(&atomic_int, 1, __ATOMIC_SEQ_CST);
+}
+
+// FIXME: adds to the signed bits.
+// CHECK-LABEL: define {{.*}}void @add_assign_int()
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         atomicrmw add ptr @atomic_int, i64 1
+// CHECK-NOT:     @llvm.ptrauth
+void add_assign_int(void) { atomic_int += 1; }
+
+// FIXME: adds to the signed bits.
+// CHECK-LABEL: define {{.*}}void @inc_int()
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         atomicrmw add ptr @atomic_int, i64 1
+// CHECK-NOT:     @llvm.ptrauth
+void inc_int(void) { atomic_int++; }
+
+// FIXME: adds to the signed bits.
+// CHECK-LABEL: define {{.*}}i64 @sync_fetch_add_int()
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         atomicrmw add ptr @qualified_int, i64 1
+// CHECK-NOT:     @llvm.ptrauth
+long sync_fetch_add_int(void) { return __sync_fetch_and_add(&qualified_int, 1); }
+
+// FIXME: writes a raw byte into the signed representation.
+// CHECK-LABEL: define {{.*}}i1 @test_and_set()
+// CHECK:         atomicrmw xchg ptr @qualified_ptr, i8 1
+_Bool test_and_set(void) {
+  return __atomic_test_and_set(&qualified_ptr, __ATOMIC_SEQ_CST);
+}
+
+// FIXME: writes a raw byte into the signed representation.
+// CHECK-LABEL: define {{.*}}void @clear()
+// CHECK:         store atomic i8 0, ptr @qualified_ptr
+void clear(void) { __atomic_clear(&qualified_ptr, __ATOMIC_SEQ_CST); }
+
+// FIXME: authenticates once, then compares and increments the signed bits without re-signing.
+// CHECK-LABEL: define {{.*}}void @inc_ptr()
+// CHECK:         call i64 @llvm.ptrauth.auth(i64 {{.*}}, i32 2, i64 50)
+// CHECK:         [[AUTHED:%.*]] = phi ptr [ null, {{.*}} ]
+// CHECK:         [[CUR:%.*]] = phi ptr [ [[AUTHED]], {{.*}} ], [ [[OBSERVED:%.*]], {{.*}} ]
+// CHECK-NEXT:    [[NEW:%.*]] = getelementptr {{.*}}, ptr [[CUR]], i32 1
+// CHECK-NEXT:    [[PAIR:%.*]] = cmpxchg ptr @atomic_ptr, ptr [[CUR]], ptr [[NEW]]
+// CHECK-NEXT:    [[OBSERVED]] = extractvalue { ptr, i1 } [[PAIR]], 0
+// CHECK-NOT:     @llvm.ptrauth
+void inc_ptr(void) { atomic_ptr++; }

>From 1403fce9cf7d082653021aac97b61f5142f6269c Mon Sep 17 00:00:00 2001
From: JF Bastien <github at jfbastien.com>
Date: Mon, 9 Nov 2026 15:10:30 +0900
Subject: [PATCH 2/2] [clang][PAC] Sign and authenticate atomics on __ptrauth
 types

  typedef int *__ptrauth(2, 0, 50) Ptr;
  _Atomic Ptr p;
  int *load(void) { return __c11_atomic_load(&p, __ATOMIC_SEQ_CST); }

returned the signed bits as if they were the pointer, and
__c11_atomic_store wrote the raw pointer, which the next read failed to
authenticate. Loads now authenticate and stores sign, as the implicit
_Atomic operations already do. Same for __c11_atomic_init, exchange,
compare-exchange and the GNU _n forms. A copy between two _Atomic
qualified objects resigns at most once instead of authenticating and
signing.

Operands passed by address, such as the expected of a compare-exchange,
must point to the object's qualified type. __sync_*, atomic arithmetic,
__atomic_test_and_set, __atomic_clear, and implicit ++, -- and compound
assignment of an _Atomic object are rejected.

Assisted-by: AI
---
 clang/docs/PointerAuthentication.md           |   7 +
 clang/docs/ReleaseNotes.md                    |   3 +
 .../clang/Basic/DiagnosticSemaKinds.td        |   7 +
 clang/lib/CodeGen/CGAtomic.cpp                |  49 ++++++-
 clang/lib/CodeGen/CGPointerAuth.cpp           |   7 +
 clang/lib/Sema/SemaChecking.cpp               |  29 +++-
 clang/lib/Sema/SemaExpr.cpp                   |  13 ++
 clang/test/CodeGen/ptrauth-qualifier-atomic.c | 137 +++++-------------
 clang/test/Sema/ptrauth-atomic-ops.c          | 137 ++++++++++++++----
 9 files changed, 250 insertions(+), 139 deletions(-)

diff --git a/clang/docs/PointerAuthentication.md b/clang/docs/PointerAuthentication.md
index 8a77d0178430a3..84bff23dfc8ada 100644
--- a/clang/docs/PointerAuthentication.md
+++ b/clang/docs/PointerAuthentication.md
@@ -431,6 +431,13 @@ a discriminator determined as follows:
   is `ptrauth_blend_discriminator(&x, discriminator)`; see
   [`ptrauth_blend_discriminator`](#ptrauth-blend-discriminator).
 
+Atomic initialization, load, store, exchange and compare-exchange on a
+`__ptrauth`-qualified object use its schema. An operand passed by address,
+such as the `expected` of a compare-exchange, must point to the object's
+`__ptrauth`-qualified type. Atomic arithmetic, `__sync_*`,
+`__atomic_test_and_set`, `__atomic_clear`, and implicit increment, decrement
+and compound assignment of an `_Atomic` object are rejected.
+
 ##### Non-triviality from address diversity
 
 Address diversity must impose additional restrictions in order to allow the
diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index 603b3096259cb5..80eb391f545256 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -1336,6 +1336,9 @@ documentation](CIR/index.md) for more information regarding ClangIR's status and
   pointers stored in VTTs via the `-fptrauth-vtt-vtable-pointer-discrimination`
   option.
 
+- Atomic load, store, exchange and compare-exchange on a `__ptrauth`-qualified
+  object now sign and authenticate.
+
 - Added support for the `aarch64-unknown-uefi` target triple. Like
   `x86_64-unknown-uefi`, it follows the Microsoft ABI conventions (LLP64,
   Microsoft C++ ABI, `char *` based `va_list`) and links with `lld-link`.
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 80de4627959c4b..f9046207551f7f 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -9700,6 +9700,13 @@ def err_atomic_op_needs_non_const_pointer : Error<
 def err_atomic_op_needs_non_address_discriminated_pointer : Error<
   "address argument to %select{atomic|__sync}0 operation must be a pointer to a non address discriminated "
   "type (%1 invalid)">;
+def err_atomic_op_needs_non_ptrauth_pointer : Error<
+  "address argument to %select{__sync|atomic arithmetic|atomic test-and-set or "
+  "clear}0 operation must not be a pointer to a '__ptrauth'-qualified type (%1 "
+  "invalid)">;
+def err_ptrauth_atomic_rmw : Error<
+  "atomic %select{increment|decrement|compound assignment}0 of "
+  "'__ptrauth'-qualified type %1 is not supported">;
 def err_atomic_op_needs_trivial_copy : Error<
   "address argument to atomic operation must be a pointer to a "
   "trivially-copyable type (%0 invalid)">;
diff --git a/clang/lib/CodeGen/CGAtomic.cpp b/clang/lib/CodeGen/CGAtomic.cpp
index cd7b278eab15d9..d1f9592a0bf163 100644
--- a/clang/lib/CodeGen/CGAtomic.cpp
+++ b/clang/lib/CodeGen/CGAtomic.cpp
@@ -375,6 +375,20 @@ bool AtomicInfo::emitMemSetZeroIfNecessary() const {
   return true;
 }
 
+/// The '__ptrauth' qualifier of the object of \p E when the result of \p E is
+/// a plain value.
+static PointerAuthQualifier getResultPointerAuth(const AtomicExpr *E) {
+  switch (E->getOp()) {
+  case AtomicExpr::AO__atomic_load:
+  case AtomicExpr::AO__atomic_exchange:
+  case AtomicExpr::AO__scoped_atomic_load:
+  case AtomicExpr::AO__scoped_atomic_exchange:
+    return PointerAuthQualifier();
+  default:
+    return E->getPtr()->getType()->getPointeeType().getPointerAuth();
+  }
+}
+
 static void emitAtomicCmpXchg(CodeGenFunction &CGF, AtomicExpr *E, bool IsWeak,
                               Address Dest, Address Ptr, Address Val1,
                               Address Val2, Address ExpectedResult,
@@ -633,7 +647,12 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, Address Dest,
     Load->setVolatile(E->isVolatile());
     CGF.getTargetHooks().setTargetAtomicMetadata(CGF, *Load, E);
     CGF.maybeAttachRangeForLoad(Load, E->getValueType(), E->getExprLoc());
-    auto *I = CGF.Builder.CreateStore(Load, Dest);
+    llvm::Value *Result = Load;
+    if (PointerAuthQualifier PtrAuth = getResultPointerAuth(E))
+      Result = CGF.EmitPointerAuthUnqualify(
+          PtrAuth, Load, E->getValueType().getUnqualifiedType(), Ptr,
+          /*IsKnownNonNull=*/false);
+    auto *I = CGF.Builder.CreateStore(Result, Dest);
     CGF.addInstToCurrentSourceAtom(I, Load);
     return;
   }
@@ -838,6 +857,12 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, Address Dest,
   // For __atomic_*_fetch operations, perform the operation again to
   // determine the value which was written.
   llvm::Value *Result = RMWI;
+  if (PointerAuthQualifier PtrAuth = getResultPointerAuth(E)) {
+    assert(Op == llvm::AtomicRMWInst::Xchg && !PostOp && !PostOpMinMax);
+    Result = CGF.EmitPointerAuthUnqualify(
+        PtrAuth, RMWI, E->getValueType().getUnqualifiedType(), Ptr,
+        /*IsKnownNonNull=*/false);
+  }
   if (PostOpMinMax)
     Result = EmitPostAtomicMinMax(CGF.Builder, E->getOp(),
                                   E->getValueType()->isSignedIntegerType(),
@@ -854,11 +879,15 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, Address Dest,
 
 // This function emits any expression (scalar, complex, or aggregate)
 // into a temporary alloca.
-static Address
-EmitValToTemp(CodeGenFunction &CGF, Expr *E) {
+static Address EmitValToTemp(CodeGenFunction &CGF, Expr *E,
+                             PointerAuthQualifier PtrAuth, Address Ptr) {
   Address DeclPtr = CGF.CreateMemTempWithoutCast(E->getType(), ".atomictmp");
-  CGF.EmitAnyExprToMem(E, DeclPtr, E->getType().getQualifiers(),
-                       /*Init*/ true);
+  if (PtrAuth)
+    CGF.Builder.CreateStore(CGF.EmitPointerAuthQualify(PtrAuth, E, Ptr),
+                            DeclPtr);
+  else
+    CGF.EmitAnyExprToMem(E, DeclPtr, E->getType().getQualifiers(),
+                         /*Init*/ true);
   return DeclPtr;
 }
 
@@ -1030,7 +1059,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {
         E->getOp() == AtomicExpr::AO__scoped_atomic_compare_exchange)
       Val2 = EmitPointerWithAlignment(E->getVal2());
     else
-      Val2 = EmitValToTemp(*this, E->getVal2());
+      Val2 = EmitValToTemp(*this, E->getVal2(), AtomicTy.getPointerAuth(), Ptr);
     OrderFail = EmitScalarExpr(E->getOrderFail());
     if (E->getOp() == AtomicExpr::AO__atomic_compare_exchange_n ||
         E->getOp() == AtomicExpr::AO__atomic_compare_exchange ||
@@ -1133,7 +1162,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {
   case AtomicExpr::AO__atomic_fetch_fmaximum:
   case AtomicExpr::AO__atomic_fetch_fminimum_num:
   case AtomicExpr::AO__atomic_fetch_fmaximum_num:
-    Val1 = EmitValToTemp(*this, E->getVal1());
+    Val1 = EmitValToTemp(*this, E->getVal1(), AtomicTy.getPointerAuth(), Ptr);
     break;
   }
 
@@ -2222,7 +2251,11 @@ void CodeGenFunction::EmitAtomicInit(Expr *init, LValue dest) {
 
   switch (atomics.getEvaluationKind()) {
   case TEK_Scalar: {
-    llvm::Value *value = EmitScalarExpr(init);
+    llvm::Value *value;
+    if (PointerAuthQualifier PtrAuth = dest.getQuals().getPointerAuth())
+      value = EmitPointerAuthQualify(PtrAuth, init, dest.getAddress());
+    else
+      value = EmitScalarExpr(init);
     atomics.emitCopyIntoMemory(RValue::get(value));
     return;
   }
diff --git a/clang/lib/CodeGen/CGPointerAuth.cpp b/clang/lib/CodeGen/CGPointerAuth.cpp
index 62697b317f9126..6072f87bd0ad22 100644
--- a/clang/lib/CodeGen/CGPointerAuth.cpp
+++ b/clang/lib/CodeGen/CGPointerAuth.cpp
@@ -263,6 +263,13 @@ CodeGenFunction::EmitPointerAuthQualify(PointerAuthQualifier DestQualifier,
                                         const Expr *E,
                                         Address DestStorageAddress) {
   assert(DestQualifier);
+  E = E->IgnoreParens();
+  while (const auto *Cast = dyn_cast<CastExpr>(E)) {
+    if (Cast->getCastKind() != CK_NonAtomicToAtomic &&
+        Cast->getCastKind() != CK_AtomicToNonAtomic)
+      break;
+    E = Cast->getSubExpr()->IgnoreParens();
+  }
   auto [Value, CurAuthInfo] = EmitOrigPointerRValue(E);
 
   CGPointerAuthInfo DestAuthInfo =
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 4b9c1d187dfeb9..22c6c54853f872 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -5461,6 +5461,15 @@ ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
     }
   }
 
+  if (AtomTy.getPointerAuth()) {
+    bool IsByte = Form == TestAndSetByte || Form == ClearByte;
+    if (IsByte || Form == Arithmetic) {
+      Diag(ExprRange.getBegin(), diag::err_atomic_op_needs_non_ptrauth_pointer)
+          << (IsByte ? 2 : 1) << Ptr->getType() << Ptr->getSourceRange();
+      return ExprError();
+    }
+  }
+
   if (Form != TestAndSetByte && Form != ClearByte) {
     // Pointer to object of size zero is not allowed.
     if (RequireCompleteType(Ptr->getBeginLoc(), AtomTy,
@@ -5572,6 +5581,11 @@ ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
   // pointer to a const 'A'.
   ValType.removeLocalVolatile();
   ValType.removeLocalConst();
+  if (ValType.getPointerAuth()) {
+    Qualifiers Quals = ValType.getQualifiers();
+    Quals.removePointerAuth();
+    ValType = Context.getQualifiedType(ValType.getUnqualifiedType(), Quals);
+  }
   QualType ResultType = ValType;
   if (Form == Copy || Form == LoadCopy || Form == GNUXchg || Form == Init ||
       Form == ClearByte)
@@ -5671,8 +5685,11 @@ ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
                   ValArg->getType()->getAs<PointerType>()) {
             AS = PtrTy->getPointeeType().getAddressSpace();
           }
-          Ty = Context.getPointerType(
-              Context.getAddrSpaceQualType(ValType.getUnqualifiedType(), AS));
+          QualType Pointee = ValType.getUnqualifiedType();
+          if (PointerAuth)
+            Pointee = Context.getPointerAuthType(Pointee, PointerAuth);
+          Ty =
+              Context.getPointerType(Context.getAddrSpaceQualType(Pointee, AS));
         }
         break;
       case 2:
@@ -5872,11 +5889,9 @@ ExprResult Sema::BuiltinAtomicOverloaded(ExprResult TheCallResult) {
         << FirstArg->getType() << 0 << FirstArg->getSourceRange();
     return ExprError();
   }
-  PointerAuthQualifier PointerAuth = ValType.getPointerAuth();
-  if (PointerAuth && PointerAuth.isAddressDiscriminated()) {
-    Diag(FirstArg->getBeginLoc(),
-         diag::err_atomic_op_needs_non_address_discriminated_pointer)
-        << 1 << ValType << FirstArg->getSourceRange();
+  if (ValType.getPointerAuth()) {
+    Diag(FirstArg->getBeginLoc(), diag::err_atomic_op_needs_non_ptrauth_pointer)
+        << 0 << FirstArg->getType() << FirstArg->getSourceRange();
     return ExprError();
   }
 
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 5c3541cfab0187..81daeeb82a7db7 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -15072,6 +15072,11 @@ static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
                                                SourceLocation OpLoc, bool IsInc,
                                                bool IsPrefix) {
   QualType ResType = Op->getType();
+  if (ResType.getPointerAuth() && ResType->isAtomicType()) {
+    S.Diag(OpLoc, diag::err_ptrauth_atomic_rmw)
+        << (IsInc ? 0 : 1) << ResType << Op->getSourceRange();
+    return QualType();
+  }
   // Atomic types can be used for increment / decrement where the non-atomic
   // versions can, so ignore the _Atomic() specifier for the purpose of
   // checking.
@@ -15900,6 +15905,14 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
     }
   }
 
+  if (BinaryOperator::isCompoundAssignmentOp(Opc) &&
+      LHSExpr->getType().getPointerAuth() &&
+      LHSExpr->getType()->isAtomicType()) {
+    Diag(OpLoc, diag::err_ptrauth_atomic_rmw)
+        << 2 << LHSExpr->getType() << LHSExpr->getSourceRange();
+    return ExprError();
+  }
+
   checkTypeSupport(LHSExpr->getType(), OpLoc, /*ValueDecl*/ nullptr);
   checkTypeSupport(RHSExpr->getType(), OpLoc, /*ValueDecl*/ nullptr);
 
diff --git a/clang/test/CodeGen/ptrauth-qualifier-atomic.c b/clang/test/CodeGen/ptrauth-qualifier-atomic.c
index dc939dfd710684..a7b135344fa9ad 100644
--- a/clang/test/CodeGen/ptrauth-qualifier-atomic.c
+++ b/clang/test/CodeGen/ptrauth-qualifier-atomic.c
@@ -10,7 +10,6 @@ _Atomic UniformPtr atomic_ptr, atomic_src;
 _Atomic AuthPtr atomic_auth, atomic_auth_src;
 UniformPtr qualified_ptr;
 _Atomic UniformInt atomic_int;
-UniformInt qualified_int;
 _Atomic(Fn *) plain_fn;
 _Atomic UniformFn atomic_fn;
 
@@ -26,12 +25,8 @@ int *load_implicit(void) { return atomic_ptr; }
 // CHECK-NEXT:    store atomic ptr [[SIGNED]], ptr @atomic_ptr
 void store_implicit(int *p) { atomic_ptr = p; }
 
-// FIXME: authenticates and re-signs under the same schema.
 // CHECK-LABEL: define {{.*}}void @copy_implicit()
-// CHECK:         load atomic ptr, ptr @atomic_src
-// CHECK:         call i64 @llvm.ptrauth.auth(i64 {{.*}}, i32 2, i64 50)
-// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
-// CHECK:         [[SIGNED:%.*]] = phi ptr
+// CHECK:         [[SIGNED:%.*]] = load atomic ptr, ptr @atomic_src
 // CHECK-NEXT:    store atomic ptr [[SIGNED]], ptr @atomic_ptr
 void copy_implicit(void) { atomic_ptr = atomic_src; }
 
@@ -49,12 +44,12 @@ int *load_implicit_auth(void) { return atomic_auth; }
 // CHECK-NEXT:    store atomic ptr [[SIGNED]], ptr @atomic_auth
 void store_implicit_auth(int *p) { atomic_auth = p; }
 
-// FIXME: authenticates and re-signs instead of one resign.
 // CHECK-LABEL: define {{.*}}void @copy_implicit_auth()
 // CHECK:         [[SRC:%.*]] = call i64 @llvm.ptrauth.blend(i64 ptrtoint (ptr @atomic_auth_src to i64), i64 100)
-// CHECK:         call i64 @llvm.ptrauth.auth(i64 {{.*}}, i32 2, i64 [[SRC]])
-// CHECK:         [[DST:%.*]] = call i64 @llvm.ptrauth.blend(i64 ptrtoint (ptr @atomic_auth to i64), i64 100)
-// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 [[DST]])
+// CHECK-NEXT:    [[DST:%.*]] = call i64 @llvm.ptrauth.blend(i64 ptrtoint (ptr @atomic_auth to i64), i64 100)
+// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         call i64 @llvm.ptrauth.resign(i64 {{.*}}, i32 2, i64 [[SRC]], i32 2, i64 [[DST]])
+// CHECK-NOT:     @llvm.ptrauth
 // CHECK:         [[SIGNED:%.*]] = phi ptr
 // CHECK-NEXT:    store atomic ptr [[SIGNED]], ptr @atomic_auth
 void copy_implicit_auth(void) { atomic_auth = atomic_auth_src; }
@@ -77,100 +72,100 @@ Fn *load_fn_implicit(void) { return atomic_fn; }
 // CHECK-NEXT:    store ptr [[SIGNED]], ptr %l
 void init_decl(int *p) { _Atomic UniformPtr l = p; }
 
-// FIXME: stores the raw pointer.
 // CHECK-LABEL: define {{.*}}void @init_c11(
-// CHECK-NOT:     @llvm.ptrauth
-// CHECK:         store ptr {{.*}}, ptr @atomic_ptr
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
+// CHECK:         [[SIGNED:%.*]] = phi ptr
+// CHECK-NEXT:    store ptr [[SIGNED]], ptr @atomic_ptr
 void init_c11(int *p) { __c11_atomic_init(&atomic_ptr, p); }
 
-// FIXME: returns the signed pointer.
 // CHECK-LABEL: define {{.*}}ptr @load_c11()
-// CHECK:         load atomic ptr, ptr @atomic_ptr
-// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         [[SIGNED:%.*]] = load atomic ptr, ptr @atomic_ptr
+// CHECK:         [[INT:%.*]] = ptrtoint ptr [[SIGNED]] to i64
+// CHECK-NEXT:    call i64 @llvm.ptrauth.auth(i64 [[INT]], i32 2, i64 50)
 int *load_c11(void) { return __c11_atomic_load(&atomic_ptr, __ATOMIC_SEQ_CST); }
 
-// FIXME: stores the raw pointer.
 // CHECK-LABEL: define {{.*}}void @store_c11(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
 // CHECK-NOT:     @llvm.ptrauth
 // CHECK:         store atomic ptr {{.*}}, ptr @atomic_ptr
 void store_c11(int *p) { __c11_atomic_store(&atomic_ptr, p, __ATOMIC_SEQ_CST); }
 
-// FIXME: stores the raw pointer and returns the signed one.
 // CHECK-LABEL: define {{.*}}ptr @exchange_c11(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
 // CHECK-NOT:     @llvm.ptrauth
-// CHECK:         atomicrmw xchg ptr @atomic_ptr, ptr {{.*}}
-// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         [[OLD:%.*]] = atomicrmw xchg ptr @atomic_ptr, ptr {{.*}}
+// CHECK:         [[INT:%.*]] = ptrtoint ptr [[OLD]] to i64
+// CHECK-NEXT:    call i64 @llvm.ptrauth.auth(i64 [[INT]], i32 2, i64 50)
 int *exchange_c11(int *p) {
   return __c11_atomic_exchange(&atomic_ptr, p, __ATOMIC_SEQ_CST);
 }
 
-// FIXME: compares the raw expected and stores the raw desired.
 // CHECK-LABEL: define {{.*}}i1 @cmpxchg_c11(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
 // CHECK-NOT:     @llvm.ptrauth
 // CHECK:         cmpxchg ptr @atomic_ptr, ptr {{.*}}, ptr {{.*}}
 // CHECK-NOT:     @llvm.ptrauth
-_Bool cmpxchg_c11(int **expected, int *desired) {
+_Bool cmpxchg_c11(UniformPtr *expected, int *desired) {
   return __c11_atomic_compare_exchange_strong(&atomic_ptr, expected, desired,
                                               __ATOMIC_SEQ_CST,
                                               __ATOMIC_SEQ_CST);
 }
 
-// FIXME: compares the raw expected and stores the raw desired.
 // CHECK-LABEL: define {{.*}}i1 @cmpxchg_weak_c11(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
 // CHECK-NOT:     @llvm.ptrauth
 // CHECK:         cmpxchg weak ptr @atomic_ptr, ptr {{.*}}, ptr {{.*}}
 // CHECK-NOT:     @llvm.ptrauth
-_Bool cmpxchg_weak_c11(int **expected, int *desired) {
+_Bool cmpxchg_weak_c11(UniformPtr *expected, int *desired) {
   return __c11_atomic_compare_exchange_weak(&atomic_ptr, expected, desired,
                                             __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
 }
 
-// FIXME: returns the signed pointer.
 // CHECK-LABEL: define {{.*}}ptr @load_n()
-// CHECK:         load atomic ptr, ptr @qualified_ptr
-// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         [[SIGNED:%.*]] = load atomic ptr, ptr @qualified_ptr
+// CHECK:         [[INT:%.*]] = ptrtoint ptr [[SIGNED]] to i64
+// CHECK-NEXT:    call i64 @llvm.ptrauth.auth(i64 [[INT]], i32 2, i64 50)
 int *load_n(void) { return __atomic_load_n(&qualified_ptr, __ATOMIC_SEQ_CST); }
 
-// FIXME: stores the raw pointer.
 // CHECK-LABEL: define {{.*}}void @store_n(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
 // CHECK-NOT:     @llvm.ptrauth
 // CHECK:         store atomic ptr {{.*}}, ptr @qualified_ptr
 void store_n(int *p) { __atomic_store_n(&qualified_ptr, p, __ATOMIC_SEQ_CST); }
 
-// FIXME: stores the raw pointer and returns the signed one.
 // CHECK-LABEL: define {{.*}}ptr @exchange_n(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
 // CHECK-NOT:     @llvm.ptrauth
-// CHECK:         atomicrmw xchg ptr @qualified_ptr, ptr {{.*}}
-// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         [[OLD:%.*]] = atomicrmw xchg ptr @qualified_ptr, ptr {{.*}}
+// CHECK:         [[INT:%.*]] = ptrtoint ptr [[OLD]] to i64
+// CHECK-NEXT:    call i64 @llvm.ptrauth.auth(i64 [[INT]], i32 2, i64 50)
 int *exchange_n(int *p) {
   return __atomic_exchange_n(&qualified_ptr, p, __ATOMIC_SEQ_CST);
 }
 
-// FIXME: compares the raw expected and stores the raw desired.
 // CHECK-LABEL: define {{.*}}i1 @cmpxchg_n(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 50)
 // CHECK-NOT:     @llvm.ptrauth
 // CHECK:         cmpxchg ptr @qualified_ptr, ptr {{.*}}, ptr {{.*}}
 // CHECK-NOT:     @llvm.ptrauth
-_Bool cmpxchg_n(int **expected, int *desired) {
+_Bool cmpxchg_n(UniformPtr *expected, int *desired) {
   return __atomic_compare_exchange_n(&qualified_ptr, expected, desired, 0,
                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
 }
 
-// FIXME: compares the raw expected.
 // CHECK-LABEL: define {{.*}}i1 @cmpxchg_generic(
 // CHECK-NOT:     @llvm.ptrauth
 // CHECK:         cmpxchg ptr @qualified_ptr, ptr {{.*}}, ptr {{.*}}
 // CHECK-NOT:     @llvm.ptrauth
-_Bool cmpxchg_generic(int **expected, UniformPtr *desired) {
+_Bool cmpxchg_generic(UniformPtr *expected, UniformPtr *desired) {
   return __atomic_compare_exchange(&qualified_ptr, expected, desired, 0,
                                    __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
 }
 
-// FIXME: stores the signed bits into a raw pointer.
 // CHECK-LABEL: define {{.*}}void @load_generic(
 // CHECK:         [[SIGNED:%.*]] = load atomic ptr, ptr @qualified_ptr
 // CHECK-NEXT:    store ptr [[SIGNED]], ptr
-void load_generic(int **out) {
+void load_generic(UniformPtr *out) {
   __atomic_load(&qualified_ptr, out, __ATOMIC_SEQ_CST);
 }
 
@@ -181,12 +176,11 @@ void store_generic(UniformPtr *in) {
   __atomic_store(&qualified_ptr, in, __ATOMIC_SEQ_CST);
 }
 
-// FIXME: stores the raw pointer.
 // CHECK-LABEL: define {{.*}}void @exchange_generic(
 // CHECK-NOT:     @llvm.ptrauth
 // CHECK:         atomicrmw xchg ptr @qualified_ptr, ptr {{.*}}
 // CHECK-NOT:     @llvm.ptrauth
-void exchange_generic(int **in, UniformPtr *out) {
+void exchange_generic(UniformPtr *in, UniformPtr *out) {
   __atomic_exchange(&qualified_ptr, in, out, __ATOMIC_SEQ_CST);
 }
 
@@ -200,78 +194,25 @@ _Bool cmpxchg_plain_fn(Fn **expected, Fn *desired) {
                                               __ATOMIC_SEQ_CST);
 }
 
-// FIXME: compares and stores pointers signed under the function pointer schema.
 // CHECK-LABEL: define {{.*}}i1 @cmpxchg_fn(
 // CHECK-NOT:     @llvm.ptrauth
+// CHECK:         call i64 @llvm.ptrauth.resign(i64 {{.*}}, i32 0, i64 0, i32 0, i64 300)
+// CHECK-NOT:     @llvm.ptrauth
 // CHECK:         cmpxchg ptr @atomic_fn, ptr {{.*}}, ptr {{.*}}
 // CHECK-NOT:     @llvm.ptrauth
-_Bool cmpxchg_fn(Fn **expected, Fn *desired) {
+_Bool cmpxchg_fn(UniformFn *expected, Fn *desired) {
   return __c11_atomic_compare_exchange_strong(&atomic_fn, expected, desired,
                                               __ATOMIC_SEQ_CST,
                                               __ATOMIC_SEQ_CST);
 }
 
-// FIXME: returns the signed integer.
 // CHECK-LABEL: define {{.*}}i64 @load_int()
-// CHECK:         load atomic i64, ptr @atomic_int
-// CHECK-NOT:     @llvm.ptrauth
+// CHECK:         [[SIGNED:%.*]] = load atomic i64, ptr @atomic_int
+// CHECK:         call i64 @llvm.ptrauth.auth(i64 [[SIGNED]], i32 2, i64 200)
 long load_int(void) { return __c11_atomic_load(&atomic_int, __ATOMIC_SEQ_CST); }
 
-// FIXME: stores the raw integer.
 // CHECK-LABEL: define {{.*}}void @store_int(
+// CHECK:         call i64 @llvm.ptrauth.sign(i64 {{.*}}, i32 2, i64 200)
 // CHECK-NOT:     @llvm.ptrauth
 // CHECK:         store atomic i64 {{.*}}, ptr @atomic_int
 void store_int(long v) { __c11_atomic_store(&atomic_int, v, __ATOMIC_SEQ_CST); }
-
-// FIXME: adds to the signed bits.
-// CHECK-LABEL: define {{.*}}i64 @fetch_add_int()
-// CHECK-NOT:     @llvm.ptrauth
-// CHECK:         atomicrmw add ptr @atomic_int, i64 {{.*}}
-// CHECK-NOT:     @llvm.ptrauth
-long fetch_add_int(void) {
-  return __c11_atomic_fetch_add(&atomic_int, 1, __ATOMIC_SEQ_CST);
-}
-
-// FIXME: adds to the signed bits.
-// CHECK-LABEL: define {{.*}}void @add_assign_int()
-// CHECK-NOT:     @llvm.ptrauth
-// CHECK:         atomicrmw add ptr @atomic_int, i64 1
-// CHECK-NOT:     @llvm.ptrauth
-void add_assign_int(void) { atomic_int += 1; }
-
-// FIXME: adds to the signed bits.
-// CHECK-LABEL: define {{.*}}void @inc_int()
-// CHECK-NOT:     @llvm.ptrauth
-// CHECK:         atomicrmw add ptr @atomic_int, i64 1
-// CHECK-NOT:     @llvm.ptrauth
-void inc_int(void) { atomic_int++; }
-
-// FIXME: adds to the signed bits.
-// CHECK-LABEL: define {{.*}}i64 @sync_fetch_add_int()
-// CHECK-NOT:     @llvm.ptrauth
-// CHECK:         atomicrmw add ptr @qualified_int, i64 1
-// CHECK-NOT:     @llvm.ptrauth
-long sync_fetch_add_int(void) { return __sync_fetch_and_add(&qualified_int, 1); }
-
-// FIXME: writes a raw byte into the signed representation.
-// CHECK-LABEL: define {{.*}}i1 @test_and_set()
-// CHECK:         atomicrmw xchg ptr @qualified_ptr, i8 1
-_Bool test_and_set(void) {
-  return __atomic_test_and_set(&qualified_ptr, __ATOMIC_SEQ_CST);
-}
-
-// FIXME: writes a raw byte into the signed representation.
-// CHECK-LABEL: define {{.*}}void @clear()
-// CHECK:         store atomic i8 0, ptr @qualified_ptr
-void clear(void) { __atomic_clear(&qualified_ptr, __ATOMIC_SEQ_CST); }
-
-// FIXME: authenticates once, then compares and increments the signed bits without re-signing.
-// CHECK-LABEL: define {{.*}}void @inc_ptr()
-// CHECK:         call i64 @llvm.ptrauth.auth(i64 {{.*}}, i32 2, i64 50)
-// CHECK:         [[AUTHED:%.*]] = phi ptr [ null, {{.*}} ]
-// CHECK:         [[CUR:%.*]] = phi ptr [ [[AUTHED]], {{.*}} ], [ [[OBSERVED:%.*]], {{.*}} ]
-// CHECK-NEXT:    [[NEW:%.*]] = getelementptr {{.*}}, ptr [[CUR]], i32 1
-// CHECK-NEXT:    [[PAIR:%.*]] = cmpxchg ptr @atomic_ptr, ptr [[CUR]], ptr [[NEW]]
-// CHECK-NEXT:    [[OBSERVED]] = extractvalue { ptr, i1 } [[PAIR]], 0
-// CHECK-NOT:     @llvm.ptrauth
-void inc_ptr(void) { atomic_ptr++; }
diff --git a/clang/test/Sema/ptrauth-atomic-ops.c b/clang/test/Sema/ptrauth-atomic-ops.c
index a5411f2e197b3f..ec0580efaf5a8b 100644
--- a/clang/test/Sema/ptrauth-atomic-ops.c
+++ b/clang/test/Sema/ptrauth-atomic-ops.c
@@ -7,6 +7,8 @@ int i;
 int *__ptrauth(2, 1, 100) authenticated_ptr = &i;
 int *__ptrauth(2, 0, 200) non_addr_discriminatedauthenticated_ptr = &i;
 int * wat = &i;
+long __ptrauth(2, 0, 200) qualified_int;
+_Atomic long __ptrauth(2, 0, 200) atomic_qualified_int;
 #define ATOMIZE(p) (__typeof__(p) volatile _Atomic *)(long)(&p)
 
 void f() {
@@ -28,23 +30,23 @@ void f() {
   __atomic_exchange(ATOMIZE(authenticated_ptr), &j, &j, memory_order_seq_cst);
   // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
   __c11_atomic_fetch_add(ATOMIZE(authenticated_ptr), 1, memory_order_seq_cst);
-  // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
   __atomic_fetch_add(ATOMIZE(authenticated_ptr), 3, memory_order_seq_cst);
-  // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
   __atomic_fetch_sub(ATOMIZE(authenticated_ptr), 3, memory_order_seq_cst);
-  // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
   __atomic_fetch_min(ATOMIZE(authenticated_ptr), 3, memory_order_seq_cst);
-  // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
   __atomic_fetch_max(ATOMIZE(authenticated_ptr), 3, memory_order_seq_cst);
-  // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
   __c11_atomic_fetch_and(ATOMIZE(authenticated_ptr), 1, memory_order_seq_cst);
-  // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
   __atomic_fetch_and(ATOMIZE(authenticated_ptr), 3, memory_order_seq_cst);
-  // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
   __atomic_fetch_or(ATOMIZE(authenticated_ptr), 3, memory_order_seq_cst);
-  // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
   __atomic_fetch_xor(ATOMIZE(authenticated_ptr), 3, memory_order_seq_cst);
-  // expected-error at -1 {{address argument to atomic operation must be a pointer to a non address discriminated type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
 
   __c11_atomic_init(ATOMIZE(non_addr_discriminatedauthenticated_ptr), &j);
   __c11_atomic_store(ATOMIZE(non_addr_discriminatedauthenticated_ptr), 0, memory_order_relaxed);
@@ -54,65 +56,148 @@ void f() {
   __c11_atomic_exchange(ATOMIZE(j), ATOMIZE(non_addr_discriminatedauthenticated_ptr), memory_order_seq_cst);
   // expected-error at -1 {{incompatible pointer to integer conversion passing 'volatile __ptrauth(2,0,200) _Atomic(int *) *' to parameter of type 'typeof (j)' (aka 'int')}}
   __c11_atomic_fetch_add(ATOMIZE(non_addr_discriminatedauthenticated_ptr), ATOMIZE(j), memory_order_seq_cst);
-  // expected-error at -1 {{incompatible pointer to integer conversion passing 'volatile _Atomic(typeof (j)) *' to parameter of type '__ptrdiff_t'}}
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,0,200) _Atomic(int *) *' invalid)}}
   __c11_atomic_fetch_and(ATOMIZE(j), ATOMIZE(non_addr_discriminatedauthenticated_ptr), memory_order_seq_cst);
   // expected-error at -1 {{incompatible pointer to integer conversion passing 'volatile __ptrauth(2,0,200) _Atomic(int *) *' to parameter of type 'typeof (j)' (aka 'int')}}
+  __c11_atomic_fetch_add(ATOMIZE(non_addr_discriminatedauthenticated_ptr), 1, memory_order_seq_cst);
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,0,200) _Atomic(int *) *' invalid)}}
+  __atomic_fetch_add(&non_addr_discriminatedauthenticated_ptr, 1, memory_order_seq_cst);
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
+  __c11_atomic_fetch_add(&atomic_qualified_int, 1, memory_order_seq_cst);
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('__ptrauth(2,0,200) _Atomic(long) *' invalid)}}
+  __atomic_fetch_add(&qualified_int, 1, memory_order_seq_cst);
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('__ptrauth(2,0,200) long *' invalid)}}
+  __atomic_fetch_or(&atomic_qualified_int, 1, memory_order_seq_cst);
+  // expected-error at -1 {{address argument to atomic arithmetic operation must not be a pointer to a '__ptrauth'-qualified type ('__ptrauth(2,0,200) _Atomic(long) *' invalid)}}
+
+  __atomic_test_and_set(&non_addr_discriminatedauthenticated_ptr, memory_order_seq_cst);
+  // expected-error at -1 {{address argument to atomic test-and-set or clear operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
+  __atomic_clear(&non_addr_discriminatedauthenticated_ptr, memory_order_seq_cst);
+  // expected-error at -1 {{address argument to atomic test-and-set or clear operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
+  __atomic_test_and_set(ATOMIZE(authenticated_ptr), memory_order_seq_cst);
+  // expected-error at -1 {{address argument to atomic test-and-set or clear operation must not be a pointer to a '__ptrauth'-qualified type ('volatile __ptrauth(2,1,100) _Atomic(int *) *' invalid)}}
+  __atomic_clear(&qualified_int, memory_order_seq_cst);
+  // expected-error at -1 {{address argument to atomic test-and-set or clear operation must not be a pointer to a '__ptrauth'-qualified type ('__ptrauth(2,0,200) long *' invalid)}}
+
+  (*ATOMIZE(non_addr_discriminatedauthenticated_ptr))++;
+  // expected-error at -1 {{atomic increment of '__ptrauth'-qualified type 'volatile __ptrauth(2,0,200) _Atomic(int *)' is not supported}}
+  --(*ATOMIZE(non_addr_discriminatedauthenticated_ptr));
+  // expected-error at -1 {{atomic decrement of '__ptrauth'-qualified type 'volatile __ptrauth(2,0,200) _Atomic(int *)' is not supported}}
+  (*ATOMIZE(non_addr_discriminatedauthenticated_ptr)) += 1;
+  // expected-error at -1 {{atomic compound assignment of '__ptrauth'-qualified type 'volatile __ptrauth(2,0,200) _Atomic(int *)' is not supported}}
+  (*ATOMIZE(authenticated_ptr))--;
+  // expected-error at -1 {{atomic decrement of '__ptrauth'-qualified type 'volatile __ptrauth(2,1,100) _Atomic(int *)' is not supported}}
+  atomic_qualified_int++;
+  // expected-error at -1 {{atomic increment of '__ptrauth'-qualified type '__ptrauth(2,0,200) _Atomic(long)' is not supported}}
+  ++atomic_qualified_int;
+  // expected-error at -1 {{atomic increment of '__ptrauth'-qualified type '__ptrauth(2,0,200) _Atomic(long)' is not supported}}
+  atomic_qualified_int -= 2;
+  // expected-error at -1 {{atomic compound assignment of '__ptrauth'-qualified type '__ptrauth(2,0,200) _Atomic(long)' is not supported}}
+  atomic_qualified_int |= 2;
+  // expected-error at -1 {{atomic compound assignment of '__ptrauth'-qualified type '__ptrauth(2,0,200) _Atomic(long)' is not supported}}
+  qualified_int++;
+  qualified_int += 2;
+  atomic_qualified_int = 3;
 
 
   __sync_fetch_and_add(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_fetch_and_sub(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_fetch_and_or(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_fetch_and_and(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_fetch_and_xor(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_fetch_and_nand(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
 
   __sync_add_and_fetch(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_sub_and_fetch(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_or_and_fetch(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_and_and_fetch(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_xor_and_fetch(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_nand_and_fetch(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
 
   __sync_bool_compare_and_swap(&authenticated_ptr, 1, 0);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_val_compare_and_swap(&authenticated_ptr, 1, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
 
   __sync_lock_test_and_set(&authenticated_ptr, 1);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
   __sync_lock_release(&authenticated_ptr);
-  // expected-error at -1 {{address argument to __sync operation must be a pointer to a non address discriminated type ('int *__ptrauth(2,1,100)' invalid)}}
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,1,100) *' invalid)}}
 
 
 int i = 0;
 
   __sync_fetch_and_add(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_fetch_and_sub(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_fetch_and_or(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_fetch_and_and(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_fetch_and_xor(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
 
   __sync_add_and_fetch(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_sub_and_fetch(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_or_and_fetch(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_and_and_fetch(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_xor_and_fetch(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
 
   __sync_bool_compare_and_swap(&non_addr_discriminatedauthenticated_ptr, &i, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_val_compare_and_swap(&non_addr_discriminatedauthenticated_ptr, &i, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
 
   __sync_lock_test_and_set(&non_addr_discriminatedauthenticated_ptr, &i);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
   __sync_lock_release(&non_addr_discriminatedauthenticated_ptr);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('int *__ptrauth(2,0,200) *' invalid)}}
+
+  __sync_fetch_and_add(&qualified_int, 1);
+  // expected-error at -1 {{address argument to __sync operation must not be a pointer to a '__ptrauth'-qualified type ('__ptrauth(2,0,200) long *' invalid)}}
+}
+
+typedef int *__ptrauth(2, 0, 200) UniformPtr;
+UniformPtr uniform;
+_Atomic UniformPtr atomic_uniform;
+_Atomic(int *) atomic_plain;
+
+void by_address(int *p, int **raw, UniformPtr *same) {
+  __c11_atomic_compare_exchange_strong(&atomic_uniform, same, p, memory_order_seq_cst, memory_order_seq_cst);
+  __atomic_compare_exchange_n(&uniform, same, p, 0, memory_order_seq_cst, memory_order_seq_cst);
+  __atomic_compare_exchange(&uniform, same, same, 0, memory_order_seq_cst, memory_order_seq_cst);
+  __atomic_load(&uniform, same, memory_order_seq_cst);
+  __atomic_store(&uniform, same, memory_order_seq_cst);
+  __atomic_exchange(&uniform, same, same, memory_order_seq_cst);
+
+  __c11_atomic_compare_exchange_strong(&atomic_uniform, raw, p, memory_order_seq_cst, memory_order_seq_cst);
+  // expected-error at -1 {{passing 'int **' to parameter of type 'int *__ptrauth(2,0,200) *' changes pointer authentication of pointee type}}
+  __atomic_compare_exchange_n(&uniform, raw, p, 0, memory_order_seq_cst, memory_order_seq_cst);
+  // expected-error at -1 {{passing 'int **' to parameter of type 'int *__ptrauth(2,0,200) *' changes pointer authentication of pointee type}}
+  __atomic_compare_exchange(&uniform, raw, same, 0, memory_order_seq_cst, memory_order_seq_cst);
+  // expected-error at -1 {{passing 'int **' to parameter of type 'int *__ptrauth(2,0,200) *' changes pointer authentication of pointee type}}
+  __atomic_load(&uniform, raw, memory_order_seq_cst);
+  // expected-error at -1 {{passing 'int **' to parameter of type 'int *__ptrauth(2,0,200) *' changes pointer authentication of pointee type}}
+  __atomic_exchange(&uniform, raw, same, memory_order_seq_cst);
+  // expected-error at -1 {{passing 'int **' to parameter of type 'int *__ptrauth(2,0,200) *' changes pointer authentication of pointee type}}
+  __c11_atomic_compare_exchange_strong(&atomic_plain, same, p, memory_order_seq_cst, memory_order_seq_cst);
+  // expected-error at -1 {{passing 'UniformPtr *' (aka 'int *__ptrauth(2,0,200) *') to parameter of type 'int **' changes pointer authentication of pointee type}}
 }



More information about the cfe-commits mailing list