[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:07 PST 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang
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