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

via cfe-commits cfe-commits at lists.llvm.org
Sat Nov 7 21:03:06 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-clang-codegen

Author: JF Bastien (jfbastien)

<details>
<summary>Changes</summary>

Atomic builtins on `__ptrauth`-qualified objects either rejected address
diversity or operated on raw signed bits. Stores could write unsigned
values that later failed authentication, and implicit `_Atomic` operations
could assert in CodeGen.

Use the object's schema for initialization, load, store, exchange and
compare-exchange. Preserve source authentication when copying between
qualified objects.

Compare-exchange never signs the caller's expected value: a signature of
a caller-chosen value is a signing oracle wherever the compiler keeps it
in memory, and at -O2 a hoisted signature lives in a callee-saved
register across calls. Instead, load the object's signed representation,
authenticate it, compare plain values, and use that snapshot as the
hardware comparand. A strong exchange retries after interference, and
it now succeeds against a signed-null representation. Volatile
compare-exchange is rejected because of the extra read, and misaligned
atomic builtins because the library call passes signed values through
memory.

Route qualified integer constants through schema-aware emission. Sema
rejects nonzero constant initializers of qualified integers in C static
storage and in C++ `constexpr` and `constinit` objects; other C++ objects
initialize dynamically.

Reject atomic arithmetic, `__sync_*`, GNU generic by-address forms,
`__atomic_test_and_set`, `__atomic_clear`, `_Atomic` aggregates with
address-diverse fields, and implicit increment, decrement and compound
assignment. Also reject authenticated OpenMP atomic targets and
compare-capture results. These can be supported in follow-ups if needed.
Ordinary OpenMP read and capture can still store to qualified results.

Support is limited to directly qualified pointers and pointer-sized
integers. No LLVM IR or backend changes are needed.

Validated with real arm64e programs at -O0 and -O2, including a probe
that recovers no signature of the expected value from the stack or from
callee-saved registers.

Assisted-by: AI


---

Patch is 90.97 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/240090.diff


24 Files Affected:

- (modified) clang/docs/PointerAuthentication.md (+21) 
- (modified) clang/docs/ReleaseNotes.md (+19) 
- (modified) clang/include/clang/Basic/DiagnosticFrontendKinds.td (+5) 
- (modified) clang/include/clang/Basic/DiagnosticSemaKinds.td (+16-5) 
- (modified) clang/include/clang/Sema/Sema.h (+7) 
- (modified) clang/lib/AST/ASTContext.cpp (+1-1) 
- (modified) clang/lib/CodeGen/CGAtomic.cpp (+139-25) 
- (modified) clang/lib/CodeGen/CGExprConstant.cpp (+16-4) 
- (modified) clang/lib/CodeGen/CGExprScalar.cpp (+4-1) 
- (modified) clang/lib/CodeGen/CGPointerAuth.cpp (+14-2) 
- (modified) clang/lib/Sema/SemaChecking.cpp (+36-11) 
- (modified) clang/lib/Sema/SemaDecl.cpp (+86) 
- (modified) clang/lib/Sema/SemaExpr.cpp (+24-1) 
- (modified) clang/lib/Sema/SemaOpenMP.cpp (+20) 
- (modified) clang/lib/Sema/SemaType.cpp (+5) 
- (added) clang/test/CodeGen/ptrauth-atomic-builtins.c (+125) 
- (added) clang/test/CodeGen/ptrauth-atomic-misaligned.c (+22) 
- (added) clang/test/CodeGen/ptrauth-qualifier-atomic.c (+203) 
- (added) clang/test/CodeGenCXX/ptrauth-integer-dynamic-init.cpp (+40) 
- (added) clang/test/OpenMP/atomic_ptrauth.c (+53) 
- (added) clang/test/OpenMP/atomic_ptrauth_result_codegen.c (+24) 
- (modified) clang/test/Sema/ptrauth-atomic-ops.c (+136-45) 
- (added) clang/test/Sema/ptrauth-integer-constant-init.c (+34) 
- (added) clang/test/SemaCXX/ptrauth-integer-constant-init.cpp (+28) 


