[clang] [clang][PAC] Fix crashes on _Atomic __ptrauth-qualified objects (PR #240294)
JF Bastien via cfe-commits
cfe-commits at lists.llvm.org
Mon Nov 9 00:31:23 PST 2026
https://github.com/jfbastien created https://github.com/llvm/llvm-project/pull/240294
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
>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] [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++; }
More information about the cfe-commits
mailing list