1//===--- CGPointerAuth.cpp - IR generation for pointer authentication -----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains common routines relating to the emission of
10// pointer authentication operations.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CGCXXABI.h"
15#include "CodeGenFunction.h"
16#include "CodeGenModule.h"
17#include "clang/AST/Attr.h"
18#include "clang/CodeGen/CodeGenABITypes.h"
19#include "clang/CodeGen/ConstantInitBuilder.h"
20#include "llvm/Analysis/ValueTracking.h"
21#include "llvm/Support/SipHash.h"
22
23using namespace clang;
24using namespace CodeGen;
25
26/// Given a pointer-authentication schema, return a concrete "other"
27/// discriminator for it.
28llvm::ConstantInt *CodeGenModule::getPointerAuthOtherDiscriminator(
29 const PointerAuthSchema &Schema, GlobalDecl Decl, QualType Type) {
30 switch (Schema.getOtherDiscrimination()) {
31 case PointerAuthSchema::Discrimination::None:
32 return nullptr;
33
34 case PointerAuthSchema::Discrimination::Type:
35 assert(!Type.isNull() && "type not provided for type-discriminated schema");
36 return llvm::ConstantInt::get(
37 Ty: IntPtrTy, V: getContext().getPointerAuthTypeDiscriminator(T: Type));
38
39 case PointerAuthSchema::Discrimination::Decl:
40 assert(Decl.getDecl() &&
41 "declaration not provided for decl-discriminated schema");
42 return llvm::ConstantInt::get(Ty: IntPtrTy,
43 V: getPointerAuthDeclDiscriminator(GD: Decl));
44
45 case PointerAuthSchema::Discrimination::Constant:
46 return llvm::ConstantInt::get(Ty: IntPtrTy, V: Schema.getConstantDiscrimination());
47 }
48 llvm_unreachable("bad discrimination kind");
49}
50
51uint16_t CodeGen::getPointerAuthTypeDiscriminator(CodeGenModule &CGM,
52 QualType FunctionType) {
53 return CGM.getContext().getPointerAuthTypeDiscriminator(T: FunctionType);
54}
55
56uint16_t CodeGen::getPointerAuthDeclDiscriminator(CodeGenModule &CGM,
57 GlobalDecl Declaration) {
58 return CGM.getPointerAuthDeclDiscriminator(GD: Declaration);
59}
60
61/// Return the "other" decl-specific discriminator for the given decl.
62uint16_t
63CodeGenModule::getPointerAuthDeclDiscriminator(GlobalDecl Declaration) {
64 uint16_t &EntityHash = PtrAuthDiscriminatorHashes[Declaration];
65
66 if (EntityHash == 0) {
67 const auto *ND = cast<NamedDecl>(Val: Declaration.getDecl());
68 if (ND->hasAttr<AsmLabelAttr>() &&
69 ND->getAttr<AsmLabelAttr>()->getLabel().starts_with(
70 Prefix: LLDBManglingABI::FunctionLabelPrefix)) {
71 // If the declaration comes from LLDB, the asm label has a prefix that
72 // would producing a different discriminator. Compute the real C++ mangled
73 // name instead so the discriminator matches what the original translation
74 // unit used.
75 SmallString<256> Buffer;
76 llvm::raw_svector_ostream Out(Buffer);
77 getCXXABI().getMangleContext().mangleCXXName(GD: Declaration, Out);
78 EntityHash = llvm::getPointerAuthStableSipHash(S: Out.str());
79 } else {
80 StringRef Name = getMangledName(GD: Declaration);
81 EntityHash = llvm::getPointerAuthStableSipHash(S: Name);
82 }
83 }
84
85 return EntityHash;
86}
87
88/// Return the abstract pointer authentication schema for a pointer to the given
89/// function type.
90CGPointerAuthInfo CodeGenModule::getFunctionPointerAuthInfo(QualType T) {
91 const auto &Schema = getCodeGenOpts().PointerAuth.FunctionPointers;
92 if (!Schema)
93 return CGPointerAuthInfo();
94
95 assert(!Schema.isAddressDiscriminated() &&
96 "function pointers cannot use address-specific discrimination");
97
98 llvm::Constant *Discriminator = nullptr;
99 if (T->isFunctionPointerType() || T->isFunctionReferenceType())
100 T = T->getPointeeType();
101 if (T->isFunctionType())
102 Discriminator = getPointerAuthOtherDiscriminator(Schema, Decl: GlobalDecl(), Type: T);
103
104 return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
105 /*IsaPointer=*/false, /*AuthenticatesNull=*/false,
106 Discriminator);
107}
108
109llvm::Value *
110CodeGenFunction::EmitPointerAuthBlendDiscriminator(llvm::Value *StorageAddress,
111 llvm::Value *Discriminator) {
112 StorageAddress = Builder.CreatePtrToInt(V: StorageAddress, DestTy: IntPtrTy);
113 auto Intrinsic = CGM.getIntrinsic(IID: llvm::Intrinsic::ptrauth_blend);
114 return Builder.CreateCall(Callee: Intrinsic, Args: {StorageAddress, Discriminator});
115}
116
117/// Emit the concrete pointer authentication informaton for the
118/// given authentication schema.
119CGPointerAuthInfo CodeGenFunction::EmitPointerAuthInfo(
120 const PointerAuthSchema &Schema, llvm::Value *StorageAddress,
121 GlobalDecl SchemaDecl, QualType SchemaType) {
122 if (!Schema)
123 return CGPointerAuthInfo();
124
125 llvm::Value *Discriminator =
126 CGM.getPointerAuthOtherDiscriminator(Schema, Decl: SchemaDecl, Type: SchemaType);
127
128 if (Schema.isAddressDiscriminated()) {
129 assert(StorageAddress &&
130 "address not provided for address-discriminated schema");
131
132 if (Discriminator)
133 Discriminator =
134 EmitPointerAuthBlendDiscriminator(StorageAddress, Discriminator);
135 else
136 Discriminator = Builder.CreatePtrToInt(V: StorageAddress, DestTy: IntPtrTy);
137 }
138
139 return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
140 Schema.isIsaPointer(),
141 Schema.authenticatesNullValues(), Discriminator);
142}
143
144CGPointerAuthInfo
145CodeGenFunction::EmitPointerAuthInfo(PointerAuthQualifier Qual,
146 Address StorageAddress) {
147 assert(Qual && "don't call this if you don't know that the Qual is present");
148 if (Qual.hasKeyNone())
149 return CGPointerAuthInfo();
150
151 llvm::Value *Discriminator = nullptr;
152 if (unsigned Extra = Qual.getExtraDiscriminator())
153 Discriminator = llvm::ConstantInt::get(Ty: IntPtrTy, V: Extra);
154
155 if (Qual.isAddressDiscriminated()) {
156 assert(StorageAddress.isValid() &&
157 "address discrimination without address");
158 llvm::Value *StoragePtr = StorageAddress.emitRawPointer(CGF&: *this);
159 if (Discriminator)
160 Discriminator =
161 EmitPointerAuthBlendDiscriminator(StorageAddress: StoragePtr, Discriminator);
162 else
163 Discriminator = Builder.CreatePtrToInt(V: StoragePtr, DestTy: IntPtrTy);
164 }
165
166 return CGPointerAuthInfo(Qual.getKey(), Qual.getAuthenticationMode(),
167 Qual.isIsaPointer(), Qual.authenticatesNullValues(),
168 Discriminator);
169}
170
171/// Return the natural pointer authentication for values of the given
172/// pointee type.
173static CGPointerAuthInfo
174getPointerAuthInfoForPointeeType(CodeGenModule &CGM, QualType PointeeType) {
175 if (PointeeType.isNull())
176 return CGPointerAuthInfo();
177
178 // Function pointers use the function-pointer schema by default.
179 if (PointeeType->isFunctionType())
180 return CGM.getFunctionPointerAuthInfo(T: PointeeType);
181
182 // Normal data pointers never use direct pointer authentication by default.
183 return CGPointerAuthInfo();
184}
185
186CGPointerAuthInfo CodeGenModule::getPointerAuthInfoForPointeeType(QualType T) {
187 return ::getPointerAuthInfoForPointeeType(CGM&: *this, PointeeType: T);
188}
189
190/// Return the natural pointer authentication for values of the given
191/// pointer type.
192static CGPointerAuthInfo getPointerAuthInfoForType(CodeGenModule &CGM,
193 QualType PointerType) {
194 PointerType = PointerType.getAtomicUnqualifiedType();
195 assert(PointerType->isSignableType(CGM.getContext()));
196
197 // Block pointers are currently not signed.
198 if (PointerType->isBlockPointerType())
199 return CGPointerAuthInfo();
200
201 auto PointeeType = PointerType->getPointeeType();
202
203 if (PointeeType.isNull())
204 return CGPointerAuthInfo();
205
206 return ::getPointerAuthInfoForPointeeType(CGM, PointeeType);
207}
208
209CGPointerAuthInfo CodeGenModule::getPointerAuthInfoForType(QualType T) {
210 return ::getPointerAuthInfoForType(CGM&: *this, PointerType: T);
211}
212
213static std::pair<llvm::Value *, CGPointerAuthInfo>
214emitLoadOfOrigPointerRValue(CodeGenFunction &CGF, const LValue &LV,
215 SourceLocation Loc) {
216 llvm::Value *Value = CGF.EmitLoadOfScalar(lvalue: LV, Loc);
217 CGPointerAuthInfo AuthInfo;
218 if (PointerAuthQualifier PtrAuth = LV.getQuals().getPointerAuth())
219 AuthInfo = CGF.EmitPointerAuthInfo(Qual: PtrAuth, StorageAddress: LV.getAddress());
220 else
221 AuthInfo = getPointerAuthInfoForType(CGM&: CGF.CGM, PointerType: LV.getType());
222 return {Value, AuthInfo};
223}
224
225/// Retrieve a pointer rvalue and its ptrauth info. When possible, avoid
226/// needlessly resigning the pointer.
227std::pair<llvm::Value *, CGPointerAuthInfo>
228CodeGenFunction::EmitOrigPointerRValue(const Expr *E) {
229 assert(E->getType().getAtomicUnqualifiedType()->isSignableType(getContext()));
230
231 E = E->IgnoreParens();
232 if (const auto *Load = dyn_cast<ImplicitCastExpr>(Val: E)) {
233 if (Load->getCastKind() == CK_LValueToRValue) {
234 E = Load->getSubExpr()->IgnoreParens();
235
236 // We're semantically required to not emit loads of certain DREs naively.
237 if (const auto *RefExpr = dyn_cast<DeclRefExpr>(Val: E)) {
238 if (ConstantEmission Result = tryEmitAsConstant(RefExpr)) {
239 // Fold away a use of an intermediate variable.
240 if (!Result.isReference())
241 return {Result.getValue(),
242 getPointerAuthInfoForType(CGM, PointerType: RefExpr->getType())};
243
244 // Fold away a use of an intermediate reference.
245 LValue LV = Result.getReferenceLValue(CGF&: *this, RefExpr);
246 return emitLoadOfOrigPointerRValue(CGF&: *this, LV, Loc: RefExpr->getLocation());
247 }
248 }
249
250 // Otherwise, load and use the pointer
251 LValue LV = EmitCheckedLValue(E, TCK: CodeGenFunction::TCK_Load);
252 return emitLoadOfOrigPointerRValue(CGF&: *this, LV, Loc: E->getExprLoc());
253 }
254 }
255
256 // Fallback: just use the normal rules for the type.
257 llvm::Value *Value = EmitScalarExpr(E);
258 return {Value, getPointerAuthInfoForType(CGM, PointerType: E->getType())};
259}
260
261llvm::Value *
262CodeGenFunction::EmitPointerAuthQualify(PointerAuthQualifier DestQualifier,
263 const Expr *E,
264 Address DestStorageAddress) {
265 assert(DestQualifier);
266 auto [Value, CurAuthInfo] = EmitOrigPointerRValue(E);
267
268 CGPointerAuthInfo DestAuthInfo =
269 EmitPointerAuthInfo(Qual: DestQualifier, StorageAddress: DestStorageAddress);
270 return emitPointerAuthResign(Pointer: Value, PointerType: E->getType(), CurAuthInfo, NewAuthInfo: DestAuthInfo,
271 IsKnownNonNull: isPointerKnownNonNull(E));
272}
273
274llvm::Value *CodeGenFunction::EmitPointerAuthQualify(
275 PointerAuthQualifier DestQualifier, llvm::Value *Value,
276 QualType PointerType, Address DestStorageAddress, bool IsKnownNonNull) {
277 assert(DestQualifier);
278
279 CGPointerAuthInfo CurAuthInfo = getPointerAuthInfoForType(CGM, PointerType);
280 CGPointerAuthInfo DestAuthInfo =
281 EmitPointerAuthInfo(Qual: DestQualifier, StorageAddress: DestStorageAddress);
282 return emitPointerAuthResign(Pointer: Value, PointerType, CurAuthInfo, NewAuthInfo: DestAuthInfo,
283 IsKnownNonNull);
284}
285
286llvm::Value *CodeGenFunction::EmitPointerAuthUnqualify(
287 PointerAuthQualifier CurQualifier, llvm::Value *Value, QualType PointerType,
288 Address CurStorageAddress, bool IsKnownNonNull) {
289 assert(CurQualifier);
290
291 CGPointerAuthInfo CurAuthInfo =
292 EmitPointerAuthInfo(Qual: CurQualifier, StorageAddress: CurStorageAddress);
293 CGPointerAuthInfo DestAuthInfo = getPointerAuthInfoForType(CGM, PointerType);
294 return emitPointerAuthResign(Pointer: Value, PointerType, CurAuthInfo, NewAuthInfo: DestAuthInfo,
295 IsKnownNonNull);
296}
297
298static bool isZeroConstant(const llvm::Value *Value) {
299 if (const auto *CI = dyn_cast<llvm::ConstantInt>(Val: Value))
300 return CI->isZero();
301 return false;
302}
303
304static bool equalAuthPolicies(const CGPointerAuthInfo &Left,
305 const CGPointerAuthInfo &Right) {
306 assert((Left.isSigned() || Right.isSigned()) &&
307 "shouldn't be called if neither is signed");
308 if (Left.isSigned() != Right.isSigned())
309 return false;
310 return Left.getKey() == Right.getKey() &&
311 Left.getAuthenticationMode() == Right.getAuthenticationMode() &&
312 Left.isIsaPointer() == Right.isIsaPointer() &&
313 Left.authenticatesNullValues() == Right.authenticatesNullValues() &&
314 Left.getDiscriminator() == Right.getDiscriminator();
315}
316
317// Return the discriminator or return zero if the discriminator is null.
318static llvm::Value *getDiscriminatorOrZero(const CGPointerAuthInfo &Info,
319 CGBuilderTy &Builder) {
320 llvm::Value *Discriminator = Info.getDiscriminator();
321 return Discriminator ? Discriminator : Builder.getSize(N: 0);
322}
323
324llvm::Value *
325CodeGenFunction::emitPointerAuthResignCall(llvm::Value *Value,
326 const CGPointerAuthInfo &CurAuth,
327 const CGPointerAuthInfo &NewAuth) {
328 assert(CurAuth && NewAuth);
329
330 if (CurAuth.getAuthenticationMode() !=
331 PointerAuthenticationMode::SignAndAuth ||
332 NewAuth.getAuthenticationMode() !=
333 PointerAuthenticationMode::SignAndAuth) {
334 llvm::Value *AuthedValue = EmitPointerAuthAuth(Info: CurAuth, Pointer: Value);
335 return EmitPointerAuthSign(Info: NewAuth, Pointer: AuthedValue);
336 }
337 // Convert the pointer to intptr_t before signing it.
338 auto *OrigType = Value->getType();
339 Value = Builder.CreatePtrToInt(V: Value, DestTy: IntPtrTy);
340
341 auto *CurKey = Builder.getInt32(C: CurAuth.getKey());
342 auto *NewKey = Builder.getInt32(C: NewAuth.getKey());
343
344 llvm::Value *CurDiscriminator = getDiscriminatorOrZero(Info: CurAuth, Builder);
345 llvm::Value *NewDiscriminator = getDiscriminatorOrZero(Info: NewAuth, Builder);
346
347 // call i64 @llvm.ptrauth.resign(i64 %pointer,
348 // i32 %curKey, i64 %curDiscriminator,
349 // i32 %newKey, i64 %newDiscriminator)
350 auto *Intrinsic = CGM.getIntrinsic(IID: llvm::Intrinsic::ptrauth_resign);
351 Value = EmitRuntimeCall(
352 callee: Intrinsic, args: {Value, CurKey, CurDiscriminator, NewKey, NewDiscriminator});
353
354 // Convert back to the original type.
355 Value = Builder.CreateIntToPtr(V: Value, DestTy: OrigType);
356 return Value;
357}
358
359llvm::Value *CodeGenFunction::emitPointerAuthResign(
360 llvm::Value *Value, QualType Type, const CGPointerAuthInfo &CurAuthInfo,
361 const CGPointerAuthInfo &NewAuthInfo, bool IsKnownNonNull) {
362 // Fast path: if neither schema wants a signature, we're done.
363 if (!CurAuthInfo && !NewAuthInfo)
364 return Value;
365
366 llvm::Value *Null = nullptr;
367 // If the value is obviously null, we're done.
368 if (auto *PointerValue = dyn_cast<llvm::PointerType>(Val: Value->getType())) {
369 Null = CGM.getNullPointer(T: PointerValue, QT: Type);
370 } else {
371 assert(Value->getType()->isIntegerTy());
372 Null = llvm::ConstantInt::get(Ty: IntPtrTy, V: 0);
373 }
374 if (Value == Null)
375 return Value;
376
377 // If both schemas sign the same way, we're done.
378 if (equalAuthPolicies(Left: CurAuthInfo, Right: NewAuthInfo)) {
379 const llvm::Value *CurD = CurAuthInfo.getDiscriminator();
380 const llvm::Value *NewD = NewAuthInfo.getDiscriminator();
381 if (CurD == NewD)
382 return Value;
383
384 if ((CurD == nullptr && isZeroConstant(Value: NewD)) ||
385 (NewD == nullptr && isZeroConstant(Value: CurD)))
386 return Value;
387 }
388
389 llvm::BasicBlock *InitBB = Builder.GetInsertBlock();
390 llvm::BasicBlock *ResignBB = nullptr, *ContBB = nullptr;
391
392 // Null pointers have to be mapped to null, and the ptrauth_resign
393 // intrinsic doesn't do that.
394 if (!IsKnownNonNull && !llvm::isKnownNonZero(V: Value, Q: CGM.getDataLayout())) {
395 ContBB = createBasicBlock(name: "resign.cont");
396 ResignBB = createBasicBlock(name: "resign.nonnull");
397
398 auto *IsNonNull = Builder.CreateICmpNE(LHS: Value, RHS: Null);
399 Builder.CreateCondBr(Cond: IsNonNull, True: ResignBB, False: ContBB);
400 EmitBlock(BB: ResignBB);
401 }
402
403 // Perform the auth/sign/resign operation.
404 if (!NewAuthInfo)
405 Value = EmitPointerAuthAuth(Info: CurAuthInfo, Pointer: Value);
406 else if (!CurAuthInfo)
407 Value = EmitPointerAuthSign(Info: NewAuthInfo, Pointer: Value);
408 else
409 Value = emitPointerAuthResignCall(Value, CurAuth: CurAuthInfo, NewAuth: NewAuthInfo);
410
411 // Clean up with a phi if we branched before.
412 if (ContBB) {
413 EmitBlock(BB: ContBB);
414 auto *Phi = Builder.CreatePHI(Ty: Value->getType(), NumReservedValues: 2);
415 Phi->addIncoming(V: Null, BB: InitBB);
416 Phi->addIncoming(V: Value, BB: ResignBB);
417 Value = Phi;
418 }
419
420 return Value;
421}
422
423void CodeGenFunction::EmitPointerAuthCopy(PointerAuthQualifier Qual, QualType T,
424 Address DestAddress,
425 Address SrcAddress) {
426 assert(Qual);
427 llvm::Value *Value = Builder.CreateLoad(Addr: SrcAddress);
428
429 // If we're using address-discrimination, we have to re-sign the value.
430 if (Qual.isAddressDiscriminated()) {
431 CGPointerAuthInfo SrcPtrAuth = EmitPointerAuthInfo(Qual, StorageAddress: SrcAddress);
432 CGPointerAuthInfo DestPtrAuth = EmitPointerAuthInfo(Qual, StorageAddress: DestAddress);
433 Value = emitPointerAuthResign(Value, Type: T, CurAuthInfo: SrcPtrAuth, NewAuthInfo: DestPtrAuth,
434 /*IsKnownNonNull=*/false);
435 }
436
437 Builder.CreateStore(Val: Value, Addr: DestAddress);
438}
439
440llvm::Constant *
441CodeGenModule::getConstantSignedPointer(llvm::Constant *Pointer, unsigned Key,
442 llvm::Constant *StorageAddress,
443 llvm::ConstantInt *OtherDiscriminator) {
444 llvm::Constant *AddressDiscriminator;
445 if (StorageAddress) {
446 assert(StorageAddress->getType() == DefaultPtrTy);
447 AddressDiscriminator = StorageAddress;
448 } else {
449 AddressDiscriminator = llvm::Constant::getNullValue(Ty: DefaultPtrTy);
450 }
451
452 llvm::ConstantInt *IntegerDiscriminator;
453 if (OtherDiscriminator) {
454 assert(OtherDiscriminator->getType() == Int64Ty);
455 IntegerDiscriminator = OtherDiscriminator;
456 } else {
457 IntegerDiscriminator = llvm::ConstantInt::get(Ty: Int64Ty, V: 0);
458 }
459
460 return llvm::ConstantPtrAuth::get(
461 Ptr: Pointer, Key: llvm::ConstantInt::get(Ty: Int32Ty, V: Key), Disc: IntegerDiscriminator,
462 AddrDisc: AddressDiscriminator,
463 /*DeactivationSymbol=*/llvm::Constant::getNullValue(Ty: DefaultPtrTy));
464}
465
466/// Does a given PointerAuthScheme require us to sign a value
467bool CodeGenModule::shouldSignPointer(const PointerAuthSchema &Schema) {
468 auto AuthenticationMode = Schema.getAuthenticationMode();
469 return AuthenticationMode == PointerAuthenticationMode::SignAndStrip ||
470 AuthenticationMode == PointerAuthenticationMode::SignAndAuth;
471}
472
473/// Sign a constant pointer using the given scheme, producing a constant
474/// with the same IR type.
475llvm::Constant *CodeGenModule::getConstantSignedPointer(
476 llvm::Constant *Pointer, const PointerAuthSchema &Schema,
477 llvm::Constant *StorageAddress, GlobalDecl SchemaDecl,
478 QualType SchemaType) {
479 assert(shouldSignPointer(Schema));
480 llvm::ConstantInt *OtherDiscriminator =
481 getPointerAuthOtherDiscriminator(Schema, Decl: SchemaDecl, Type: SchemaType);
482
483 return getConstantSignedPointer(Pointer, Key: Schema.getKey(), StorageAddress,
484 OtherDiscriminator);
485}
486
487llvm::Constant *
488CodeGen::getConstantSignedPointer(CodeGenModule &CGM, llvm::Constant *Pointer,
489 unsigned Key, llvm::Constant *StorageAddress,
490 llvm::ConstantInt *OtherDiscriminator) {
491 return CGM.getConstantSignedPointer(Pointer, Key, StorageAddress,
492 OtherDiscriminator);
493}
494
495/// If applicable, sign a given constant function pointer with the ABI rules for
496/// functionType.
497llvm::Constant *CodeGenModule::getFunctionPointer(llvm::Constant *Pointer,
498 QualType FunctionType) {
499 assert(FunctionType->isFunctionType() ||
500 FunctionType->isFunctionReferenceType() ||
501 FunctionType->isFunctionPointerType());
502
503 if (auto PointerAuth = getFunctionPointerAuthInfo(T: FunctionType))
504 return getConstantSignedPointer(
505 Pointer, Key: PointerAuth.getKey(), /*StorageAddress=*/nullptr,
506 OtherDiscriminator: cast_or_null<llvm::ConstantInt>(Val: PointerAuth.getDiscriminator()));
507
508 return Pointer;
509}
510
511llvm::Constant *CodeGenModule::getFunctionPointer(GlobalDecl GD,
512 llvm::Type *Ty) {
513 const auto *FD = cast<FunctionDecl>(Val: GD.getDecl());
514 QualType FuncType = FD->getType();
515
516 // Annoyingly, K&R functions have prototypes in the clang AST, but
517 // expressions referring to them are unprototyped.
518 if (!FD->hasPrototype())
519 if (const auto *Proto = FuncType->getAs<FunctionProtoType>())
520 FuncType = Context.getFunctionNoProtoType(ResultTy: Proto->getReturnType(),
521 Info: Proto->getExtInfo());
522
523 return getFunctionPointer(Pointer: getRawFunctionPointer(GD, Ty), FunctionType: FuncType);
524}
525
526CGPointerAuthInfo CodeGenModule::getMemberFunctionPointerAuthInfo(QualType FT) {
527 assert(FT->getAs<MemberPointerType>() && "MemberPointerType expected");
528 const auto &Schema = getCodeGenOpts().PointerAuth.CXXMemberFunctionPointers;
529 if (!Schema)
530 return CGPointerAuthInfo();
531
532 assert(!Schema.isAddressDiscriminated() &&
533 "function pointers cannot use address-specific discrimination");
534
535 llvm::ConstantInt *Discriminator =
536 getPointerAuthOtherDiscriminator(Schema, Decl: GlobalDecl(), Type: FT);
537 return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
538 /* IsIsaPointer */ false,
539 /* AuthenticatesNullValues */ false, Discriminator);
540}
541
542llvm::Constant *CodeGenModule::getMemberFunctionPointer(llvm::Constant *Pointer,
543 QualType FT) {
544 if (CGPointerAuthInfo PointerAuth = getMemberFunctionPointerAuthInfo(FT))
545 return getConstantSignedPointer(
546 Pointer, Key: PointerAuth.getKey(), StorageAddress: nullptr,
547 OtherDiscriminator: cast_or_null<llvm::ConstantInt>(Val: PointerAuth.getDiscriminator()));
548
549 if (const auto *MFT = dyn_cast<MemberPointerType>(Val: FT.getTypePtr())) {
550 if (MFT->hasPointeeToCFIUncheckedCalleeFunctionType())
551 Pointer = llvm::NoCFIValue::get(GV: cast<llvm::GlobalValue>(Val: Pointer));
552 }
553
554 return Pointer;
555}
556
557llvm::Constant *CodeGenModule::getMemberFunctionPointer(const FunctionDecl *FD,
558 llvm::Type *Ty) {
559 QualType FT = FD->getType();
560 FT = getContext().getMemberPointerType(T: FT, /*Qualifier=*/std::nullopt,
561 Cls: cast<CXXMethodDecl>(Val: FD)->getParent());
562 return getMemberFunctionPointer(Pointer: getRawFunctionPointer(GD: FD, Ty), FT);
563}
564
565std::optional<PointerAuthQualifier>
566CodeGenModule::computeVTPointerAuthentication(const CXXRecordDecl *ThisClass,
567 bool IsVTTEntry) {
568 auto DefaultAuthentication =
569 IsVTTEntry ? getCodeGenOpts().PointerAuth.CXXVTTVTablePointers
570 : getCodeGenOpts().PointerAuth.CXXVTablePointers;
571 if (!DefaultAuthentication)
572 return std::nullopt;
573 const CXXRecordDecl *PrimaryBase =
574 Context.baseForVTableAuthentication(ThisClass);
575 const CXXRecordDecl *TypeDiscriminatorClass =
576 IsVTTEntry ? ThisClass : PrimaryBase;
577
578 unsigned Key = DefaultAuthentication.getKey();
579 bool AddressDiscriminated = DefaultAuthentication.isAddressDiscriminated();
580 auto DefaultDiscrimination = DefaultAuthentication.getOtherDiscrimination();
581 unsigned TypeBasedDiscriminator =
582 Context.getPointerAuthVTablePointerDiscriminator(RD: TypeDiscriminatorClass,
583 IsVTTEntry);
584 unsigned Discriminator;
585 if (DefaultDiscrimination == PointerAuthSchema::Discrimination::Type) {
586 Discriminator = TypeBasedDiscriminator;
587 } else if (DefaultDiscrimination ==
588 PointerAuthSchema::Discrimination::Constant) {
589 Discriminator = DefaultAuthentication.getConstantDiscrimination();
590 } else {
591 assert(DefaultDiscrimination == PointerAuthSchema::Discrimination::None);
592 Discriminator = 0;
593 }
594 auto ExplicitAuthentication =
595 PrimaryBase->getAttr<VTablePointerAuthenticationAttr>();
596
597 // TODO: enable explicit authentication path for VTT vtable entries.
598 if (!IsVTTEntry && ExplicitAuthentication) {
599 auto ExplicitAddressDiscrimination =
600 ExplicitAuthentication->getAddressDiscrimination();
601 auto ExplicitDiscriminator =
602 ExplicitAuthentication->getExtraDiscrimination();
603
604 unsigned ExplicitKey = ExplicitAuthentication->getKey();
605 if (ExplicitKey == VTablePointerAuthenticationAttr::NoKey)
606 return std::nullopt;
607
608 if (ExplicitKey != VTablePointerAuthenticationAttr::DefaultKey) {
609 if (ExplicitKey == VTablePointerAuthenticationAttr::ProcessIndependent)
610 Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDA;
611 else {
612 assert(ExplicitKey ==
613 VTablePointerAuthenticationAttr::ProcessDependent);
614 Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDB;
615 }
616 }
617
618 if (ExplicitAddressDiscrimination !=
619 VTablePointerAuthenticationAttr::DefaultAddressDiscrimination)
620 AddressDiscriminated =
621 ExplicitAddressDiscrimination ==
622 VTablePointerAuthenticationAttr::AddressDiscrimination;
623
624 if (ExplicitDiscriminator ==
625 VTablePointerAuthenticationAttr::TypeDiscrimination)
626 Discriminator = TypeBasedDiscriminator;
627 else if (ExplicitDiscriminator ==
628 VTablePointerAuthenticationAttr::CustomDiscrimination)
629 Discriminator = ExplicitAuthentication->getCustomDiscriminationValue();
630 else if (ExplicitDiscriminator ==
631 VTablePointerAuthenticationAttr::NoExtraDiscrimination)
632 Discriminator = 0;
633 }
634 return PointerAuthQualifier::Create(Key, IsAddressDiscriminated: AddressDiscriminated, ExtraDiscriminator: Discriminator,
635 AuthenticationMode: PointerAuthenticationMode::SignAndAuth,
636 /* IsIsaPointer */ false,
637 /* AuthenticatesNullValues */ false);
638}
639
640std::optional<PointerAuthQualifier>
641CodeGenModule::getVTablePointerAuthentication(const CXXRecordDecl *Record,
642 bool IsVTTEntry) {
643 if (!Record->getDefinition() || !Record->isPolymorphic())
644 return std::nullopt;
645
646 if (IsVTTEntry)
647 return computeVTPointerAuthentication(ThisClass: Record, IsVTTEntry);
648
649 auto Existing = VTablePtrAuthInfos.find(Val: Record);
650 if (Existing != VTablePtrAuthInfos.end())
651 return Existing->getSecond();
652
653 std::optional<PointerAuthQualifier> Authentication =
654 computeVTPointerAuthentication(ThisClass: Record, IsVTTEntry);
655 VTablePtrAuthInfos.insert(KV: std::make_pair(x&: Record, y&: Authentication));
656 return Authentication;
657}
658
659std::optional<CGPointerAuthInfo> CodeGenModule::getVTablePointerAuthInfo(
660 CodeGenFunction *CGF, const CXXRecordDecl *Record,
661 llvm::Value *StorageAddress, bool IsVTTEntry) {
662 auto Authentication = getVTablePointerAuthentication(Record, IsVTTEntry);
663 if (!Authentication)
664 return std::nullopt;
665
666 llvm::Value *Discriminator = nullptr;
667 if (auto ExtraDiscriminator = Authentication->getExtraDiscriminator())
668 Discriminator = llvm::ConstantInt::get(Ty: IntPtrTy, V: ExtraDiscriminator);
669
670 if (Authentication->isAddressDiscriminated()) {
671 assert(StorageAddress &&
672 "address not provided for address-discriminated schema");
673 if (Discriminator)
674 Discriminator =
675 CGF->EmitPointerAuthBlendDiscriminator(StorageAddress, Discriminator);
676 else
677 Discriminator = CGF->Builder.CreatePtrToInt(V: StorageAddress, DestTy: IntPtrTy);
678 }
679
680 return CGPointerAuthInfo(Authentication->getKey(),
681 PointerAuthenticationMode::SignAndAuth,
682 /* IsIsaPointer */ false,
683 /* AuthenticatesNullValues */ false, Discriminator);
684}
685
686llvm::Value *CodeGenFunction::authPointerToPointerCast(llvm::Value *ResultPtr,
687 QualType SourceType,
688 QualType DestType) {
689 CGPointerAuthInfo CurAuthInfo, NewAuthInfo;
690 if (SourceType->isSignableType(Ctx: getContext()))
691 CurAuthInfo = getPointerAuthInfoForType(CGM, PointerType: SourceType);
692
693 if (DestType->isSignableType(Ctx: getContext()))
694 NewAuthInfo = getPointerAuthInfoForType(CGM, PointerType: DestType);
695
696 if (!CurAuthInfo && !NewAuthInfo)
697 return ResultPtr;
698
699 // If only one side of the cast is a function pointer, then we still need to
700 // resign to handle casts to/from opaque pointers.
701 if (!CurAuthInfo && DestType->isFunctionPointerType())
702 CurAuthInfo = CGM.getFunctionPointerAuthInfo(T: SourceType);
703
704 if (!NewAuthInfo && SourceType->isFunctionPointerType())
705 NewAuthInfo = CGM.getFunctionPointerAuthInfo(T: DestType);
706
707 return emitPointerAuthResign(Value: ResultPtr, Type: DestType, CurAuthInfo, NewAuthInfo,
708 /*IsKnownNonNull=*/false);
709}
710
711Address CodeGenFunction::authPointerToPointerCast(Address Ptr,
712 QualType SourceType,
713 QualType DestType) {
714 CGPointerAuthInfo CurAuthInfo, NewAuthInfo;
715 if (SourceType->isSignableType(Ctx: getContext()))
716 CurAuthInfo = getPointerAuthInfoForType(CGM, PointerType: SourceType);
717
718 if (DestType->isSignableType(Ctx: getContext()))
719 NewAuthInfo = getPointerAuthInfoForType(CGM, PointerType: DestType);
720
721 if (!CurAuthInfo && !NewAuthInfo)
722 return Ptr;
723
724 if (!CurAuthInfo && DestType->isFunctionPointerType()) {
725 // When casting a non-signed pointer to a function pointer, just set the
726 // auth info on Ptr to the assumed schema. The pointer will be resigned to
727 // the effective type when used.
728 Ptr.setPointerAuthInfo(CGM.getFunctionPointerAuthInfo(T: SourceType));
729 return Ptr;
730 }
731
732 if (!NewAuthInfo && SourceType->isFunctionPointerType()) {
733 NewAuthInfo = CGM.getFunctionPointerAuthInfo(T: DestType);
734 Ptr = Ptr.getResignedAddress(NewInfo: NewAuthInfo, CGF&: *this);
735 Ptr.setPointerAuthInfo(CGPointerAuthInfo());
736 return Ptr;
737 }
738
739 return Ptr;
740}
741
742Address CodeGenFunction::getAsNaturalAddressOf(Address Addr,
743 QualType PointeeTy) {
744 CGPointerAuthInfo Info =
745 PointeeTy.isNull() ? CGPointerAuthInfo()
746 : CGM.getPointerAuthInfoForPointeeType(T: PointeeTy);
747 return Addr.getResignedAddress(NewInfo: Info, CGF&: *this);
748}
749
750Address Address::getResignedAddress(const CGPointerAuthInfo &NewInfo,
751 CodeGenFunction &CGF) const {
752 assert(isValid() && "pointer isn't valid");
753 CGPointerAuthInfo CurInfo = getPointerAuthInfo();
754 llvm::Value *Val;
755
756 // Nothing to do if neither the current or the new ptrauth info needs signing.
757 if (!CurInfo.isSigned() && !NewInfo.isSigned())
758 return Address(getBasePointer(), getElementType(), getAlignment(),
759 isKnownNonNull());
760
761 assert(ElementType && "Effective type has to be set");
762 assert(!Offset && "unexpected non-null offset");
763
764 // If the current and the new ptrauth infos are the same and the offset is
765 // null, just cast the base pointer to the effective type.
766 if (CurInfo == NewInfo && !hasOffset())
767 Val = getBasePointer();
768 else
769 Val = CGF.emitPointerAuthResign(Value: getBasePointer(), Type: QualType(), CurAuthInfo: CurInfo,
770 NewAuthInfo: NewInfo, IsKnownNonNull: isKnownNonNull());
771
772 return Address(Val, getElementType(), getAlignment(), NewInfo,
773 /*Offset=*/nullptr, isKnownNonNull());
774}
775
776llvm::Value *Address::emitRawPointerSlow(CodeGenFunction &CGF) const {
777 return CGF.getAsNaturalPointerTo(Addr: *this, PointeeType: QualType());
778}
779
780llvm::Value *LValue::getPointer(CodeGenFunction &CGF) const {
781 assert(isSimple());
782 return emitResignedPointer(PointeeTy: getType(), CGF);
783}
784
785llvm::Value *LValue::emitResignedPointer(QualType PointeeTy,
786 CodeGenFunction &CGF) const {
787 assert(isSimple());
788 return CGF.getAsNaturalAddressOf(Addr: Addr, PointeeTy).getBasePointer();
789}
790
791llvm::Value *LValue::emitRawPointer(CodeGenFunction &CGF) const {
792 assert(isSimple());
793 return Addr.isValid() ? Addr.emitRawPointer(CGF) : nullptr;
794}
795