``````````diff
diff --git a/clang/docs/PointerAuthentication.md b/clang/docs/PointerAuthentication.md
index 8a77d0178430a3..72f5bc46403822 100644
--- a/clang/docs/PointerAuthentication.md
+++ b/clang/docs/PointerAuthentication.md
@@ -431,6 +431,27 @@ 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 use the
+object's authentication schema, including address diversity. This covers implicit
+`_Atomic` initialization, loads, and stores, and the C11, OpenCL, GNU by-value
+(`_n`, including scoped), and HIP atomic builtins on directly qualified pointers
+and pointer-sized integers. Compare-exchange reads the object before the
+exchange, so it is rejected on `volatile` objects. libc++ `atomic` and
+`atomic_ref` specializations remain unsupported.
+
+Atomic arithmetic, `__sync_*`, GNU generic by-address forms,
+`__atomic_test_and_set`, `__atomic_clear`, misaligned builtins, and implicit
+increment, decrement, and compound assignment are rejected, as are `_Atomic`
+aggregates with address-diverse fields. OpenMP atomic targets and
+compare-capture result destinations cannot be qualified either. Ordinary OpenMP
+read and capture can store to qualified results.
+
+Numeric integer constants requiring signing cannot currently initialize static
+storage in C. C++ can initialize such objects dynamically, except where
+`constexpr` or `constinit` requires constant initialization. This applies to
+atomic and non-atomic integers. Null-preserving zero and supported symbol-address
+relocations remain constant-initializable.
+
 ##### 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 110dc79b7a7ae8..e26241cbd0d662 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -48,8 +48,16 @@ The previous behavior can be restored with `-Wno-error=unicode-whitespace`.
 Clang will stop accepting non-ascii whitespaces as token separators
 in a future version of Clang.
 
+- Unsupported atomic operations on `__ptrauth`-qualified storage now diagnose.
+  C static numeric integer initializers requiring signing also diagnose instead
+  of storing unsigned bits. See [pointer authentication](PointerAuthentication.html).
+
 ### C++ Specific Potentially Breaking Changes
 
