b194cf1e40
This introduces the attribute discussed in https://discourse.llvm.org/t/rfc-function-type-attribute-to-prevent-cfi-instrumentation/85458. The proposed name has been changed from `no_cfi` to `cfi_unchecked_callee` to help differentiate from `no_sanitize("cfi")` more easily. The proposed attribute has the following semantics: 1. Indirect calls to a function type with this attribute will not be instrumented with CFI. That is, the indirect call will not be checked. Note that this only changes the behavior for indirect calls on pointers to function types having this attribute. It does not prevent all indirect function calls for a given type from being checked. 2. All direct references to a function whose type has this attribute will always reference the true function definition rather than an entry in the CFI jump table. 3. When a pointer to a function with this attribute is implicitly cast to a pointer to a function without this attribute, the compiler will give a warning saying this attribute is discarded. This warning can be silenced with an explicit C-style cast or C++ static_cast.
758 lines
29 KiB
C++
758 lines
29 KiB
C++
//===--- CGPointerAuth.cpp - IR generation for pointer authentication -----===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains common routines relating to the emission of
|
|
// pointer authentication operations.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "CodeGenFunction.h"
|
|
#include "CodeGenModule.h"
|
|
#include "clang/CodeGen/CodeGenABITypes.h"
|
|
#include "clang/CodeGen/ConstantInitBuilder.h"
|
|
#include "llvm/Analysis/ValueTracking.h"
|
|
#include "llvm/Support/SipHash.h"
|
|
|
|
using namespace clang;
|
|
using namespace CodeGen;
|
|
|
|
/// Given a pointer-authentication schema, return a concrete "other"
|
|
/// discriminator for it.
|
|
llvm::ConstantInt *CodeGenModule::getPointerAuthOtherDiscriminator(
|
|
const PointerAuthSchema &Schema, GlobalDecl Decl, QualType Type) {
|
|
switch (Schema.getOtherDiscrimination()) {
|
|
case PointerAuthSchema::Discrimination::None:
|
|
return nullptr;
|
|
|
|
case PointerAuthSchema::Discrimination::Type:
|
|
assert(!Type.isNull() && "type not provided for type-discriminated schema");
|
|
return llvm::ConstantInt::get(
|
|
IntPtrTy, getContext().getPointerAuthTypeDiscriminator(Type));
|
|
|
|
case PointerAuthSchema::Discrimination::Decl:
|
|
assert(Decl.getDecl() &&
|
|
"declaration not provided for decl-discriminated schema");
|
|
return llvm::ConstantInt::get(IntPtrTy,
|
|
getPointerAuthDeclDiscriminator(Decl));
|
|
|
|
case PointerAuthSchema::Discrimination::Constant:
|
|
return llvm::ConstantInt::get(IntPtrTy, Schema.getConstantDiscrimination());
|
|
}
|
|
llvm_unreachable("bad discrimination kind");
|
|
}
|
|
|
|
uint16_t CodeGen::getPointerAuthTypeDiscriminator(CodeGenModule &CGM,
|
|
QualType FunctionType) {
|
|
return CGM.getContext().getPointerAuthTypeDiscriminator(FunctionType);
|
|
}
|
|
|
|
uint16_t CodeGen::getPointerAuthDeclDiscriminator(CodeGenModule &CGM,
|
|
GlobalDecl Declaration) {
|
|
return CGM.getPointerAuthDeclDiscriminator(Declaration);
|
|
}
|
|
|
|
/// Return the "other" decl-specific discriminator for the given decl.
|
|
uint16_t
|
|
CodeGenModule::getPointerAuthDeclDiscriminator(GlobalDecl Declaration) {
|
|
uint16_t &EntityHash = PtrAuthDiscriminatorHashes[Declaration];
|
|
|
|
if (EntityHash == 0) {
|
|
StringRef Name = getMangledName(Declaration);
|
|
EntityHash = llvm::getPointerAuthStableSipHash(Name);
|
|
}
|
|
|
|
return EntityHash;
|
|
}
|
|
|
|
/// Return the abstract pointer authentication schema for a pointer to the given
|
|
/// function type.
|
|
CGPointerAuthInfo CodeGenModule::getFunctionPointerAuthInfo(QualType T) {
|
|
const auto &Schema = getCodeGenOpts().PointerAuth.FunctionPointers;
|
|
if (!Schema)
|
|
return CGPointerAuthInfo();
|
|
|
|
assert(!Schema.isAddressDiscriminated() &&
|
|
"function pointers cannot use address-specific discrimination");
|
|
|
|
llvm::Constant *Discriminator = nullptr;
|
|
if (T->isFunctionPointerType() || T->isFunctionReferenceType())
|
|
T = T->getPointeeType();
|
|
if (T->isFunctionType())
|
|
Discriminator = getPointerAuthOtherDiscriminator(Schema, GlobalDecl(), T);
|
|
|
|
return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
|
|
/*IsaPointer=*/false, /*AuthenticatesNull=*/false,
|
|
Discriminator);
|
|
}
|
|
|
|
llvm::Value *
|
|
CodeGenFunction::EmitPointerAuthBlendDiscriminator(llvm::Value *StorageAddress,
|
|
llvm::Value *Discriminator) {
|
|
StorageAddress = Builder.CreatePtrToInt(StorageAddress, IntPtrTy);
|
|
auto Intrinsic = CGM.getIntrinsic(llvm::Intrinsic::ptrauth_blend);
|
|
return Builder.CreateCall(Intrinsic, {StorageAddress, Discriminator});
|
|
}
|
|
|
|
/// Emit the concrete pointer authentication informaton for the
|
|
/// given authentication schema.
|
|
CGPointerAuthInfo CodeGenFunction::EmitPointerAuthInfo(
|
|
const PointerAuthSchema &Schema, llvm::Value *StorageAddress,
|
|
GlobalDecl SchemaDecl, QualType SchemaType) {
|
|
if (!Schema)
|
|
return CGPointerAuthInfo();
|
|
|
|
llvm::Value *Discriminator =
|
|
CGM.getPointerAuthOtherDiscriminator(Schema, SchemaDecl, SchemaType);
|
|
|
|
if (Schema.isAddressDiscriminated()) {
|
|
assert(StorageAddress &&
|
|
"address not provided for address-discriminated schema");
|
|
|
|
if (Discriminator)
|
|
Discriminator =
|
|
EmitPointerAuthBlendDiscriminator(StorageAddress, Discriminator);
|
|
else
|
|
Discriminator = Builder.CreatePtrToInt(StorageAddress, IntPtrTy);
|
|
}
|
|
|
|
return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
|
|
Schema.isIsaPointer(),
|
|
Schema.authenticatesNullValues(), Discriminator);
|
|
}
|
|
|
|
CGPointerAuthInfo
|
|
CodeGenFunction::EmitPointerAuthInfo(PointerAuthQualifier Qual,
|
|
Address StorageAddress) {
|
|
assert(Qual && "don't call this if you don't know that the Qual is present");
|
|
if (Qual.hasKeyNone())
|
|
return CGPointerAuthInfo();
|
|
|
|
llvm::Value *Discriminator = nullptr;
|
|
if (unsigned Extra = Qual.getExtraDiscriminator())
|
|
Discriminator = llvm::ConstantInt::get(IntPtrTy, Extra);
|
|
|
|
if (Qual.isAddressDiscriminated()) {
|
|
assert(StorageAddress.isValid() &&
|
|
"address discrimination without address");
|
|
llvm::Value *StoragePtr = StorageAddress.emitRawPointer(*this);
|
|
if (Discriminator)
|
|
Discriminator =
|
|
EmitPointerAuthBlendDiscriminator(StoragePtr, Discriminator);
|
|
else
|
|
Discriminator = Builder.CreatePtrToInt(StoragePtr, IntPtrTy);
|
|
}
|
|
|
|
return CGPointerAuthInfo(Qual.getKey(), Qual.getAuthenticationMode(),
|
|
Qual.isIsaPointer(), Qual.authenticatesNullValues(),
|
|
Discriminator);
|
|
}
|
|
|
|
/// Return the natural pointer authentication for values of the given
|
|
/// pointee type.
|
|
static CGPointerAuthInfo
|
|
getPointerAuthInfoForPointeeType(CodeGenModule &CGM, QualType PointeeType) {
|
|
if (PointeeType.isNull())
|
|
return CGPointerAuthInfo();
|
|
|
|
// Function pointers use the function-pointer schema by default.
|
|
if (PointeeType->isFunctionType())
|
|
return CGM.getFunctionPointerAuthInfo(PointeeType);
|
|
|
|
// Normal data pointers never use direct pointer authentication by default.
|
|
return CGPointerAuthInfo();
|
|
}
|
|
|
|
CGPointerAuthInfo CodeGenModule::getPointerAuthInfoForPointeeType(QualType T) {
|
|
return ::getPointerAuthInfoForPointeeType(*this, T);
|
|
}
|
|
|
|
/// Return the natural pointer authentication for values of the given
|
|
/// pointer type.
|
|
static CGPointerAuthInfo getPointerAuthInfoForType(CodeGenModule &CGM,
|
|
QualType PointerType) {
|
|
assert(PointerType->isSignableType(CGM.getContext()));
|
|
|
|
// Block pointers are currently not signed.
|
|
if (PointerType->isBlockPointerType())
|
|
return CGPointerAuthInfo();
|
|
|
|
auto PointeeType = PointerType->getPointeeType();
|
|
|
|
if (PointeeType.isNull())
|
|
return CGPointerAuthInfo();
|
|
|
|
return ::getPointerAuthInfoForPointeeType(CGM, PointeeType);
|
|
}
|
|
|
|
CGPointerAuthInfo CodeGenModule::getPointerAuthInfoForType(QualType T) {
|
|
return ::getPointerAuthInfoForType(*this, T);
|
|
}
|
|
|
|
static std::pair<llvm::Value *, CGPointerAuthInfo>
|
|
emitLoadOfOrigPointerRValue(CodeGenFunction &CGF, const LValue &LV,
|
|
SourceLocation Loc) {
|
|
llvm::Value *Value = CGF.EmitLoadOfScalar(LV, Loc);
|
|
CGPointerAuthInfo AuthInfo;
|
|
if (PointerAuthQualifier PtrAuth = LV.getQuals().getPointerAuth())
|
|
AuthInfo = CGF.EmitPointerAuthInfo(PtrAuth, LV.getAddress());
|
|
else
|
|
AuthInfo = getPointerAuthInfoForType(CGF.CGM, LV.getType());
|
|
return {Value, AuthInfo};
|
|
}
|
|
|
|
/// Retrieve a pointer rvalue and its ptrauth info. When possible, avoid
|
|
/// needlessly resigning the pointer.
|
|
std::pair<llvm::Value *, CGPointerAuthInfo>
|
|
CodeGenFunction::EmitOrigPointerRValue(const Expr *E) {
|
|
assert(E->getType()->isSignableType(getContext()));
|
|
|
|
E = E->IgnoreParens();
|
|
if (const auto *Load = dyn_cast<ImplicitCastExpr>(E)) {
|
|
if (Load->getCastKind() == CK_LValueToRValue) {
|
|
E = Load->getSubExpr()->IgnoreParens();
|
|
|
|
// We're semantically required to not emit loads of certain DREs naively.
|
|
if (const auto *RefExpr = dyn_cast<DeclRefExpr>(E)) {
|
|
if (ConstantEmission Result = tryEmitAsConstant(RefExpr)) {
|
|
// Fold away a use of an intermediate variable.
|
|
if (!Result.isReference())
|
|
return {Result.getValue(),
|
|
getPointerAuthInfoForType(CGM, RefExpr->getType())};
|
|
|
|
// Fold away a use of an intermediate reference.
|
|
LValue LV = Result.getReferenceLValue(*this, RefExpr);
|
|
return emitLoadOfOrigPointerRValue(*this, LV, RefExpr->getLocation());
|
|
}
|
|
}
|
|
|
|
// Otherwise, load and use the pointer
|
|
LValue LV = EmitCheckedLValue(E, CodeGenFunction::TCK_Load);
|
|
return emitLoadOfOrigPointerRValue(*this, LV, E->getExprLoc());
|
|
}
|
|
}
|
|
|
|
// Fallback: just use the normal rules for the type.
|
|
llvm::Value *Value = EmitScalarExpr(E);
|
|
return {Value, getPointerAuthInfoForType(CGM, E->getType())};
|
|
}
|
|
|
|
llvm::Value *
|
|
CodeGenFunction::EmitPointerAuthQualify(PointerAuthQualifier DestQualifier,
|
|
const Expr *E,
|
|
Address DestStorageAddress) {
|
|
assert(DestQualifier);
|
|
auto [Value, CurAuthInfo] = EmitOrigPointerRValue(E);
|
|
|
|
CGPointerAuthInfo DestAuthInfo =
|
|
EmitPointerAuthInfo(DestQualifier, DestStorageAddress);
|
|
return emitPointerAuthResign(Value, E->getType(), CurAuthInfo, DestAuthInfo,
|
|
isPointerKnownNonNull(E));
|
|
}
|
|
|
|
llvm::Value *CodeGenFunction::EmitPointerAuthQualify(
|
|
PointerAuthQualifier DestQualifier, llvm::Value *Value,
|
|
QualType PointerType, Address DestStorageAddress, bool IsKnownNonNull) {
|
|
assert(DestQualifier);
|
|
|
|
CGPointerAuthInfo CurAuthInfo = getPointerAuthInfoForType(CGM, PointerType);
|
|
CGPointerAuthInfo DestAuthInfo =
|
|
EmitPointerAuthInfo(DestQualifier, DestStorageAddress);
|
|
return emitPointerAuthResign(Value, PointerType, CurAuthInfo, DestAuthInfo,
|
|
IsKnownNonNull);
|
|
}
|
|
|
|
llvm::Value *CodeGenFunction::EmitPointerAuthUnqualify(
|
|
PointerAuthQualifier CurQualifier, llvm::Value *Value, QualType PointerType,
|
|
Address CurStorageAddress, bool IsKnownNonNull) {
|
|
assert(CurQualifier);
|
|
|
|
CGPointerAuthInfo CurAuthInfo =
|
|
EmitPointerAuthInfo(CurQualifier, CurStorageAddress);
|
|
CGPointerAuthInfo DestAuthInfo = getPointerAuthInfoForType(CGM, PointerType);
|
|
return emitPointerAuthResign(Value, PointerType, CurAuthInfo, DestAuthInfo,
|
|
IsKnownNonNull);
|
|
}
|
|
|
|
static bool isZeroConstant(const llvm::Value *Value) {
|
|
if (const auto *CI = dyn_cast<llvm::ConstantInt>(Value))
|
|
return CI->isZero();
|
|
return false;
|
|
}
|
|
|
|
static bool equalAuthPolicies(const CGPointerAuthInfo &Left,
|
|
const CGPointerAuthInfo &Right) {
|
|
assert((Left.isSigned() || Right.isSigned()) &&
|
|
"shouldn't be called if neither is signed");
|
|
if (Left.isSigned() != Right.isSigned())
|
|
return false;
|
|
return Left.getKey() == Right.getKey() &&
|
|
Left.getAuthenticationMode() == Right.getAuthenticationMode() &&
|
|
Left.isIsaPointer() == Right.isIsaPointer() &&
|
|
Left.authenticatesNullValues() == Right.authenticatesNullValues() &&
|
|
Left.getDiscriminator() == Right.getDiscriminator();
|
|
}
|
|
|
|
// Return the discriminator or return zero if the discriminator is null.
|
|
static llvm::Value *getDiscriminatorOrZero(const CGPointerAuthInfo &Info,
|
|
CGBuilderTy &Builder) {
|
|
llvm::Value *Discriminator = Info.getDiscriminator();
|
|
return Discriminator ? Discriminator : Builder.getSize(0);
|
|
}
|
|
|
|
llvm::Value *
|
|
CodeGenFunction::emitPointerAuthResignCall(llvm::Value *Value,
|
|
const CGPointerAuthInfo &CurAuth,
|
|
const CGPointerAuthInfo &NewAuth) {
|
|
assert(CurAuth && NewAuth);
|
|
|
|
if (CurAuth.getAuthenticationMode() !=
|
|
PointerAuthenticationMode::SignAndAuth ||
|
|
NewAuth.getAuthenticationMode() !=
|
|
PointerAuthenticationMode::SignAndAuth) {
|
|
llvm::Value *AuthedValue = EmitPointerAuthAuth(CurAuth, Value);
|
|
return EmitPointerAuthSign(NewAuth, AuthedValue);
|
|
}
|
|
// Convert the pointer to intptr_t before signing it.
|
|
auto *OrigType = Value->getType();
|
|
Value = Builder.CreatePtrToInt(Value, IntPtrTy);
|
|
|
|
auto *CurKey = Builder.getInt32(CurAuth.getKey());
|
|
auto *NewKey = Builder.getInt32(NewAuth.getKey());
|
|
|
|
llvm::Value *CurDiscriminator = getDiscriminatorOrZero(CurAuth, Builder);
|
|
llvm::Value *NewDiscriminator = getDiscriminatorOrZero(NewAuth, Builder);
|
|
|
|
// call i64 @llvm.ptrauth.resign(i64 %pointer,
|
|
// i32 %curKey, i64 %curDiscriminator,
|
|
// i32 %newKey, i64 %newDiscriminator)
|
|
auto *Intrinsic = CGM.getIntrinsic(llvm::Intrinsic::ptrauth_resign);
|
|
Value = EmitRuntimeCall(
|
|
Intrinsic, {Value, CurKey, CurDiscriminator, NewKey, NewDiscriminator});
|
|
|
|
// Convert back to the original type.
|
|
Value = Builder.CreateIntToPtr(Value, OrigType);
|
|
return Value;
|
|
}
|
|
|
|
llvm::Value *CodeGenFunction::emitPointerAuthResign(
|
|
llvm::Value *Value, QualType Type, const CGPointerAuthInfo &CurAuthInfo,
|
|
const CGPointerAuthInfo &NewAuthInfo, bool IsKnownNonNull) {
|
|
// Fast path: if neither schema wants a signature, we're done.
|
|
if (!CurAuthInfo && !NewAuthInfo)
|
|
return Value;
|
|
|
|
llvm::Value *Null = nullptr;
|
|
// If the value is obviously null, we're done.
|
|
if (auto *PointerValue = dyn_cast<llvm::PointerType>(Value->getType())) {
|
|
Null = CGM.getNullPointer(PointerValue, Type);
|
|
} else {
|
|
assert(Value->getType()->isIntegerTy());
|
|
Null = llvm::ConstantInt::get(IntPtrTy, 0);
|
|
}
|
|
if (Value == Null)
|
|
return Value;
|
|
|
|
// If both schemas sign the same way, we're done.
|
|
if (equalAuthPolicies(CurAuthInfo, NewAuthInfo)) {
|
|
const llvm::Value *CurD = CurAuthInfo.getDiscriminator();
|
|
const llvm::Value *NewD = NewAuthInfo.getDiscriminator();
|
|
if (CurD == NewD)
|
|
return Value;
|
|
|
|
if ((CurD == nullptr && isZeroConstant(NewD)) ||
|
|
(NewD == nullptr && isZeroConstant(CurD)))
|
|
return Value;
|
|
}
|
|
|
|
llvm::BasicBlock *InitBB = Builder.GetInsertBlock();
|
|
llvm::BasicBlock *ResignBB = nullptr, *ContBB = nullptr;
|
|
|
|
// Null pointers have to be mapped to null, and the ptrauth_resign
|
|
// intrinsic doesn't do that.
|
|
if (!IsKnownNonNull && !llvm::isKnownNonZero(Value, CGM.getDataLayout())) {
|
|
ContBB = createBasicBlock("resign.cont");
|
|
ResignBB = createBasicBlock("resign.nonnull");
|
|
|
|
auto *IsNonNull = Builder.CreateICmpNE(Value, Null);
|
|
Builder.CreateCondBr(IsNonNull, ResignBB, ContBB);
|
|
EmitBlock(ResignBB);
|
|
}
|
|
|
|
// Perform the auth/sign/resign operation.
|
|
if (!NewAuthInfo)
|
|
Value = EmitPointerAuthAuth(CurAuthInfo, Value);
|
|
else if (!CurAuthInfo)
|
|
Value = EmitPointerAuthSign(NewAuthInfo, Value);
|
|
else
|
|
Value = emitPointerAuthResignCall(Value, CurAuthInfo, NewAuthInfo);
|
|
|
|
// Clean up with a phi if we branched before.
|
|
if (ContBB) {
|
|
EmitBlock(ContBB);
|
|
auto *Phi = Builder.CreatePHI(Value->getType(), 2);
|
|
Phi->addIncoming(Null, InitBB);
|
|
Phi->addIncoming(Value, ResignBB);
|
|
Value = Phi;
|
|
}
|
|
|
|
return Value;
|
|
}
|
|
|
|
void CodeGenFunction::EmitPointerAuthCopy(PointerAuthQualifier Qual, QualType T,
|
|
Address DestAddress,
|
|
Address SrcAddress) {
|
|
assert(Qual);
|
|
llvm::Value *Value = Builder.CreateLoad(SrcAddress);
|
|
|
|
// If we're using address-discrimination, we have to re-sign the value.
|
|
if (Qual.isAddressDiscriminated()) {
|
|
CGPointerAuthInfo SrcPtrAuth = EmitPointerAuthInfo(Qual, SrcAddress);
|
|
CGPointerAuthInfo DestPtrAuth = EmitPointerAuthInfo(Qual, DestAddress);
|
|
Value = emitPointerAuthResign(Value, T, SrcPtrAuth, DestPtrAuth,
|
|
/*IsKnownNonNull=*/false);
|
|
}
|
|
|
|
Builder.CreateStore(Value, DestAddress);
|
|
}
|
|
|
|
llvm::Constant *
|
|
CodeGenModule::getConstantSignedPointer(llvm::Constant *Pointer, unsigned Key,
|
|
llvm::Constant *StorageAddress,
|
|
llvm::ConstantInt *OtherDiscriminator) {
|
|
llvm::Constant *AddressDiscriminator;
|
|
if (StorageAddress) {
|
|
assert(StorageAddress->getType() == UnqualPtrTy);
|
|
AddressDiscriminator = StorageAddress;
|
|
} else {
|
|
AddressDiscriminator = llvm::Constant::getNullValue(UnqualPtrTy);
|
|
}
|
|
|
|
llvm::ConstantInt *IntegerDiscriminator;
|
|
if (OtherDiscriminator) {
|
|
assert(OtherDiscriminator->getType() == Int64Ty);
|
|
IntegerDiscriminator = OtherDiscriminator;
|
|
} else {
|
|
IntegerDiscriminator = llvm::ConstantInt::get(Int64Ty, 0);
|
|
}
|
|
|
|
return llvm::ConstantPtrAuth::get(Pointer,
|
|
llvm::ConstantInt::get(Int32Ty, Key),
|
|
IntegerDiscriminator, AddressDiscriminator);
|
|
}
|
|
|
|
/// Does a given PointerAuthScheme require us to sign a value
|
|
bool CodeGenModule::shouldSignPointer(const PointerAuthSchema &Schema) {
|
|
auto AuthenticationMode = Schema.getAuthenticationMode();
|
|
return AuthenticationMode == PointerAuthenticationMode::SignAndStrip ||
|
|
AuthenticationMode == PointerAuthenticationMode::SignAndAuth;
|
|
}
|
|
|
|
/// Sign a constant pointer using the given scheme, producing a constant
|
|
/// with the same IR type.
|
|
llvm::Constant *CodeGenModule::getConstantSignedPointer(
|
|
llvm::Constant *Pointer, const PointerAuthSchema &Schema,
|
|
llvm::Constant *StorageAddress, GlobalDecl SchemaDecl,
|
|
QualType SchemaType) {
|
|
assert(shouldSignPointer(Schema));
|
|
llvm::ConstantInt *OtherDiscriminator =
|
|
getPointerAuthOtherDiscriminator(Schema, SchemaDecl, SchemaType);
|
|
|
|
return getConstantSignedPointer(Pointer, Schema.getKey(), StorageAddress,
|
|
OtherDiscriminator);
|
|
}
|
|
|
|
/// If applicable, sign a given constant function pointer with the ABI rules for
|
|
/// functionType.
|
|
llvm::Constant *CodeGenModule::getFunctionPointer(llvm::Constant *Pointer,
|
|
QualType FunctionType) {
|
|
assert(FunctionType->isFunctionType() ||
|
|
FunctionType->isFunctionReferenceType() ||
|
|
FunctionType->isFunctionPointerType());
|
|
|
|
if (auto PointerAuth = getFunctionPointerAuthInfo(FunctionType))
|
|
return getConstantSignedPointer(
|
|
Pointer, PointerAuth.getKey(), /*StorageAddress=*/nullptr,
|
|
cast_or_null<llvm::ConstantInt>(PointerAuth.getDiscriminator()));
|
|
|
|
return Pointer;
|
|
}
|
|
|
|
llvm::Constant *CodeGenModule::getFunctionPointer(GlobalDecl GD,
|
|
llvm::Type *Ty) {
|
|
const auto *FD = cast<FunctionDecl>(GD.getDecl());
|
|
QualType FuncType = FD->getType();
|
|
|
|
// Annoyingly, K&R functions have prototypes in the clang AST, but
|
|
// expressions referring to them are unprototyped.
|
|
if (!FD->hasPrototype())
|
|
if (const auto *Proto = FuncType->getAs<FunctionProtoType>())
|
|
FuncType = Context.getFunctionNoProtoType(Proto->getReturnType(),
|
|
Proto->getExtInfo());
|
|
|
|
return getFunctionPointer(getRawFunctionPointer(GD, Ty), FuncType);
|
|
}
|
|
|
|
CGPointerAuthInfo CodeGenModule::getMemberFunctionPointerAuthInfo(QualType FT) {
|
|
assert(FT->getAs<MemberPointerType>() && "MemberPointerType expected");
|
|
const auto &Schema = getCodeGenOpts().PointerAuth.CXXMemberFunctionPointers;
|
|
if (!Schema)
|
|
return CGPointerAuthInfo();
|
|
|
|
assert(!Schema.isAddressDiscriminated() &&
|
|
"function pointers cannot use address-specific discrimination");
|
|
|
|
llvm::ConstantInt *Discriminator =
|
|
getPointerAuthOtherDiscriminator(Schema, GlobalDecl(), FT);
|
|
return CGPointerAuthInfo(Schema.getKey(), Schema.getAuthenticationMode(),
|
|
/* IsIsaPointer */ false,
|
|
/* AuthenticatesNullValues */ false, Discriminator);
|
|
}
|
|
|
|
llvm::Constant *CodeGenModule::getMemberFunctionPointer(llvm::Constant *Pointer,
|
|
QualType FT) {
|
|
if (CGPointerAuthInfo PointerAuth = getMemberFunctionPointerAuthInfo(FT))
|
|
return getConstantSignedPointer(
|
|
Pointer, PointerAuth.getKey(), nullptr,
|
|
cast_or_null<llvm::ConstantInt>(PointerAuth.getDiscriminator()));
|
|
|
|
if (const auto *MFT = dyn_cast<MemberPointerType>(FT.getTypePtr())) {
|
|
if (MFT->hasPointeeToToCFIUncheckedCalleeFunctionType())
|
|
Pointer = llvm::NoCFIValue::get(cast<llvm::GlobalValue>(Pointer));
|
|
}
|
|
|
|
return Pointer;
|
|
}
|
|
|
|
llvm::Constant *CodeGenModule::getMemberFunctionPointer(const FunctionDecl *FD,
|
|
llvm::Type *Ty) {
|
|
QualType FT = FD->getType();
|
|
FT = getContext().getMemberPointerType(FT, /*Qualifier=*/nullptr,
|
|
cast<CXXMethodDecl>(FD)->getParent());
|
|
return getMemberFunctionPointer(getRawFunctionPointer(FD, Ty), FT);
|
|
}
|
|
|
|
std::optional<PointerAuthQualifier>
|
|
CodeGenModule::computeVTPointerAuthentication(const CXXRecordDecl *ThisClass) {
|
|
auto DefaultAuthentication = getCodeGenOpts().PointerAuth.CXXVTablePointers;
|
|
if (!DefaultAuthentication)
|
|
return std::nullopt;
|
|
const CXXRecordDecl *PrimaryBase =
|
|
Context.baseForVTableAuthentication(ThisClass);
|
|
|
|
unsigned Key = DefaultAuthentication.getKey();
|
|
bool AddressDiscriminated = DefaultAuthentication.isAddressDiscriminated();
|
|
auto DefaultDiscrimination = DefaultAuthentication.getOtherDiscrimination();
|
|
unsigned TypeBasedDiscriminator =
|
|
Context.getPointerAuthVTablePointerDiscriminator(PrimaryBase);
|
|
unsigned Discriminator;
|
|
if (DefaultDiscrimination == PointerAuthSchema::Discrimination::Type) {
|
|
Discriminator = TypeBasedDiscriminator;
|
|
} else if (DefaultDiscrimination ==
|
|
PointerAuthSchema::Discrimination::Constant) {
|
|
Discriminator = DefaultAuthentication.getConstantDiscrimination();
|
|
} else {
|
|
assert(DefaultDiscrimination == PointerAuthSchema::Discrimination::None);
|
|
Discriminator = 0;
|
|
}
|
|
if (auto ExplicitAuthentication =
|
|
PrimaryBase->getAttr<VTablePointerAuthenticationAttr>()) {
|
|
auto ExplicitAddressDiscrimination =
|
|
ExplicitAuthentication->getAddressDiscrimination();
|
|
auto ExplicitDiscriminator =
|
|
ExplicitAuthentication->getExtraDiscrimination();
|
|
|
|
unsigned ExplicitKey = ExplicitAuthentication->getKey();
|
|
if (ExplicitKey == VTablePointerAuthenticationAttr::NoKey)
|
|
return std::nullopt;
|
|
|
|
if (ExplicitKey != VTablePointerAuthenticationAttr::DefaultKey) {
|
|
if (ExplicitKey == VTablePointerAuthenticationAttr::ProcessIndependent)
|
|
Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDA;
|
|
else {
|
|
assert(ExplicitKey ==
|
|
VTablePointerAuthenticationAttr::ProcessDependent);
|
|
Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDB;
|
|
}
|
|
}
|
|
|
|
if (ExplicitAddressDiscrimination !=
|
|
VTablePointerAuthenticationAttr::DefaultAddressDiscrimination)
|
|
AddressDiscriminated =
|
|
ExplicitAddressDiscrimination ==
|
|
VTablePointerAuthenticationAttr::AddressDiscrimination;
|
|
|
|
if (ExplicitDiscriminator ==
|
|
VTablePointerAuthenticationAttr::TypeDiscrimination)
|
|
Discriminator = TypeBasedDiscriminator;
|
|
else if (ExplicitDiscriminator ==
|
|
VTablePointerAuthenticationAttr::CustomDiscrimination)
|
|
Discriminator = ExplicitAuthentication->getCustomDiscriminationValue();
|
|
else if (ExplicitDiscriminator ==
|
|
VTablePointerAuthenticationAttr::NoExtraDiscrimination)
|
|
Discriminator = 0;
|
|
}
|
|
return PointerAuthQualifier::Create(Key, AddressDiscriminated, Discriminator,
|
|
PointerAuthenticationMode::SignAndAuth,
|
|
/* IsIsaPointer */ false,
|
|
/* AuthenticatesNullValues */ false);
|
|
}
|
|
|
|
std::optional<PointerAuthQualifier>
|
|
CodeGenModule::getVTablePointerAuthentication(const CXXRecordDecl *Record) {
|
|
if (!Record->getDefinition() || !Record->isPolymorphic())
|
|
return std::nullopt;
|
|
|
|
auto Existing = VTablePtrAuthInfos.find(Record);
|
|
std::optional<PointerAuthQualifier> Authentication;
|
|
if (Existing != VTablePtrAuthInfos.end()) {
|
|
Authentication = Existing->getSecond();
|
|
} else {
|
|
Authentication = computeVTPointerAuthentication(Record);
|
|
VTablePtrAuthInfos.insert(std::make_pair(Record, Authentication));
|
|
}
|
|
return Authentication;
|
|
}
|
|
|
|
std::optional<CGPointerAuthInfo>
|
|
CodeGenModule::getVTablePointerAuthInfo(CodeGenFunction *CGF,
|
|
const CXXRecordDecl *Record,
|
|
llvm::Value *StorageAddress) {
|
|
auto Authentication = getVTablePointerAuthentication(Record);
|
|
if (!Authentication)
|
|
return std::nullopt;
|
|
|
|
llvm::Value *Discriminator = nullptr;
|
|
if (auto ExtraDiscriminator = Authentication->getExtraDiscriminator())
|
|
Discriminator = llvm::ConstantInt::get(IntPtrTy, ExtraDiscriminator);
|
|
|
|
if (Authentication->isAddressDiscriminated()) {
|
|
assert(StorageAddress &&
|
|
"address not provided for address-discriminated schema");
|
|
if (Discriminator)
|
|
Discriminator =
|
|
CGF->EmitPointerAuthBlendDiscriminator(StorageAddress, Discriminator);
|
|
else
|
|
Discriminator = CGF->Builder.CreatePtrToInt(StorageAddress, IntPtrTy);
|
|
}
|
|
|
|
return CGPointerAuthInfo(Authentication->getKey(),
|
|
PointerAuthenticationMode::SignAndAuth,
|
|
/* IsIsaPointer */ false,
|
|
/* AuthenticatesNullValues */ false, Discriminator);
|
|
}
|
|
|
|
llvm::Value *CodeGenFunction::authPointerToPointerCast(llvm::Value *ResultPtr,
|
|
QualType SourceType,
|
|
QualType DestType) {
|
|
CGPointerAuthInfo CurAuthInfo, NewAuthInfo;
|
|
if (SourceType->isSignableType(getContext()))
|
|
CurAuthInfo = getPointerAuthInfoForType(CGM, SourceType);
|
|
|
|
if (DestType->isSignableType(getContext()))
|
|
NewAuthInfo = getPointerAuthInfoForType(CGM, DestType);
|
|
|
|
if (!CurAuthInfo && !NewAuthInfo)
|
|
return ResultPtr;
|
|
|
|
// If only one side of the cast is a function pointer, then we still need to
|
|
// resign to handle casts to/from opaque pointers.
|
|
if (!CurAuthInfo && DestType->isFunctionPointerType())
|
|
CurAuthInfo = CGM.getFunctionPointerAuthInfo(SourceType);
|
|
|
|
if (!NewAuthInfo && SourceType->isFunctionPointerType())
|
|
NewAuthInfo = CGM.getFunctionPointerAuthInfo(DestType);
|
|
|
|
return emitPointerAuthResign(ResultPtr, DestType, CurAuthInfo, NewAuthInfo,
|
|
/*IsKnownNonNull=*/false);
|
|
}
|
|
|
|
Address CodeGenFunction::authPointerToPointerCast(Address Ptr,
|
|
QualType SourceType,
|
|
QualType DestType) {
|
|
CGPointerAuthInfo CurAuthInfo, NewAuthInfo;
|
|
if (SourceType->isSignableType(getContext()))
|
|
CurAuthInfo = getPointerAuthInfoForType(CGM, SourceType);
|
|
|
|
if (DestType->isSignableType(getContext()))
|
|
NewAuthInfo = getPointerAuthInfoForType(CGM, DestType);
|
|
|
|
if (!CurAuthInfo && !NewAuthInfo)
|
|
return Ptr;
|
|
|
|
if (!CurAuthInfo && DestType->isFunctionPointerType()) {
|
|
// When casting a non-signed pointer to a function pointer, just set the
|
|
// auth info on Ptr to the assumed schema. The pointer will be resigned to
|
|
// the effective type when used.
|
|
Ptr.setPointerAuthInfo(CGM.getFunctionPointerAuthInfo(SourceType));
|
|
return Ptr;
|
|
}
|
|
|
|
if (!NewAuthInfo && SourceType->isFunctionPointerType()) {
|
|
NewAuthInfo = CGM.getFunctionPointerAuthInfo(DestType);
|
|
Ptr = Ptr.getResignedAddress(NewAuthInfo, *this);
|
|
Ptr.setPointerAuthInfo(CGPointerAuthInfo());
|
|
return Ptr;
|
|
}
|
|
|
|
return Ptr;
|
|
}
|
|
|
|
Address CodeGenFunction::getAsNaturalAddressOf(Address Addr,
|
|
QualType PointeeTy) {
|
|
CGPointerAuthInfo Info =
|
|
PointeeTy.isNull() ? CGPointerAuthInfo()
|
|
: CGM.getPointerAuthInfoForPointeeType(PointeeTy);
|
|
return Addr.getResignedAddress(Info, *this);
|
|
}
|
|
|
|
Address Address::getResignedAddress(const CGPointerAuthInfo &NewInfo,
|
|
CodeGenFunction &CGF) const {
|
|
assert(isValid() && "pointer isn't valid");
|
|
CGPointerAuthInfo CurInfo = getPointerAuthInfo();
|
|
llvm::Value *Val;
|
|
|
|
// Nothing to do if neither the current or the new ptrauth info needs signing.
|
|
if (!CurInfo.isSigned() && !NewInfo.isSigned())
|
|
return Address(getBasePointer(), getElementType(), getAlignment(),
|
|
isKnownNonNull());
|
|
|
|
assert(ElementType && "Effective type has to be set");
|
|
assert(!Offset && "unexpected non-null offset");
|
|
|
|
// If the current and the new ptrauth infos are the same and the offset is
|
|
// null, just cast the base pointer to the effective type.
|
|
if (CurInfo == NewInfo && !hasOffset())
|
|
Val = getBasePointer();
|
|
else
|
|
Val = CGF.emitPointerAuthResign(getBasePointer(), QualType(), CurInfo,
|
|
NewInfo, isKnownNonNull());
|
|
|
|
return Address(Val, getElementType(), getAlignment(), NewInfo,
|
|
/*Offset=*/nullptr, isKnownNonNull());
|
|
}
|
|
|
|
llvm::Value *Address::emitRawPointerSlow(CodeGenFunction &CGF) const {
|
|
return CGF.getAsNaturalPointerTo(*this, QualType());
|
|
}
|
|
|
|
llvm::Value *LValue::getPointer(CodeGenFunction &CGF) const {
|
|
assert(isSimple());
|
|
return emitResignedPointer(getType(), CGF);
|
|
}
|
|
|
|
llvm::Value *LValue::emitResignedPointer(QualType PointeeTy,
|
|
CodeGenFunction &CGF) const {
|
|
assert(isSimple());
|
|
return CGF.getAsNaturalAddressOf(Addr, PointeeTy).getBasePointer();
|
|
}
|
|
|
|
llvm::Value *LValue::emitRawPointer(CodeGenFunction &CGF) const {
|
|
assert(isSimple());
|
|
return Addr.isValid() ? Addr.emitRawPointer(CGF) : nullptr;
|
|
}
|