[clang] Resign type-discriminated function pointers on cast.

Author: ahmedbougacha

clang/include/clang/AST/ASTContext.h

@@ -1284,7 +1284,7 @@ class ASTContext : public RefCountedBase<ASTContext> {
   getPointerAuthVTablePointerDiscriminator(const CXXRecordDecl *RD);
 
   /// Return the "other" type-specific discriminator for the given type.
-  uint16_t getPointerAuthTypeDiscriminator(QualType T) const;
+  uint16_t getPointerAuthTypeDiscriminator(QualType T);
 
   /// Apply Objective-C protocol qualifiers to the given type.
   /// \param allowOnPointerType specifies if we can apply protocol

clang/include/clang/AST/Type.h

@@ -2507,6 +2507,7 @@ class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
   bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
   bool isPointerType() const;
   bool isSignableType() const;
+  bool isSignablePointerType() const;
   bool isAnyPointerType() const;   // Any C pointer or ObjC object pointer
   bool isCountAttributedType() const;
   bool isBlockPointerType() const;
@@ -8002,7 +8003,9 @@ inline bool Type::isAnyPointerType() const {
   return isPointerType() || isObjCObjectPointerType();
 }
 
-inline bool Type::isSignableType() const { return isPointerType(); }
+inline bool Type::isSignableType() const { return isSignablePointerType(); }
+
+inline bool Type::isSignablePointerType() const { return isPointerType(); }
 
 inline bool Type::isBlockPointerType() const {
   return isa<BlockPointerType>(CanonicalType);

clang/lib/AST/ASTContext.cpp

@@ -3400,7 +3400,7 @@ static void encodeTypeForFunctionPointerAuth(const ASTContext &Ctx,
   }
 }
 
-uint16_t ASTContext::getPointerAuthTypeDiscriminator(QualType T) const {
+uint16_t ASTContext::getPointerAuthTypeDiscriminator(QualType T) {
   assert(!T->isDependentType() &&
          "cannot compute type discriminator of a dependent type");
 
@@ -3410,11 +3410,13 @@ uint16_t ASTContext::getPointerAuthTypeDiscriminator(QualType T) const {
   if (T->isFunctionPointerType() || T->isFunctionReferenceType())
     T = T->getPointeeType();
 
-  if (T->isFunctionType())
+  if (T->isFunctionType()) {
     encodeTypeForFunctionPointerAuth(*this, Out, T);
-  else
-    llvm_unreachable(
-        "type discrimination of non-function type not implemented yet");
+  } else {
+    T = T.getUnqualifiedType();
+    std::unique_ptr<MangleContext> MC(createMangleContext());
+    MC->mangleCanonicalTypeName(T, Out);
+  }
 
   return llvm::getPointerAuthStableSipHash(Str);
 }

clang/lib/CodeGen/Address.h

@@ -14,6 +14,7 @@
 #ifndef LLVM_CLANG_LIB_CODEGEN_ADDRESS_H
 #define LLVM_CLANG_LIB_CODEGEN_ADDRESS_H
 
+#include "CGPointerAuthInfo.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Type.h"
 #include "llvm/ADT/PointerIntPair.h"
@@ -141,7 +142,11 @@ class Address {
 
   CharUnits Alignment;
 
-  /// Offset from the base pointer.
+  /// The ptrauth information needed to authenticate the base pointer.
+  CGPointerAuthInfo PtrAuthInfo;
+
+  /// Offset from the base pointer. This is non-null only when the base
+  /// pointer is signed.
   llvm::Value *Offset = nullptr;
 
   llvm::Value *emitRawPointerSlow(CodeGenFunction &CGF) const;
@@ -160,12 +165,14 @@ class Address {
   }
 
   Address(llvm::Value *BasePtr, llvm::Type *ElementType, CharUnits Alignment,
-          llvm::Value *Offset, KnownNonNull_t IsKnownNonNull = NotKnownNonNull)
+          CGPointerAuthInfo PtrAuthInfo, llvm::Value *Offset,
+          KnownNonNull_t IsKnownNonNull = NotKnownNonNull)
       : Pointer(BasePtr, IsKnownNonNull), ElementType(ElementType),
-        Alignment(Alignment), Offset(Offset) {}
+        Alignment(Alignment), PtrAuthInfo(PtrAuthInfo), Offset(Offset) {}
 
   Address(RawAddress RawAddr)
-      : Pointer(RawAddr.isValid() ? RawAddr.getPointer() : nullptr),
+      : Pointer(RawAddr.isValid() ? RawAddr.getPointer() : nullptr,
+                RawAddr.isValid() ? RawAddr.isKnownNonNull() : NotKnownNonNull),
         ElementType(RawAddr.isValid() ? RawAddr.getElementType() : nullptr),
         Alignment(RawAddr.isValid() ? RawAddr.getAlignment()
                                     : CharUnits::Zero()) {}
@@ -175,7 +182,7 @@ class Address {
 
   llvm::Value *getPointerIfNotSigned() const {
     assert(isValid() && "pointer isn't valid");
-    return Pointer.getPointer();
+    return !isSigned() ? Pointer.getPointer() : nullptr;
   }
 
   /// This function is used in situations where the caller is doing some sort of
@@ -197,7 +204,10 @@ class Address {
     return Pointer.getPointer();
   }
 
-  llvm::Value *getUnsignedPointer() const { return getBasePointer(); }
+  llvm::Value *getUnsignedPointer() const {
+    assert(!isSigned() && "cannot call this function if pointer is signed");
+    return getBasePointer();
+  }
 
   /// Return the type of the pointer value.
   llvm::PointerType *getType() const {
@@ -219,14 +229,18 @@ class Address {
   /// Return the IR name of the pointer value.
   llvm::StringRef getName() const { return Pointer.getPointer()->getName(); }
 
+  const CGPointerAuthInfo &getPointerAuthInfo() const { return PtrAuthInfo; }
+  void setPointerAuthInfo(const CGPointerAuthInfo &Info) { PtrAuthInfo = Info; }
+
   // This function is called only in CGBuilderBaseTy::CreateElementBitCast.
   void setElementType(llvm::Type *Ty) {
     assert(hasOffset() &&
            "this funcion shouldn't be called when there is no offset");
     ElementType = Ty;
   }
 
-  /// Whether the pointer is known not to be null.
+  bool isSigned() const { return PtrAuthInfo.isSigned(); }
+
   KnownNonNull_t isKnownNonNull() const {
     assert(isValid());
     return (KnownNonNull_t)Pointer.getInt();
@@ -250,10 +264,15 @@ class Address {
 
   llvm::Value *getOffset() const { return Offset; }
 
+  Address getResignedAddress(const CGPointerAuthInfo &NewInfo,
+                             CodeGenFunction &CGF) const;
+
   /// Return the pointer contained in this class after authenticating it and
   /// adding offset to it if necessary.
   llvm::Value *emitRawPointer(CodeGenFunction &CGF) const {
-    return getUnsignedPointer();
+    if (!isSigned())
+      return getUnsignedPointer();
+    return emitRawPointerSlow(CGF);
   }
 
   /// Return address with different pointer, but same element type and
@@ -275,8 +294,8 @@ class Address {
   /// alignment.
   Address withElementType(llvm::Type *ElemTy) const {
     if (!hasOffset())
-      return Address(getBasePointer(), ElemTy, getAlignment(), nullptr,
-                     isKnownNonNull());
+      return Address(getBasePointer(), ElemTy, getAlignment(),
+                     getPointerAuthInfo(), nullptr, isKnownNonNull());
     Address A(*this);
     A.ElementType = ElemTy;
     return A;

clang/lib/CodeGen/CGBuilder.h

@@ -57,7 +57,10 @@ class CGBuilderTy : public CGBuilderBaseTy {
   CodeGenFunction *getCGF() const { return getInserter().CGF; }
 
   llvm::Value *emitRawPointerFromAddress(Address Addr) const {
-    return Addr.getUnsignedPointer();
+    if (!Addr.isSigned())
+      return Addr.getUnsignedPointer();
+    assert(getCGF() && "CGF not set");
+    return Addr.emitRawPointerSlow(*getCGF());
   }
 
   /// Helper function to compute a GEP's offset and add it to Addr.
@@ -208,8 +211,8 @@ class CGBuilderTy : public CGBuilderBaseTy {
                               const llvm::Twine &Name = "") {
     if (!Addr.hasOffset())
       return Address(CreateAddrSpaceCast(Addr.getBasePointer(), Ty, Name),
-                     ElementTy, Addr.getAlignment(), nullptr,
-                     Addr.isKnownNonNull());
+                     ElementTy, Addr.getAlignment(), Addr.getPointerAuthInfo(),
+                     nullptr, Addr.isKnownNonNull());
     // Eagerly force a raw address if these is an offset.
     return RawAddress(
         CreateAddrSpaceCast(Addr.emitRawPointer(*getCGF()), Ty, Name),
@@ -240,11 +243,14 @@ class CGBuilderTy : public CGBuilderBaseTy {
     const llvm::StructLayout *Layout = DL.getStructLayout(ElTy);
     auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
 
-    return Address(CreateStructGEP(Addr.getElementType(),
-                                   Addr.getUnsignedPointer(), Index, Name),
-                   ElTy->getElementType(Index),
-                   Addr.getAlignment().alignmentAtOffset(Offset),
-                   Addr.isKnownNonNull());
+    if (!Addr.isSigned())
+      return Address(CreateStructGEP(Addr.getElementType(),
+                                     Addr.getUnsignedPointer(), Index, Name),
+                     ElTy->getElementType(Index),
+                     Addr.getAlignment().alignmentAtOffset(Offset),
+                     Addr.isKnownNonNull());
+    Addr.addOffset(Offset, ElTy->getTypeAtIndex(Index), *this);
+    return Addr;
   }
 
   /// Given
@@ -262,12 +268,15 @@ class CGBuilderTy : public CGBuilderBaseTy {
     CharUnits EltSize =
         CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy->getElementType()));
 
-    return Address(
-        CreateInBoundsGEP(Addr.getElementType(), Addr.getUnsignedPointer(),
-                          {getSize(CharUnits::Zero()), getSize(Index)}, Name),
-        ElTy->getElementType(),
-        Addr.getAlignment().alignmentAtOffset(Index * EltSize),
-        Addr.isKnownNonNull());
+    if (!Addr.isSigned())
+      return Address(
+          CreateInBoundsGEP(Addr.getElementType(), Addr.getUnsignedPointer(),
+                            {getSize(CharUnits::Zero()), getSize(Index)}, Name),
+          ElTy->getElementType(),
+          Addr.getAlignment().alignmentAtOffset(Index * EltSize),
+          Addr.isKnownNonNull());
+    Addr.addOffset(Index * EltSize, ElTy, *this);
+    return Addr;
   }
 
   /// Given
@@ -281,10 +290,14 @@ class CGBuilderTy : public CGBuilderBaseTy {
     const llvm::DataLayout &DL = BB->getDataLayout();
     CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy));
 
-    return Address(CreateInBoundsGEP(ElTy, Addr.getUnsignedPointer(),
-                                     getSize(Index), Name),
-                   ElTy, Addr.getAlignment().alignmentAtOffset(Index * EltSize),
-                   Addr.isKnownNonNull());
+    if (!Addr.isSigned())
+      return Address(CreateInBoundsGEP(ElTy, Addr.getUnsignedPointer(),
+                                       getSize(Index), Name),
+                     ElTy,
+                     Addr.getAlignment().alignmentAtOffset(Index * EltSize),
+                     Addr.isKnownNonNull());
+    Addr.addOffset(Index * EltSize, ElTy, *this);
+    return Addr;
   }
 
   /// Given
@@ -298,10 +311,12 @@ class CGBuilderTy : public CGBuilderBaseTy {
     const llvm::DataLayout &DL = BB->getDataLayout();
     CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy));
 
-    return Address(
-        CreateGEP(ElTy, Addr.getUnsignedPointer(), getSize(Index), Name),
-        Addr.getElementType(),
-        Addr.getAlignment().alignmentAtOffset(Index * EltSize));
+    if (!Addr.isSigned())
+      return Address(
+          CreateGEP(ElTy, Addr.getUnsignedPointer(), getSize(Index), Name),
+          ElTy, Addr.getAlignment().alignmentAtOffset(Index * EltSize));
+    Addr.addOffset(Index * EltSize, ElTy, *this);
+    return Addr;
   }
 
   /// Create GEP with single dynamic index. The address alignment is reduced
@@ -323,21 +338,28 @@ class CGBuilderTy : public CGBuilderBaseTy {
   Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset,
                                      const llvm::Twine &Name = "") {
     assert(Addr.getElementType() == TypeCache.Int8Ty);
-    return Address(
-        CreateInBoundsGEP(Addr.getElementType(), Addr.getUnsignedPointer(),
-                          getSize(Offset), Name),
-        Addr.getElementType(), Addr.getAlignment().alignmentAtOffset(Offset),
-        Addr.isKnownNonNull());
+
+    if (!Addr.isSigned())
+      return Address(
+          CreateInBoundsGEP(Addr.getElementType(), Addr.getUnsignedPointer(),
+                            getSize(Offset), Name),
+          Addr.getElementType(), Addr.getAlignment().alignmentAtOffset(Offset),
+          Addr.isKnownNonNull());
+    Addr.addOffset(Offset, TypeCache.Int8Ty, *this);
+    return Addr;
   }
 
   Address CreateConstByteGEP(Address Addr, CharUnits Offset,
                              const llvm::Twine &Name = "") {
     assert(Addr.getElementType() == TypeCache.Int8Ty);
 
-    return Address(CreateGEP(Addr.getElementType(), Addr.getUnsignedPointer(),
-                             getSize(Offset), Name),
-                   Addr.getElementType(),
-                   Addr.getAlignment().alignmentAtOffset(Offset));
+    if (!Addr.isSigned())
+      return Address(CreateGEP(Addr.getElementType(), Addr.getUnsignedPointer(),
+                               getSize(Offset), Name),
+                     Addr.getElementType(),
+                     Addr.getAlignment().alignmentAtOffset(Offset));
+    Addr.addOffset(Offset, TypeCache.Int8Ty, *this);
+    return Addr;
   }
 
   using CGBuilderBaseTy::CreateConstInBoundsGEP2_32;
@@ -364,10 +386,12 @@ class CGBuilderTy : public CGBuilderBaseTy {
   Address CreateInBoundsGEP(Address Addr, ArrayRef<llvm::Value *> IdxList,
                             llvm::Type *ElementType, CharUnits Align,
                             const Twine &Name = "") {
-    return RawAddress(CreateInBoundsGEP(Addr.getElementType(),
-                                        emitRawPointerFromAddress(Addr),
-                                        IdxList, Name),
-                      ElementType, Align, Addr.isKnownNonNull());
+    if (!Addr.isSigned())
+      return RawAddress(CreateInBoundsGEP(Addr.getElementType(),
+                                          emitRawPointerFromAddress(Addr),
+                                          IdxList, Name),
+                        ElementType, Align, Addr.isKnownNonNull());
+    return addGEPOffset(Addr, IdxList, Align, true, Name);
   }
 
   using CGBuilderBaseTy::CreateIsNull;

clang/lib/CodeGen/CGBuiltin.cpp

@@ -2151,7 +2151,8 @@ RValue CodeGenFunction::emitBuiltinOSLogFormat(const CallExpr &E) {
 
   // Ignore argument 1, the format string. It is not currently used.
   CallArgList Args;
-  Args.add(RValue::get(BufAddr.emitRawPointer(*this)), Ctx.VoidPtrTy);
+  Args.add(RValue::get(getAsNaturalPointerTo(BufAddr, Ctx.VoidTy)),
+           Ctx.VoidPtrTy);
 
   for (const auto &Item : Layout.Items) {
     int Size = Item.getSizeByte();

clang/lib/CodeGen/CGCall.cpp

@@ -4135,8 +4135,8 @@ static bool isProvablyNull(llvm::Value *addr) {
 }
 
 static bool isProvablyNonNull(Address Addr, CodeGenFunction &CGF) {
-  return llvm::isKnownNonZero(Addr.getUnsignedPointer(),
-                              CGF.CGM.getDataLayout());
+  return !Addr.isSigned() && llvm::isKnownNonZero(Addr.getUnsignedPointer(),
+                                                  CGF.CGM.getDataLayout());
 }
 
 /// Emit the actual writing-back of a writeback.
@@ -5101,7 +5101,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
   llvm::Value *UnusedReturnSizePtr = nullptr;
   if (RetAI.isIndirect() || RetAI.isInAlloca() || RetAI.isCoerceAndExpand()) {
     if (!ReturnValue.isNull()) {
-      SRetPtr = ReturnValue.getAddress();
+      SRetPtr = ReturnValue.getValue();
     } else {
       SRetPtr = CreateMemTemp(RetTy, "tmp", &SRetAlloca);
       if (HaveInsertPoint() && ReturnValue.isUnused()) {

clang/lib/CodeGen/CGExpr.cpp

@@ -1311,7 +1311,8 @@ static Address EmitPointerWithAlignment(const Expr *E, LValueBaseInfo *BaseInfo,
         if (CE->getCastKind() == CK_AddressSpaceConversion)
           Addr = CGF.Builder.CreateAddrSpaceCast(
               Addr, CGF.ConvertType(E->getType()), ElemTy);
-        return Addr;
+        return CGF.AuthPointerToPointerCast(Addr, CE->getSubExpr()->getType(),
+                                            CE->getType());
       }
       break;
 
@@ -1785,8 +1786,11 @@ CodeGenFunction::tryEmitAsConstant(DeclRefExpr *refExpr) {
   }
 
   // Emit as a constant.
-  auto C = ConstantEmitter(*this).emitAbstract(refExpr->getLocation(),
-                                               result.Val, resultType);
+  // Try to emit as a constant.
+  llvm::Constant *C =
+      ConstantEmitter(*this).tryEmitAbstract(result.Val, resultType);
+  if (!C)
+    return ConstantEmission();
 
   // Make sure we emit a debug reference to the global variable.
   // This should probably fire even for

clang/lib/CodeGen/CGExprAgg.cpp

@@ -330,8 +330,8 @@ void AggExprEmitter::withReturnValueSlot(
   if (!UseTemp)
     return;
 
-  assert(Dest.isIgnored() || Dest.emitRawPointer(CGF) !=
-                                 Src.getAggregatePointer(E->getType(), CGF));
+  assert(Dest.getAddress().isSigned() || Dest.isIgnored() ||
+         Dest.emitRawPointer(CGF) != Src.getAggregatePointer(E->getType(), CGF));
   EmitFinalDestCopy(E->getType(), Src);
 
   if (!RequiresDestruction && LifetimeStartInst) {