+- A `__ptrauth`-qualified integer with a nonzero numeric initializer is now
+  initialized dynamically, since no relocation can sign it. `constexpr` and
+  `constinit` declarations of such objects with static storage are rejected.
+
 - The `[[carries_dependency]]` attribute is no longer recognized, in any language
   mode, as it was removed from the standard by
   [P3475R2](https://wg21.link/P3475R2).
@@ -1336,6 +1344,17 @@ 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 initialization, load, store, exchange, and compare-exchange now use
+  the `__ptrauth` object's authentication schema. For example, these builtins
+  sign on store and authenticate on load, using `&p` as the discriminator:
+
+  ```c
+  typedef int *__ptrauth(2, 1, 0) AuthPtr;
+  _Atomic AuthPtr p;
+  void store(int *value) { __c11_atomic_store(&p, value, __ATOMIC_RELAXED); }
+  int *load(void) { return __c11_atomic_load(&p, __ATOMIC_RELAXED); }
+  ```
+
 - 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/DiagnosticFrontendKinds.td b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
index b51aa3ff0a0cb4..7c6f65ac2ac19b 100644
--- a/clang/include/clang/Basic/DiagnosticFrontendKinds.td
+++ b/clang/include/clang/Basic/DiagnosticFrontendKinds.td
@@ -378,6 +378,11 @@ def warn_atomic_op_misaligned : Warning<
   "; the expected alignment (%0 bytes) exceeds the actual alignment (%1 bytes)">,
   InGroup<AtomicAlignment>;
 
+def err_atomic_op_misaligned_ptrauth : Error<
+  "misaligned atomic operation on a '__ptrauth'-qualified type is not "
+  "supported; the expected alignment (%0 bytes) exceeds the actual alignment "
+  "(%1 bytes)">;
+
 def warn_atomic_op_oversized : Warning<
   "large atomic operation may incur "
   "significant performance penalty"
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 80de4627959c4b..e51a4c55b27d98 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -7557,8 +7557,9 @@ def err_func_def_incomplete_result : Error<
 def err_atomic_specifier_bad_type
     : Error<"_Atomic cannot be applied to "
             "%select{incomplete |array |function |reference |atomic |qualified "
-            "|sizeless ||integer ||overflow behavior }0type "
-            "%1 %select{|||||||which is not trivially copyable||in C23|}0">;
+            "|sizeless ||integer ||overflow behavior |}0type "
+            "%1 %select{|||||||which is not trivially copyable||in C23||which "
+            "contains an address-discriminated field}0">;
 def warn_atomic_member_access : Warning<
   "accessing a member of an atomic structure or union is undefined behavior">,
   InGroup<DiagGroup<"atomic-access">>, DefaultError;
@@ -9697,9 +9698,19 @@ def err_atomic_op_needs_non_const_atomic : Error<
 def err_atomic_op_needs_non_const_pointer : Error<
   "address argument to atomic operation must be a pointer to non-const "
   "type (%0 invalid)">;
-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|generic atomic|"
+  "atomic test-and-set or clear|volatile compare-exchange}0 "
+  "operation must not be a pointer to a '__ptrauth'-qualified type (%1 "
+  "invalid)">;
+def err_ptrauth_integer_constant_init : Error<
+  "'__ptrauth'-qualified integer cannot be %select{statically|constant}0 "
+  "initialized to a nonzero integer constant">;
+def err_omp_atomic_ptrauth : Error<
+  "OpenMP atomic operation on '__ptrauth'-qualified type %0 is not supported">;
+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/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 3abbaf6b1941ec..49b44316823de1 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -4079,6 +4079,13 @@ class Sema final : public SemaBase {
   bool checkPointerAuthDiscriminatorArg(Expr *Arg, PointerAuthDiscArgKind Kind,
                                         unsigned &IntVal);
 
+  /// Diagnose a constant initializer that stores a nonzero integer into a
+  /// `__ptrauth`-qualified integer, which no relocation can sign. \p Evaluate
+  /// runs only when \p T contains one.
+  void checkPointerAuthIntegerConstantInit(
+      QualType T, llvm::function_ref<const APValue *()> Evaluate,
+      SourceLocation Loc, bool Constexpr);
+
   /// Diagnose function specifiers on a declaration of an identifier that
   /// does not identify a function.
   void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 338a0eaf8d9707..f88dab2a410c09 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -1741,7 +1741,7 @@ ASTContext::findPointerAuthContent(QualType T) const {
 
   if (T.hasAddressDiscriminatedPointerAuth())
     return PointerAuthContent::AddressDiscriminatedData;
-  const RecordDecl *RD = T->getAsRecordDecl();
+  const RecordDecl *RD = getBaseElementType(T)->getAsRecordDecl();
   if (!RD)
     return PointerAuthContent::None;
 
diff --git a/clang/lib/CodeGen/CGAtomic.cpp b/clang/lib/CodeGen/CGAtomic.cpp
index cd7b278eab15d9..04b2e808a24ccf 100644
--- a/clang/lib/CodeGen/CGAtomic.cpp
+++ b/clang/lib/CodeGen/CGAtomic.cpp
@@ -375,6 +375,78 @@ bool AtomicInfo::emitMemSetZeroIfNecessary() const {
   return true;
 }
 
+/// Compare-exchange on `__ptrauth`-qualified storage. The caller's expected
+/// value is never signed: that would mint a signature for a caller-chosen
+/// value, a signing oracle wherever the compiler spills it. The comparand is
+/// the object's own signed representation, authenticated and compared as a
+/// plain value. Leaves the builder in \p StoreExpectedBB and returns the plain
+/// value to write back there, with the block that reaches \p ContinueBB on
+/// success.
+static std::pair<llvm::Value *, llvm::BasicBlock *>
+emitAuthenticatedAtomicCmpXchg(
+    CodeGenFunction &CGF, AtomicExpr *E, bool IsWeak, Address Ptr,
+    llvm::Value *Expected, llvm::Value *Desired, PointerAuthQualifier PtrAuth,
+    llvm::BasicBlock *StoreExpectedBB, llvm::BasicBlock *ContinueBB,
+    llvm::AtomicOrdering SuccessOrder, llvm::AtomicOrdering FailureOrder,
+    llvm::SyncScope::ID Scope) {
+  // The snapshot is a second access, which volatile rules out.
+  assert(!E->isVolatile() && "volatile authenticated compare-exchange");
+  QualType ValueTy = E->getValueType().getUnqualifiedType();
+  auto Unqualify = [&](llvm::Value *Signed) {
+    return CGF.EmitPointerAuthUnqualify(PtrAuth, Signed, ValueTy, Ptr,
+                                        /*IsKnownNonNull=*/false);
+  };
+  llvm::BasicBlock *AuthBB = CGF.createBasicBlock("cmpxchg.auth", CGF.CurFn);
+  llvm::BasicBlock *TryBB = CGF.createBasicBlock("cmpxchg.try", CGF.CurFn);
+  llvm::BasicBlock *FailBB = CGF.createBasicBlock("cmpxchg.fail", CGF.CurFn);
+
+  // A failed compare-exchange is a load with the failure ordering.
+  llvm::LoadInst *Snapshot = CGF.Builder.CreateLoad(Ptr, "cmpxchg.snapshot");
+  Snapshot->setAtomic(FailureOrder, Scope);
+  CGF.getTargetHooks().setTargetAtomicMetadata(CGF, *Snapshot, E);
+  llvm::BasicBlock *EntryBB = CGF.Builder.GetInsertBlock();
+  CGF.Builder.CreateBr(AuthBB);
+
+  CGF.Builder.SetInsertPoint(AuthBB);
+  llvm::PHINode *Signed =
+      CGF.Builder.CreatePHI(Snapshot->getType(), 2, "cmpxchg.signed");
+  Signed->addIncoming(Snapshot, EntryBB);
+  llvm::Value *Plain = Unqualify(Signed);
+  llvm::Value *Equal =
+      CGF.Builder.CreateICmpEQ(Plain, Expected, "cmpxchg.equal");
+  llvm::BasicBlock *CompareBB = CGF.Builder.GetInsertBlock();
+  CGF.Builder.CreateCondBr(Equal, TryBB, StoreExpectedBB);
+
+  CGF.Builder.SetInsertPoint(TryBB);
+  llvm::AtomicCmpXchgInst *Pair = CGF.Builder.CreateAtomicCmpXchg(
+      Ptr, Signed, Desired, SuccessOrder, FailureOrder, Scope);
+  Pair->setWeak(IsWeak);
+  CGF.getTargetHooks().setTargetAtomicMetadata(CGF, *Pair, E);
+  llvm::Value *Observed = CGF.Builder.CreateExtractValue(Pair, 0);
+  llvm::Value *Success = CGF.Builder.CreateExtractValue(Pair, 1);
+  CGF.Builder.CreateCondBr(Success, ContinueBB, FailBB);
+
+  CGF.Builder.SetInsertPoint(FailBB);
+  llvm::Value *WeakOld = nullptr;
+  llvm::BasicBlock *WeakFailBB = nullptr;
+  if (IsWeak) {
+    WeakOld = Unqualify(Observed);
+    WeakFailBB = CGF.Builder.GetInsertBlock();
+    CGF.Builder.CreateBr(StoreExpectedBB);
+  } else {
+    Signed->addIncoming(Observed, FailBB);
+    CGF.Builder.CreateBr(AuthBB);
+  }
+
+  CGF.Builder.SetInsertPoint(StoreExpectedBB);
+  llvm::PHINode *Old =
+      CGF.Builder.CreatePHI(Plain->getType(), 2, "cmpxchg.old");
+  Old->addIncoming(Plain, CompareBB);
+  if (IsWeak)
+    Old->addIncoming(WeakOld, WeakFailBB);
+  return {Old, TryBB};
+}
+
 static void emitAtomicCmpXchg(CodeGenFunction &CGF, AtomicExpr *E, bool IsWeak,
                               Address Dest, Address Ptr, Address Val1,
                               Address Val2, Address ExpectedResult,
@@ -385,17 +457,6 @@ static void emitAtomicCmpXchg(CodeGenFunction &CGF, AtomicExpr *E, bool IsWeak,
   llvm::Value *Expected = CGF.Builder.CreateLoad(Val1);
   llvm::Value *Desired = CGF.Builder.CreateLoad(Val2);
 
-  llvm::AtomicCmpXchgInst *Pair = CGF.Builder.CreateAtomicCmpXchg(
-      Ptr, Expected, Desired, SuccessOrder, FailureOrder, Scope);
-  Pair->setVolatile(E->isVolatile());
-  Pair->setWeak(IsWeak);
-  CGF.getTargetHooks().setTargetAtomicMetadata(CGF, *Pair, E);
-
-  // Cmp holds the result of the compare-exchange operation: true on success,
-  // false on failure.
-  llvm::Value *Old = CGF.Builder.CreateExtractValue(Pair, 0);
-  llvm::Value *Cmp = CGF.Builder.CreateExtractValue(Pair, 1);
-
   // This basic block is used to hold the store instruction if the operation
   // failed.
   llvm::BasicBlock *StoreExpectedBB =
@@ -406,11 +467,32 @@ static void emitAtomicCmpXchg(CodeGenFunction &CGF, AtomicExpr *E, bool IsWeak,
   llvm::BasicBlock *ContinueBB =
       CGF.createBasicBlock("cmpxchg.continue", CGF.CurFn);
 
-  // Update Expected if Expected isn't equal to Old, otherwise branch to the
-  // exit point.
-  CGF.Builder.CreateCondBr(Cmp, ContinueBB, StoreExpectedBB);
+  // Old is the value written back to Expected on failure. Cmp holds the result
+  // of the compare-exchange operation: true on success, false on failure.
+  llvm::Value *Old = nullptr, *Cmp = nullptr;
+  llvm::BasicBlock *SuccessBB = nullptr;
+  if (PointerAuthQualifier PtrAuth =
+          E->getPtr()->getType()->getPointeeType().getPointerAuth()) {
+    auto [AuthOld, TryBB] = emitAuthenticatedAtomicCmpXchg(
+        CGF, E, IsWeak, Ptr, Expected, Desired, PtrAuth, StoreExpectedBB,
+        ContinueBB, SuccessOrder, FailureOrder, Scope);
+    Old = AuthOld;
+    SuccessBB = TryBB;
+  } else {
+    llvm::AtomicCmpXchgInst *Pair = CGF.Builder.CreateAtomicCmpXchg(
+        Ptr, Expected, Desired, SuccessOrder, FailureOrder, Scope);
+    Pair->setVolatile(E->isVolatile());
+    Pair->setWeak(IsWeak);
+    CGF.getTargetHooks().setTargetAtomicMetadata(CGF, *Pair, E);
+    Old = CGF.Builder.CreateExtractValue(Pair, 0);
+    Cmp = CGF.Builder.CreateExtractValue(Pair, 1);
+
+    // Update Expected if Expected isn't equal to Old, otherwise branch to the
+    // exit point.
+    CGF.Builder.CreateCondBr(Cmp, ContinueBB, StoreExpectedBB);
+    CGF.Builder.SetInsertPoint(StoreExpectedBB);
+  }
 
-  CGF.Builder.SetInsertPoint(StoreExpectedBB);
   // Update the memory at Expected with Old's value.
   llvm::Type *ExpectedType = ExpectedResult.getElementType();
   const llvm::DataLayout &DL = CGF.CGM.getDataLayout();
@@ -438,9 +520,17 @@ static void emitAtomicCmpXchg(CodeGenFunction &CGF, AtomicExpr *E, bool IsWeak,
   }
 
   // Finally, branch to the exit point.
+  llvm::BasicBlock *FailureBB = CGF.Builder.GetInsertBlock();
   CGF.Builder.CreateBr(ContinueBB);
 
   CGF.Builder.SetInsertPoint(ContinueBB);
+  if (SuccessBB) {
+    llvm::PHINode *Phi =
+        CGF.Builder.CreatePHI(CGF.Builder.getInt1Ty(), 2, "cmpxchg.success");
+    Phi->addIncoming(CGF.Builder.getTrue(), SuccessBB);
+    Phi->addIncoming(CGF.Builder.getFalse(), FailureBB);
+    Cmp = Phi;
+  }
   // Update the memory at Dest with Cmp's value.
   CGF.EmitStoreOfScalar(Cmp, CGF.MakeAddrLValue(Dest, E->getType()));
 }
@@ -566,6 +656,9 @@ static void EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, Address Dest,
   llvm::AtomicRMWInst::BinOp Op = llvm::AtomicRMWInst::Add;
   bool PostOpMinMax = false;
   unsigned PostOp = 0;
+  PointerAuthQualifier PtrAuth =
+      E->getPtr()->getType()->getPointeeType().getPointerAuth();
+  QualType ValueTy = E->getValueType().getUnqualifiedType();
 
   switch (E->getOp()) {
   case AtomicExpr::AO__c11_atomic_init:
@@ -633,8 +726,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);
-    CGF.addInstToCurrentSourceAtom(I, Load);
+    llvm::Value *LoadVal = Load;
+    if (PtrAuth)
+      LoadVal = CGF.EmitPointerAuthUnqualify(PtrAuth, LoadVal, ValueTy, Ptr,
+                                             /*IsKnownNonNull=*/false);
+    auto *I = CGF.Builder.CreateStore(LoadVal, Dest);
+    CGF.addInstToCurrentSourceAtom(I, LoadVal);
     return;
   }
 
@@ -838,6 +935,11 @@ 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 (PtrAuth) {
+    assert(Op == llvm::AtomicRMWInst::Xchg);
+    Result = CGF.EmitPointerAuthUnqualify(PtrAuth, Result, ValueTy, Ptr,
+                                          /*IsKnownNonNull=*/false);
+  }
   if (PostOpMinMax)
     Result = EmitPostAtomicMinMax(CGF.Builder, E->getOp(),
                                   E->getValueType()->isSignedIntegerType(),
@@ -854,11 +956,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;
 }
 
@@ -948,6 +1054,7 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {
   QualType MemTy = AtomicTy;
   if (const AtomicType *AT = AtomicTy->getAs<AtomicType>())
     MemTy = AT->getValueType();
+  PointerAuthQualifier PtrAuth = AtomicTy.getPointerAuth();
   llvm::Value *IsWeak = nullptr, *OrderFail = nullptr;
 
   Address Val1 = Address::invalid();
@@ -972,7 +1079,10 @@ RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {
   bool Misaligned = !Ptr.getAlignment().isMultipleOf(TInfo.Width);
   bool Oversized = getContext().toBits(TInfo.Width) > MaxInlineWidthInBits;
   if (Misaligned) {
-    Diags.Report(E->getBeginLoc(), diag::warn_atomic_op_misaligned)
+    // The library call takes its operands through memory.
+    Diags.Report(E->getBeginLoc(), PtrAuth
+                                       ? diag::err_atomic_op_misaligned_ptrauth
+                                       : diag::warn_atomic_op_misaligned)
         << (int)TInfo.Width.getQuantity()
         << (int)Ptr.getAlignment().getQuantity();
   }
@@ -1030,7 +1140,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(), PtrAuth, Ptr);
     OrderFail = EmitScalarExpr(E->getOrderFail());
     if (E->getOp() == AtomicExpr::AO__atomic_compare_exchange_n ||
         E->getOp() == AtomicExpr::AO__atomic_compare_exchange ||
@@ -1133,7 +1243,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(), PtrAuth, Ptr);
     break;
   }
 
@@ -2222,7 +2332,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.getAd...
[truncated]

``````````

</details>


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


More information about the cfe-commits mailing list