xref: /freebsd/contrib/llvm-project/clang/lib/CodeGen/CGPointerAuth.cpp (revision b1879975794772ee51f0b4865753364c7d7626c3) 
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 "CodeGenFunction.h"
15 #include "CodeGenModule.h"
16 #include "clang/CodeGen/CodeGenABITypes.h"
17 #include "clang/CodeGen/ConstantInitBuilder.h"
18 #include "llvm/Analysis/ValueTracking.h"
19 #include "llvm/Support/SipHash.h"
20 
21 using namespace clang;
22 using namespace CodeGen;
23 
24 /// Given a pointer-authentication schema, return a concrete "other"
25 /// discriminator for it.
26 llvm::ConstantInt *CodeGenModule::getPointerAuthOtherDiscriminator(
27     const PointerAuthSchema &Schema, GlobalDecl Decl, QualType Type) {
28   switch (Schema.getOtherDiscrimination()) {
29   case PointerAuthSchema::Discrimination::None:
30     return nullptr;
31 
32   case PointerAuthSchema::Discrimination::Type:
33     assert(!Type.isNull() && "type not provided for type-discriminated schema");
34     return llvm::ConstantInt::get(
35         IntPtrTy, getContext().getPointerAuthTypeDiscriminator(Type));
36 
37   case PointerAuthSchema::Discrimination::Decl:
38     assert(Decl.getDecl() &&
39            "declaration not provided for decl-discriminated schema");
40     return llvm::ConstantInt::get(IntPtrTy,
41                                   getPointerAuthDeclDiscriminator(Decl));
42 
43   case PointerAuthSchema::Discrimination::Constant:
44     return llvm::ConstantInt::get(IntPtrTy, Schema.getConstantDiscrimination());
45   }
46   llvm_unreachable("bad discrimination kind");
47 }
48 
49 uint16_t CodeGen::getPointerAuthTypeDiscriminator(CodeGenModule &CGM,
50                                                   QualType FunctionType) {
51   return CGM.getContext().getPointerAuthTypeDiscriminator(FunctionType);
52 }
53 
54 uint16_t CodeGen::getPointerAuthDeclDiscriminator(CodeGenModule &CGM,
55                                                   GlobalDecl Declaration) {
56   return CGM.getPointerAuthDeclDiscriminator(Declaration);
57 }
58 
59 /// Return the "other" decl-specific discriminator for the given decl.
60 uint16_t
61 CodeGenModule::getPointerAuthDeclDiscriminator(GlobalDecl Declaration) {
62   uint16_t &EntityHash = PtrAuthDiscriminatorHashes[Declaration];
63 
64   if (EntityHash == 0) {
65     StringRef Name = getMangledName(Declaration);
66     EntityHash = llvm::getPointerAuthStableSipHash(Name);
67   }
68 
69   return EntityHash;
70 }
71 
72 /// Return the abstract pointer authentication schema for a pointer to the given
73 /// function type.
74 CGPointerAuthInfo CodeGenModule::getFunctionPointerAuthInfo(QualType T) {
75   const auto &Schema = getCodeGenOpts().PointerAuth.FunctionPointers;
76   if (!Schema)
77     return CGPointerAuthInfo();
78 
79   assert(!Schema.isAddressDiscriminated() &&
80          "function pointers cannot use address-specific discrimination");
81 
82   llvm::Constant *Discriminator = nullptr;
83   if (T->isFunctionPointerType() || T->isFunctionReferenceType())
84     T = T->getPointeeType();
85   if (T->isFunctionType())
86     Discriminator = getPointerAuthOtherDiscriminator(Schema, GlobalDecl(), T);
87 
88   return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
89                            /*IsaPointer=*/false, /*AuthenticatesNull=*/false,
90                            Discriminator);
91 }
92 
93 llvm::Value *
94 CodeGenFunction::EmitPointerAuthBlendDiscriminator(llvm::Value *StorageAddress,
95                                                    llvm::Value *Discriminator) {
96   StorageAddress = Builder.CreatePtrToInt(StorageAddress, IntPtrTy);
97   auto Intrinsic = CGM.getIntrinsic(llvm::Intrinsic::ptrauth_blend);
98   return Builder.CreateCall(Intrinsic, {StorageAddress, Discriminator});
99 }
100 
101 /// Emit the concrete pointer authentication informaton for the
102 /// given authentication schema.
103 CGPointerAuthInfo CodeGenFunction::EmitPointerAuthInfo(
104     const PointerAuthSchema &Schema, llvm::Value *StorageAddress,
105     GlobalDecl SchemaDecl, QualType SchemaType) {
106   if (!Schema)
107     return CGPointerAuthInfo();
108 
109   llvm::Value *Discriminator =
110       CGM.getPointerAuthOtherDiscriminator(Schema, SchemaDecl, SchemaType);
111 
112   if (Schema.isAddressDiscriminated()) {
113     assert(StorageAddress &&
114            "address not provided for address-discriminated schema");
115 
116     if (Discriminator)
117       Discriminator =
118           EmitPointerAuthBlendDiscriminator(StorageAddress, Discriminator);
119     else
120       Discriminator = Builder.CreatePtrToInt(StorageAddress, IntPtrTy);
121   }
122 
123   return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
124                            Schema.isIsaPointer(),
125                            Schema.authenticatesNullValues(), Discriminator);
126 }
127 
128 /// Return the natural pointer authentication for values of the given
129 /// pointee type.
130 static CGPointerAuthInfo
131 getPointerAuthInfoForPointeeType(CodeGenModule &CGM, QualType PointeeType) {
132   if (PointeeType.isNull())
133     return CGPointerAuthInfo();
134 
135   // Function pointers use the function-pointer schema by default.
136   if (PointeeType->isFunctionType())
137     return CGM.getFunctionPointerAuthInfo(PointeeType);
138 
139   // Normal data pointers never use direct pointer authentication by default.
140   return CGPointerAuthInfo();
141 }
142 
143 CGPointerAuthInfo CodeGenModule::getPointerAuthInfoForPointeeType(QualType T) {
144   return ::getPointerAuthInfoForPointeeType(*this, T);
145 }
146 
147 /// Return the natural pointer authentication for values of the given
148 /// pointer type.
149 static CGPointerAuthInfo getPointerAuthInfoForType(CodeGenModule &CGM,
150                                                    QualType PointerType) {
151   assert(PointerType->isSignableType());
152 
153   // Block pointers are currently not signed.
154   if (PointerType->isBlockPointerType())
155     return CGPointerAuthInfo();
156 
157   auto PointeeType = PointerType->getPointeeType();
158 
159   if (PointeeType.isNull())
160     return CGPointerAuthInfo();
161 
162   return ::getPointerAuthInfoForPointeeType(CGM, PointeeType);
163 }
164 
165 CGPointerAuthInfo CodeGenModule::getPointerAuthInfoForType(QualType T) {
166   return ::getPointerAuthInfoForType(*this, T);
167 }
168 
169 static bool isZeroConstant(const llvm::Value *Value) {
170   if (const auto *CI = dyn_cast<llvm::ConstantInt>(Value))
171     return CI->isZero();
172   return false;
173 }
174 
175 static bool equalAuthPolicies(const CGPointerAuthInfo &Left,
176                               const CGPointerAuthInfo &Right) {
177   assert((Left.isSigned() || Right.isSigned()) &&
178          "shouldn't be called if neither is signed");
179   if (Left.isSigned() != Right.isSigned())
180     return false;
181   return Left.getKey() == Right.getKey() &&
182          Left.getAuthenticationMode() == Right.getAuthenticationMode();
183 }
184 
185 // Return the discriminator or return zero if the discriminator is null.
186 static llvm::Value *getDiscriminatorOrZero(const CGPointerAuthInfo &Info,
187                                            CGBuilderTy &Builder) {
188   llvm::Value *Discriminator = Info.getDiscriminator();
189   return Discriminator ? Discriminator : Builder.getSize(0);
190 }
191 
192 llvm::Value *
193 CodeGenFunction::emitPointerAuthResignCall(llvm::Value *Value,
194                                            const CGPointerAuthInfo &CurAuth,
195                                            const CGPointerAuthInfo &NewAuth) {
196   assert(CurAuth && NewAuth);
197 
198   if (CurAuth.getAuthenticationMode() !=
199           PointerAuthenticationMode::SignAndAuth ||
200       NewAuth.getAuthenticationMode() !=
201           PointerAuthenticationMode::SignAndAuth) {
202     llvm::Value *AuthedValue = EmitPointerAuthAuth(CurAuth, Value);
203     return EmitPointerAuthSign(NewAuth, AuthedValue);
204   }
205   // Convert the pointer to intptr_t before signing it.
206   auto *OrigType = Value->getType();
207   Value = Builder.CreatePtrToInt(Value, IntPtrTy);
208 
209   auto *CurKey = Builder.getInt32(CurAuth.getKey());
210   auto *NewKey = Builder.getInt32(NewAuth.getKey());
211 
212   llvm::Value *CurDiscriminator = getDiscriminatorOrZero(CurAuth, Builder);
213   llvm::Value *NewDiscriminator = getDiscriminatorOrZero(NewAuth, Builder);
214 
215   // call i64 @llvm.ptrauth.resign(i64 %pointer,
216   //                               i32 %curKey, i64 %curDiscriminator,
217   //                               i32 %newKey, i64 %newDiscriminator)
218   auto *Intrinsic = CGM.getIntrinsic(llvm::Intrinsic::ptrauth_resign);
219   Value = EmitRuntimeCall(
220       Intrinsic, {Value, CurKey, CurDiscriminator, NewKey, NewDiscriminator});
221 
222   // Convert back to the original type.
223   Value = Builder.CreateIntToPtr(Value, OrigType);
224   return Value;
225 }
226 
227 llvm::Value *CodeGenFunction::emitPointerAuthResign(
228     llvm::Value *Value, QualType Type, const CGPointerAuthInfo &CurAuthInfo,
229     const CGPointerAuthInfo &NewAuthInfo, bool IsKnownNonNull) {
230   // Fast path: if neither schema wants a signature, we're done.
231   if (!CurAuthInfo && !NewAuthInfo)
232     return Value;
233 
234   llvm::Value *Null = nullptr;
235   // If the value is obviously null, we're done.
236   if (auto *PointerValue = dyn_cast<llvm::PointerType>(Value->getType())) {
237     Null = CGM.getNullPointer(PointerValue, Type);
238   } else {
239     assert(Value->getType()->isIntegerTy());
240     Null = llvm::ConstantInt::get(IntPtrTy, 0);
241   }
242   if (Value == Null)
243     return Value;
244 
245   // If both schemas sign the same way, we're done.
246   if (equalAuthPolicies(CurAuthInfo, NewAuthInfo)) {
247     const llvm::Value *CurD = CurAuthInfo.getDiscriminator();
248     const llvm::Value *NewD = NewAuthInfo.getDiscriminator();
249     if (CurD == NewD)
250       return Value;
251 
252     if ((CurD == nullptr && isZeroConstant(NewD)) ||
253         (NewD == nullptr && isZeroConstant(CurD)))
254       return Value;
255   }
256 
257   llvm::BasicBlock *InitBB = Builder.GetInsertBlock();
258   llvm::BasicBlock *ResignBB = nullptr, *ContBB = nullptr;
259 
260   // Null pointers have to be mapped to null, and the ptrauth_resign
261   // intrinsic doesn't do that.
262   if (!IsKnownNonNull && !llvm::isKnownNonZero(Value, CGM.getDataLayout())) {
263     ContBB = createBasicBlock("resign.cont");
264     ResignBB = createBasicBlock("resign.nonnull");
265 
266     auto *IsNonNull = Builder.CreateICmpNE(Value, Null);
267     Builder.CreateCondBr(IsNonNull, ResignBB, ContBB);
268     EmitBlock(ResignBB);
269   }
270 
271   // Perform the auth/sign/resign operation.
272   if (!NewAuthInfo)
273     Value = EmitPointerAuthAuth(CurAuthInfo, Value);
274   else if (!CurAuthInfo)
275     Value = EmitPointerAuthSign(NewAuthInfo, Value);
276   else
277     Value = emitPointerAuthResignCall(Value, CurAuthInfo, NewAuthInfo);
278 
279   // Clean up with a phi if we branched before.
280   if (ContBB) {
281     EmitBlock(ContBB);
282     auto *Phi = Builder.CreatePHI(Value->getType(), 2);
283     Phi->addIncoming(Null, InitBB);
284     Phi->addIncoming(Value, ResignBB);
285     Value = Phi;
286   }
287 
288   return Value;
289 }
290 
291 llvm::Constant *
292 CodeGenModule::getConstantSignedPointer(llvm::Constant *Pointer, unsigned Key,
293                                         llvm::Constant *StorageAddress,
294                                         llvm::ConstantInt *OtherDiscriminator) {
295   llvm::Constant *AddressDiscriminator;
296   if (StorageAddress) {
297     assert(StorageAddress->getType() == UnqualPtrTy);
298     AddressDiscriminator = StorageAddress;
299   } else {
300     AddressDiscriminator = llvm::Constant::getNullValue(UnqualPtrTy);
301   }
302 
303   llvm::ConstantInt *IntegerDiscriminator;
304   if (OtherDiscriminator) {
305     assert(OtherDiscriminator->getType() == Int64Ty);
306     IntegerDiscriminator = OtherDiscriminator;
307   } else {
308     IntegerDiscriminator = llvm::ConstantInt::get(Int64Ty, 0);
309   }
310 
311   return llvm::ConstantPtrAuth::get(Pointer,
312                                     llvm::ConstantInt::get(Int32Ty, Key),
313                                     IntegerDiscriminator, AddressDiscriminator);
314 }
315 
316 /// Does a given PointerAuthScheme require us to sign a value
317 bool CodeGenModule::shouldSignPointer(const PointerAuthSchema &Schema) {
318   auto AuthenticationMode = Schema.getAuthenticationMode();
319   return AuthenticationMode == PointerAuthenticationMode::SignAndStrip ||
320          AuthenticationMode == PointerAuthenticationMode::SignAndAuth;
321 }
322 
323 /// Sign a constant pointer using the given scheme, producing a constant
324 /// with the same IR type.
325 llvm::Constant *CodeGenModule::getConstantSignedPointer(
326     llvm::Constant *Pointer, const PointerAuthSchema &Schema,
327     llvm::Constant *StorageAddress, GlobalDecl SchemaDecl,
328     QualType SchemaType) {
329   assert(shouldSignPointer(Schema));
330   llvm::ConstantInt *OtherDiscriminator =
331       getPointerAuthOtherDiscriminator(Schema, SchemaDecl, SchemaType);
332 
333   return getConstantSignedPointer(Pointer, Schema.getKey(), StorageAddress,
334                                   OtherDiscriminator);
335 }
336 
337 /// If applicable, sign a given constant function pointer with the ABI rules for
338 /// functionType.
339 llvm::Constant *CodeGenModule::getFunctionPointer(llvm::Constant *Pointer,
340                                                   QualType FunctionType) {
341   assert(FunctionType->isFunctionType() ||
342          FunctionType->isFunctionReferenceType() ||
343          FunctionType->isFunctionPointerType());
344 
345   if (auto PointerAuth = getFunctionPointerAuthInfo(FunctionType))
346     return getConstantSignedPointer(
347         Pointer, PointerAuth.getKey(), /*StorageAddress=*/nullptr,
348         cast_or_null<llvm::ConstantInt>(PointerAuth.getDiscriminator()));
349 
350   return Pointer;
351 }
352 
353 llvm::Constant *CodeGenModule::getFunctionPointer(GlobalDecl GD,
354                                                   llvm::Type *Ty) {
355   const auto *FD = cast<FunctionDecl>(GD.getDecl());
356   QualType FuncType = FD->getType();
357 
358   // Annoyingly, K&R functions have prototypes in the clang AST, but
359   // expressions referring to them are unprototyped.
360   if (!FD->hasPrototype())
361     if (const auto *Proto = FuncType->getAs<FunctionProtoType>())
362       FuncType = Context.getFunctionNoProtoType(Proto->getReturnType(),
363                                                 Proto->getExtInfo());
364 
365   return getFunctionPointer(getRawFunctionPointer(GD, Ty), FuncType);
366 }
367 
368 CGPointerAuthInfo CodeGenModule::getMemberFunctionPointerAuthInfo(QualType FT) {
369   assert(FT->getAs<MemberPointerType>() && "MemberPointerType expected");
370   const auto &Schema = getCodeGenOpts().PointerAuth.CXXMemberFunctionPointers;
371   if (!Schema)
372     return CGPointerAuthInfo();
373 
374   assert(!Schema.isAddressDiscriminated() &&
375          "function pointers cannot use address-specific discrimination");
376 
377   llvm::ConstantInt *Discriminator =
378       getPointerAuthOtherDiscriminator(Schema, GlobalDecl(), FT);
379   return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
380                            /* IsIsaPointer */ false,
381                            /* AuthenticatesNullValues */ false, Discriminator);
382 }
383 
384 llvm::Constant *CodeGenModule::getMemberFunctionPointer(llvm::Constant *Pointer,
385                                                         QualType FT) {
386   if (CGPointerAuthInfo PointerAuth = getMemberFunctionPointerAuthInfo(FT))
387     return getConstantSignedPointer(
388         Pointer, PointerAuth.getKey(), nullptr,
389         cast_or_null<llvm::ConstantInt>(PointerAuth.getDiscriminator()));
390 
391   return Pointer;
392 }
393 
394 llvm::Constant *CodeGenModule::getMemberFunctionPointer(const FunctionDecl *FD,
395                                                         llvm::Type *Ty) {
396   QualType FT = FD->getType();
397   FT = getContext().getMemberPointerType(
398       FT, cast<CXXMethodDecl>(FD)->getParent()->getTypeForDecl());
399   return getMemberFunctionPointer(getRawFunctionPointer(FD, Ty), FT);
400 }
401 
402 std::optional<PointerAuthQualifier>
403 CodeGenModule::computeVTPointerAuthentication(const CXXRecordDecl *ThisClass) {
404   auto DefaultAuthentication = getCodeGenOpts().PointerAuth.CXXVTablePointers;
405   if (!DefaultAuthentication)
406     return std::nullopt;
407   const CXXRecordDecl *PrimaryBase =
408       Context.baseForVTableAuthentication(ThisClass);
409 
410   unsigned Key = DefaultAuthentication.getKey();
411   bool AddressDiscriminated = DefaultAuthentication.isAddressDiscriminated();
412   auto DefaultDiscrimination = DefaultAuthentication.getOtherDiscrimination();
413   unsigned TypeBasedDiscriminator =
414       Context.getPointerAuthVTablePointerDiscriminator(PrimaryBase);
415   unsigned Discriminator;
416   if (DefaultDiscrimination == PointerAuthSchema::Discrimination::Type) {
417     Discriminator = TypeBasedDiscriminator;
418   } else if (DefaultDiscrimination ==
419              PointerAuthSchema::Discrimination::Constant) {
420     Discriminator = DefaultAuthentication.getConstantDiscrimination();
421   } else {
422     assert(DefaultDiscrimination == PointerAuthSchema::Discrimination::None);
423     Discriminator = 0;
424   }
425   if (auto ExplicitAuthentication =
426           PrimaryBase->getAttr<VTablePointerAuthenticationAttr>()) {
427     auto ExplicitAddressDiscrimination =
428         ExplicitAuthentication->getAddressDiscrimination();
429     auto ExplicitDiscriminator =
430         ExplicitAuthentication->getExtraDiscrimination();
431 
432     unsigned ExplicitKey = ExplicitAuthentication->getKey();
433     if (ExplicitKey == VTablePointerAuthenticationAttr::NoKey)
434       return std::nullopt;
435 
436     if (ExplicitKey != VTablePointerAuthenticationAttr::DefaultKey) {
437       if (ExplicitKey == VTablePointerAuthenticationAttr::ProcessIndependent)
438         Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDA;
439       else {
440         assert(ExplicitKey ==
441                VTablePointerAuthenticationAttr::ProcessDependent);
442         Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDB;
443       }
444     }
445 
446     if (ExplicitAddressDiscrimination !=
447         VTablePointerAuthenticationAttr::DefaultAddressDiscrimination)
448       AddressDiscriminated =
449           ExplicitAddressDiscrimination ==
450           VTablePointerAuthenticationAttr::AddressDiscrimination;
451 
452     if (ExplicitDiscriminator ==
453         VTablePointerAuthenticationAttr::TypeDiscrimination)
454       Discriminator = TypeBasedDiscriminator;
455     else if (ExplicitDiscriminator ==
456              VTablePointerAuthenticationAttr::CustomDiscrimination)
457       Discriminator = ExplicitAuthentication->getCustomDiscriminationValue();
458     else if (ExplicitDiscriminator ==
459              VTablePointerAuthenticationAttr::NoExtraDiscrimination)
460       Discriminator = 0;
461   }
462   return PointerAuthQualifier::Create(Key, AddressDiscriminated, Discriminator,
463                                       PointerAuthenticationMode::SignAndAuth,
464                                       /* IsIsaPointer */ false,
465                                       /* AuthenticatesNullValues */ false);
466 }
467 
468 std::optional<PointerAuthQualifier>
469 CodeGenModule::getVTablePointerAuthentication(const CXXRecordDecl *Record) {
470   if (!Record->getDefinition() || !Record->isPolymorphic())
471     return std::nullopt;
472 
473   auto Existing = VTablePtrAuthInfos.find(Record);
474   std::optional<PointerAuthQualifier> Authentication;
475   if (Existing != VTablePtrAuthInfos.end()) {
476     Authentication = Existing->getSecond();
477   } else {
478     Authentication = computeVTPointerAuthentication(Record);
479     VTablePtrAuthInfos.insert(std::make_pair(Record, Authentication));
480   }
481   return Authentication;
482 }
483 
484 std::optional<CGPointerAuthInfo>
485 CodeGenModule::getVTablePointerAuthInfo(CodeGenFunction *CGF,
486                                         const CXXRecordDecl *Record,
487                                         llvm::Value *StorageAddress) {
488   auto Authentication = getVTablePointerAuthentication(Record);
489   if (!Authentication)
490     return std::nullopt;
491 
492   llvm::Value *Discriminator = nullptr;
493   if (auto ExtraDiscriminator = Authentication->getExtraDiscriminator())
494     Discriminator = llvm::ConstantInt::get(IntPtrTy, ExtraDiscriminator);
495 
496   if (Authentication->isAddressDiscriminated()) {
497     assert(StorageAddress &&
498            "address not provided for address-discriminated schema");
499     if (Discriminator)
500       Discriminator =
501           CGF->EmitPointerAuthBlendDiscriminator(StorageAddress, Discriminator);
502     else
503       Discriminator = CGF->Builder.CreatePtrToInt(StorageAddress, IntPtrTy);
504   }
505 
506   return CGPointerAuthInfo(Authentication->getKey(),
507                            PointerAuthenticationMode::SignAndAuth,
508                            /* IsIsaPointer */ false,
509                            /* AuthenticatesNullValues */ false, Discriminator);
510 }
511 
512 llvm::Value *CodeGenFunction::authPointerToPointerCast(llvm::Value *ResultPtr,
513                                                        QualType SourceType,
514                                                        QualType DestType) {
515   CGPointerAuthInfo CurAuthInfo, NewAuthInfo;
516   if (SourceType->isSignableType())
517     CurAuthInfo = getPointerAuthInfoForType(CGM, SourceType);
518 
519   if (DestType->isSignableType())
520     NewAuthInfo = getPointerAuthInfoForType(CGM, DestType);
521 
522   if (!CurAuthInfo && !NewAuthInfo)
523     return ResultPtr;
524 
525   // If only one side of the cast is a function pointer, then we still need to
526   // resign to handle casts to/from opaque pointers.
527   if (!CurAuthInfo && DestType->isFunctionPointerType())
528     CurAuthInfo = CGM.getFunctionPointerAuthInfo(SourceType);
529 
530   if (!NewAuthInfo && SourceType->isFunctionPointerType())
531     NewAuthInfo = CGM.getFunctionPointerAuthInfo(DestType);
532 
533   return emitPointerAuthResign(ResultPtr, DestType, CurAuthInfo, NewAuthInfo,
534                                /*IsKnownNonNull=*/false);
535 }
536 
537 Address CodeGenFunction::authPointerToPointerCast(Address Ptr,
538                                                   QualType SourceType,
539                                                   QualType DestType) {
540   CGPointerAuthInfo CurAuthInfo, NewAuthInfo;
541   if (SourceType->isSignableType())
542     CurAuthInfo = getPointerAuthInfoForType(CGM, SourceType);
543 
544   if (DestType->isSignableType())
545     NewAuthInfo = getPointerAuthInfoForType(CGM, DestType);
546 
547   if (!CurAuthInfo && !NewAuthInfo)
548     return Ptr;
549 
550   if (!CurAuthInfo && DestType->isFunctionPointerType()) {
551     // When casting a non-signed pointer to a function pointer, just set the
552     // auth info on Ptr to the assumed schema. The pointer will be resigned to
553     // the effective type when used.
554     Ptr.setPointerAuthInfo(CGM.getFunctionPointerAuthInfo(SourceType));
555     return Ptr;
556   }
557 
558   if (!NewAuthInfo && SourceType->isFunctionPointerType()) {
559     NewAuthInfo = CGM.getFunctionPointerAuthInfo(DestType);
560     Ptr = Ptr.getResignedAddress(NewAuthInfo, *this);
561     Ptr.setPointerAuthInfo(CGPointerAuthInfo());
562     return Ptr;
563   }
564 
565   return Ptr;
566 }
567 
568 Address CodeGenFunction::getAsNaturalAddressOf(Address Addr,
569                                                QualType PointeeTy) {
570   CGPointerAuthInfo Info =
571       PointeeTy.isNull() ? CGPointerAuthInfo()
572                          : CGM.getPointerAuthInfoForPointeeType(PointeeTy);
573   return Addr.getResignedAddress(Info, *this);
574 }
575 
576 Address Address::getResignedAddress(const CGPointerAuthInfo &NewInfo,
577                                     CodeGenFunction &CGF) const {
578   assert(isValid() && "pointer isn't valid");
579   CGPointerAuthInfo CurInfo = getPointerAuthInfo();
580   llvm::Value *Val;
581 
582   // Nothing to do if neither the current or the new ptrauth info needs signing.
583   if (!CurInfo.isSigned() && !NewInfo.isSigned())
584     return Address(getBasePointer(), getElementType(), getAlignment(),
585                    isKnownNonNull());
586 
587   assert(ElementType && "Effective type has to be set");
588   assert(!Offset && "unexpected non-null offset");
589 
590   // If the current and the new ptrauth infos are the same and the offset is
591   // null, just cast the base pointer to the effective type.
592   if (CurInfo == NewInfo && !hasOffset())
593     Val = getBasePointer();
594   else
595     Val = CGF.emitPointerAuthResign(getBasePointer(), QualType(), CurInfo,
596                                     NewInfo, isKnownNonNull());
597 
598   Val = CGF.Builder.CreateBitCast(Val, getType());
599   return Address(Val, getElementType(), getAlignment(), NewInfo,
600                  /*Offset=*/nullptr, isKnownNonNull());
601 }
602 
603 llvm::Value *Address::emitRawPointerSlow(CodeGenFunction &CGF) const {
604   return CGF.getAsNaturalPointerTo(*this, QualType());
605 }
606 
607 llvm::Value *LValue::getPointer(CodeGenFunction &CGF) const {
608   assert(isSimple());
609   return emitResignedPointer(getType(), CGF);
610 }
611 
612 llvm::Value *LValue::emitResignedPointer(QualType PointeeTy,
613                                          CodeGenFunction &CGF) const {
614   assert(isSimple());
615   return CGF.getAsNaturalAddressOf(Addr, PointeeTy).getBasePointer();
616 }
617 
618 llvm::Value *LValue::emitRawPointer(CodeGenFunction &CGF) const {
619   assert(isSimple());
620   return Addr.isValid() ? Addr.emitRawPointer(CGF) : nullptr;
621 }
622