[IR,AArch64] Add a new "ptrauth(...)" Constant to represent signed pointers

[t.p.northover]

Summary

This is a largeish change so I'm posting it together with an RFC on llvm-dev, where we should probably talk about the design related aspects. I'll put a link here when I post it but one had to come first.

This adds IR support (essentially bitcode roundtripping) for a new kind of Constant to represent an ARMv8.3 signed pointer. Its main use is to represent the kinds of signed pointers that can be represented in the MachO binary format (used for vtables etc), so it folds in functionality from @llvm.ptrauth.blend and @llvm.ptrauth.sign and that has guided the fields present.

[tschuett]

It might well be better to give up on intrinsic orthogonality and add one for this case though. It would simplify the changes to lib/IR etc.

If there is more gain then costs, I would go for it.
https://reviews.llvm.org/D90868 also seems to want to move sequences of operations
into a single intrinsic.

llvm/docs/LangRef.rst

 this can be used is for static offset calculations between a function and some other
 ``dso_local`` symbol. This is especially useful for the Relative VTables C++ ABI,
 where dynamic relocations for function pointers in VTables can be replaced with
 static relocations for offsets between the VTable and virtual functions which
 may not be ``dso_local``.
 
 This is currently only supported for ELF binary formats.
 
+.. _ptrauth
+
+Authenticated Pointers
+----------------------
+
+``ptrauth (TYPE1* CST, i32 KEY, TYPE2* ADDRDISC, i16 DISC)
+
+A '``ptrauth``' constant represents a pointer with a cryptographic
+authentication signature embedded into some bits. Its type is the same as the
+first argument.
+
+
+If the address disciminator is ``null`` then the expression is equivalent to
+
+.. code-block:llvm
+    %tmp = call i64 @llvm.ptrauth.sign.i64(i64 ptrtoint(TYPE1 *CST to i64), i32 KEY, i64 DISC)
+    %val = inttoptr i64 %tmp to TYPE1*
+
+If the address discriminator is present, then it is
+
+.. code-block:llvm
+    %tmp1 = call i64 @llvm.ptrauth.blend.i64(i64 ptrtoint(TYPE2* ADDRDISC to i64), i64 DISC)
+    %tmp2 = call i64 @llvm.ptrauth.sign.i64(i64 ptrtoint(TYPE1* CST to i64), i64  %tmp1)
+    %val = inttoptr i64 %tmp2 to TYPE1*
+
+    %tmp = call i64 @llvm.ptrauth.blend.i64
+
 .. _constantexprs:
 
 Constant Expressions
 --------------------
 
 Constant expressions are used to allow expressions involving other
 constants to be used as constants. Constant expressions may be of any
 :ref:`first class <t_firstclass>` type and may involve any LLVM operation

llvm/include/llvm-c/Core.h

typedef enum {
   LLVMConstantFPValueKind,
   LLVMConstantPointerNullValueKind,
   LLVMConstantTokenNoneValueKind,
 
   LLVMMetadataAsValueValueKind,
   LLVMInlineAsmValueKind,
 
   LLVMInstructionValueKind,
+  LLVMConstantPtrAuthValueKind,
 } LLVMValueKind;
 
 typedef enum {
   LLVMIntEQ = 32, /**< equal */
   LLVMIntNE,      /**< not equal */
   LLVMIntUGT,     /**< unsigned greater than */
   LLVMIntUGE,     /**< unsigned greater or equal */
   LLVMIntULT,     /**< unsigned less than */

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum ConstantsCodes {
   CST_CODE_CE_INBOUNDS_GEP = 20, // INBOUNDS_GEP:  [n x operands]
   CST_CODE_BLOCKADDRESS = 21,    // CST_CODE_BLOCKADDRESS [fnty, fnval, bb#]
   CST_CODE_DATA = 22,            // DATA:          [n x elements]
   CST_CODE_INLINEASM = 23,       // INLINEASM:     [sideeffect|alignstack|
                                  //                 asmdialect,asmstr,conststr]
   CST_CODE_CE_GEP_WITH_INRANGE_INDEX = 24, //      [opty, flags, n x operands]
   CST_CODE_CE_UNOP = 25,         // CE_UNOP:      [opcode, opval]
   CST_CODE_POISON = 26,          // POISON
+  CST_CODE_SIGNED_PTR = 27,      // CE_SIGNED_PTR: [ptrty, ptr, key,
+                                 //                 addrdiscty, addrdisc, disc]
 };
 
 /// CastOpcodes - These are values used in the bitcode files to encode which
 /// cast a CST_CODE_CE_CAST or a XXX refers to.  The values of these enums
 /// have no fixed relation to the LLVM IR enum values.  Changing these will
 /// break compatibility with old files.
 enum CastOpcodes {
   CAST_TRUNC = 0,

llvm/include/llvm/IR/AutoUpgrade.h

namespace llvm {
   /// This is an auto-upgrade hook for any old intrinsic function syntaxes
   /// which need to have both the function updated as well as all calls updated
   /// to the new function. This should only be run in a post-processing fashion
   /// so that it can update all calls to the old function.
   void UpgradeCallsToIntrinsic(Function* F);
 
   /// This checks for global variables which should be upgraded. It it requires
   /// upgrading, returns a pointer to the upgraded variable.
-  GlobalVariable *UpgradeGlobalVariable(GlobalVariable *GV);
+  bool UpgradeGlobalVariable(GlobalVariable *GV, GlobalVariable *&NewGV);
 
   /// This checks for module flags which should be upgraded. It returns true if
   /// module is modified.
   bool UpgradeModuleFlags(Module &M);
 
   /// Convert calls to ARC runtime functions to intrinsic calls and upgrade the
   /// old retain release marker to new module flag format.
   void UpgradeARCRuntime(Module &M);

llvm/include/llvm/IR/Constants.h

 };
 
 template <>
 struct OperandTraits<DSOLocalEquivalent>
     : public FixedNumOperandTraits<DSOLocalEquivalent, 1> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(DSOLocalEquivalent, Value)
 
+/// A signed pointer
+///
+class ConstantPtrAuth final : public Constant {
+  friend struct ConstantPtrAuthKeyType;
+  friend class Constant;
+
+  ConstantPtrAuth(Constant *Ptr, ConstantInt *Key, Constant *AddrDisc,
+                  ConstantInt *Disc);
+
+  void *operator new(size_t s) { return User::operator new(s, 4); }
+
+  void destroyConstantImpl();
+  Value *handleOperandChangeImpl(Value *From, Value *To);
+
+public:
+  /// Return a pointer authenticated with the specified parameters.
+  static ConstantPtrAuth *get(Constant *Ptr, ConstantInt *Key,
+                              Constant *AddrDisc, ConstantInt *Disc);
+
+  /// Produce a new ptrauth expression signing the given value using
+  /// the same schema as is stored in one.
+  ConstantPtrAuth *getWithSameSchema(Constant *Pointer) const;
+
+  /// Transparently provide more efficient getOperand methods.
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Constant);
+
+  /// The pointer that is authenticated in this authenticated global reference.
+  Constant *getPointer() const { return (Constant *)Op<0>().get(); }
+
+  /// The Key ID, an i32 constant.
+  ConstantInt *getKey() const { return (ConstantInt *)Op<1>().get(); }
+
+  /// The address discriminator if any, or the null constant.
+  /// If present, this must be a value equivalent to the storage location of
+  /// the only user of the authenticated ptrauth global.
+  Constant *getAddrDiscriminator() const { return (Constant *)Op<2>().get(); }
+
+  /// The discriminator.
+  ConstantInt *getDiscriminator() const { return (ConstantInt *)Op<3>().get(); }
+
+  /// Whether there is any non-null address discriminator.
+  bool hasAddressDiversity() const {
+    return !getAddrDiscriminator()->isNullValue();
+  }
+
+  /// Whether the address uses a special address discriminator.
+  /// These discriminators can't be used in real pointer-auth values; they
+  /// can only be used in "prototype" values that indicate how some real
+  /// schema is supposed to be produced.
+  bool hasSpecialAddressDiscriminator(uint64_t value) const;
+
+  /// Check whether an authentication operation with key \p KeyV and (possibly
+  /// blended) discriminator \p DiscriminatorV is compatible with this
+  /// authenticated global reference.
+  bool isCompatibleWith(const Value *Key, const Value *Discriminator,
+                        const DataLayout &DL) const;
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const Value *V) {
+    return V->getValueID() == ConstantPtrAuthVal;
+  }
+};
+
+template <>
+struct OperandTraits<ConstantPtrAuth>
+    : public FixedNumOperandTraits<ConstantPtrAuth, 4> {};
+
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantPtrAuth, Constant)
+
 //===----------------------------------------------------------------------===//
 /// A constant value that is initialized with an expression using
 /// other constant values.
 ///
 /// This class uses the standard Instruction opcodes to define the various
 /// constant expressions.  The Opcode field for the ConstantExpr class is
 /// maintained in the Value::SubclassData field.
 class ConstantExpr : public Constant {

llvm/include/llvm/IR/Value.def

 // and smaller by one operation.
 
 // Constant
 HANDLE_GLOBAL_VALUE(Function)
 HANDLE_GLOBAL_VALUE(GlobalAlias)
 HANDLE_GLOBAL_VALUE(GlobalIFunc)
 HANDLE_GLOBAL_VALUE(GlobalVariable)
 HANDLE_CONSTANT(BlockAddress)
+HANDLE_CONSTANT(ConstantPtrAuth)
 HANDLE_CONSTANT(ConstantExpr)
 HANDLE_CONSTANT_EXCLUDE_LLVM_C_API(DSOLocalEquivalent)
 
 // ConstantAggregate.
 HANDLE_CONSTANT(ConstantArray)
 HANDLE_CONSTANT(ConstantStruct)
 HANDLE_CONSTANT(ConstantVector)
 

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
 
   KEYWORD(xchg); KEYWORD(nand); KEYWORD(max); KEYWORD(min); KEYWORD(umax);
   KEYWORD(umin);
 
   KEYWORD(vscale);
   KEYWORD(x);
   KEYWORD(blockaddress);
   KEYWORD(dso_local_equivalent);
+  KEYWORD(ptrauth);
 
   // Metadata types.
   KEYWORD(distinct);
 
   // Use-list order directives.
   KEYWORD(uselistorder);
   KEYWORD(uselistorder_bb);
 

llvm/lib/AsmParser/LLParser.cpp

case lltok::kw_dso_local_equivalent: {
     if (!GV->getValueType()->isFunctionTy())
       return error(Fn.Loc, "expected a function, alias to function, or ifunc "
                            "in dso_local_equivalent");
 
     ID.ConstantVal = DSOLocalEquivalent::get(GV);
     ID.Kind = ValID::t_Constant;
     return false;
   }
+  case lltok::kw_ptrauth: {
+    // ValID ::= 'ptrauth' '(' <ty>* @foo ',' i32 <key> ','
+    //                         <ty2>* addrdisc ',' i16 <disc> ')'
+    Lex.Lex();
+
+    Constant *Ptr, *Key, *AddrDisc, *Disc;
+
+    if (parseToken(lltok::lparen,
+                   "expected '(' in signed pointer expression") ||
+        parseGlobalTypeAndValue(Ptr) ||
+        parseToken(lltok::comma,
+                   "expected comma in signed pointer expression") ||
+        parseGlobalTypeAndValue(Key) ||
+        parseToken(lltok::comma,
+                   "expected comma in signed pointer expression") ||
+        parseGlobalTypeAndValue(AddrDisc) ||
+        parseToken(lltok::comma,
+                   "expected comma in signed pointer expression") ||
+        parseGlobalTypeAndValue(Disc) ||
+        parseToken(lltok::rparen, "expected ')' in signed pointer expression"))
+      return true;
+
+    if (!Ptr->getType()->isPointerTy())
+      return error(ID.Loc, "signed pointer must be a pointer");
+
+    auto KeyC = dyn_cast<ConstantInt>(Key);
+    if (!KeyC || KeyC->getBitWidth() != 32)
+      return error(ID.Loc, "signed pointer key must be i32 constant integer");
+
+    if (!AddrDisc->getType()->isPointerTy())
+      return error(ID.Loc,
+                   "signed pointer address discriminator must be a pointer");
+
+    auto DiscC = dyn_cast<ConstantInt>(Disc);
+    if (!DiscC || DiscC->getBitWidth() != 16)
+      return error(ID.Loc,
+                   "signed pointer discriminator must be i16 constant integer");
+
+    ID.ConstantVal = ConstantPtrAuth::get(Ptr, KeyC, AddrDisc, DiscC);
+    ID.Kind = ValID::t_Constant;
+    return false;
+  }
 
   case lltok::kw_trunc:
   case lltok::kw_zext:
   case lltok::kw_sext:
   case lltok::kw_fptrunc:
   case lltok::kw_fpext:
   case lltok::kw_bitcast:
   case lltok::kw_addrspacecast:

llvm/lib/AsmParser/LLToken.h

enum Kind {
   kw_extractelement,
   kw_insertelement,
   kw_shufflevector,
   kw_extractvalue,
   kw_insertvalue,
   kw_blockaddress,
   kw_dso_local_equivalent,
 
+  kw_ptrauth,
+
   kw_freeze,
 
   // Metadata types.
   kw_distinct,
 
   // Use-list order directives.
   kw_uselistorder,
   kw_uselistorder_bb,

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::CST_CODE_BLOCKADDRESS:{
           FwdBBs.resize(BBID + 1);
         if (!FwdBBs[BBID])
           FwdBBs[BBID] = BasicBlock::Create(Context);
         BB = FwdBBs[BBID];
       }
       V = BlockAddress::get(Fn, BB);
       break;
     }
+    case bitc::CST_CODE_SIGNED_PTR: {
+      if (Record.size() < 6)
+        return error("Invalid record");
+      Type *PtrTy = getTypeByID(Record[0]);
+      if (!PtrTy)
+        return error("Invalid record");
+      Constant *Ptr = ValueList.getConstantFwdRef(Record[1], PtrTy);
+      if (!Ptr)
+        return error("Invalid record");
+
+      Type *AddrDiscTy = getTypeByID(Record[3]);
+      if (!PtrTy)
+        return error("Invalid record");
+      Constant *AddrDisc = ValueList.getConstantFwdRef(Record[4], AddrDiscTy);
+      if (!AddrDisc)
+        return error("Invalid record");
+
+      auto *Key = ConstantInt::get(Type::getInt32Ty(Context), Record[2]);
+      auto *Disc = ConstantInt::get(Type::getInt16Ty(Context), Record[5]);
+      V = ConstantPtrAuth::get(Ptr, Key, AddrDisc, Disc);
+      break;
+    }
     }
 
     assert(V->getType() == flattenPointerTypes(CurFullTy) &&
            "Incorrect fully structured type provided for Constant");
     ValueList.assignValue(V, NextCstNo, CurFullTy);
     ++NextCstNo;
   }
 }
else if (auto Remangled = Intrinsic::remangleIntrinsicFunction(&F))
       // remangle intrinsics names as well.
       RemangledIntrinsics[&F] = Remangled.getValue();
     // Look for functions that rely on old function attribute behavior.
     UpgradeFunctionAttributes(F);
   }
 
   // Look for global variables which need to be renamed.
   std::vector<std::pair<GlobalVariable *, GlobalVariable *>> UpgradedVariables;
-  for (GlobalVariable &GV : TheModule->globals())
-    if (GlobalVariable *Upgraded = UpgradeGlobalVariable(&GV))
+  for (GlobalVariable &GV : TheModule->globals()) {
+    GlobalVariable *Upgraded = nullptr;
+    if (UpgradeGlobalVariable(&GV, Upgraded))
       UpgradedVariables.emplace_back(&GV, Upgraded);
+  }
   for (auto &Pair : UpgradedVariables) {
     Pair.first->eraseFromParent();
+    if (Pair.second)
       TheModule->getGlobalList().push_back(Pair.second);
   }
 
   // Force deallocation of memory for these vectors to favor the client that
   // want lazy deserialization.
   std::vector<std::pair<GlobalVariable *, unsigned>>().swap(GlobalInits);
   std::vector<std::pair<GlobalIndirectSymbol *, unsigned>>().swap(
       IndirectSymbolInits);
   return Error::success();

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

if (C->isNullValue()) {
         Record.push_back(CE->getPredicate());
         break;
       }
     } else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
       Code = bitc::CST_CODE_BLOCKADDRESS;
       Record.push_back(VE.getTypeID(BA->getFunction()->getType()));
       Record.push_back(VE.getValueID(BA->getFunction()));
       Record.push_back(VE.getGlobalBasicBlockID(BA->getBasicBlock()));
+    } else if (const ConstantPtrAuth *SP = dyn_cast<ConstantPtrAuth>(C)) {
+      Code = bitc::CST_CODE_SIGNED_PTR;
+      Record.push_back(VE.getTypeID(SP->getPointer()->getType()));
+      Record.push_back(VE.getValueID(SP->getPointer()));
+      Record.push_back(SP->getKey()->getZExtValue());
+      Record.push_back(VE.getTypeID(SP->getAddrDiscriminator()->getType()));
+      Record.push_back(VE.getValueID(SP->getAddrDiscriminator()));
+      Record.push_back(SP->getDiscriminator()->getZExtValue());
     } else {
 #ifndef NDEBUG
       C->dump();
 #endif
       llvm_unreachable("Unknown constant!");
     }
     Stream.EmitRecord(Code, Record, AbbrevToUse);
     Record.clear();

llvm/lib/IR/AsmWriter.cpp

static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
 
   if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV)) {
     Out << "dso_local_equivalent ";
     WriteAsOperandInternal(Out, Equiv->getGlobalValue(), &TypePrinter, Machine,
                            Context);
     return;
   }
 
+  if (const ConstantPtrAuth *SP = dyn_cast<ConstantPtrAuth>(CV)) {
+    Out << "ptrauth (";
+
+    for (unsigned i = 0; i < SP->getNumOperands(); ++i) {
+      TypePrinter.print(SP->getOperand(i)->getType(), Out);
+      Out << ' ';
+      WriteAsOperandInternal(Out, SP->getOperand(i), &TypePrinter, Machine,
+                             Context);
+      if (i != SP->getNumOperands() - 1)
+        Out << ", ";
+    }
+
+    Out << ')';
+    return;
+  }
+
   if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
     Type *ETy = CA->getType()->getElementType();
     Out << '[';
     TypePrinter.print(ETy, Out);
     Out << ' ';
     WriteAsOperandInternal(Out, CA->getOperand(0),
                            &TypePrinter, Machine,
                            Context);

llvm/lib/IR/AutoUpgrade.cpp

bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
   // Upgrade intrinsic attributes.  This does not change the function.
   if (NewFn)
     F = NewFn;
   if (Intrinsic::ID id = F->getIntrinsicID())
     F->setAttributes(Intrinsic::getAttributes(F->getContext(), id));
   return Upgraded;
 }
 
-GlobalVariable *llvm::UpgradeGlobalVariable(GlobalVariable *GV) {
+bool llvm::UpgradeGlobalVariable(GlobalVariable *GV, GlobalVariable *&NewGV) {
+  if (GV->getSection() == "llvm.ptrauth") {
+    auto &Ctx = GV->getContext();
+
+    if (!GV->hasInitializer())
+      return false;
+
+    auto *Init = GV->getInitializer();
+    auto *Ty = dyn_cast<StructType>(GV->getInitializer()->getType());
+    if (!Ty)
+      return false;
+
+    auto *I64Ty = Type::getInt64Ty(Ctx);
+    auto *I32Ty = Type::getInt32Ty(Ctx);
+    auto *P0I8Ty = Type::getInt8PtrTy(Ctx);
+    // Check that the struct matches its expected shape:
+    //   { i8*, i32, i64, i64 }
+    if (!Ty->isLayoutIdentical(
+            StructType::get(Ctx, {P0I8Ty, I32Ty, I64Ty, I64Ty})))
+      return false;
+
+    auto Pointer = cast<Constant>(Init->getOperand(0));
+    Pointer = Pointer->stripPointerCasts();
+
+    auto *Key = dyn_cast<ConstantInt>(Init->getOperand(1));
+    if (!Key)
+      return false;
+
+    auto *AddrDiscriminator = cast<Constant>(Init->getOperand(2));
+    if (!isa<ConstantInt>(AddrDiscriminator) &&
+        !isa<ConstantExpr>(AddrDiscriminator))
+      return false;
+
+    auto *Discriminator = dyn_cast<ConstantInt>(Init->getOperand(3));
+    if (!Discriminator)
+      return false;
+
+    auto *I16Ty = Type::getInt16Ty(Ctx);
+    AddrDiscriminator = ConstantExpr::getIntToPtr(AddrDiscriminator, P0I8Ty);
+    Discriminator = ConstantInt::get(I16Ty, Discriminator->getZExtValue());
+    auto *SP =
+        ConstantPtrAuth::get(Pointer, Key, AddrDiscriminator, Discriminator);
+
+    GV->replaceAllUsesWith(ConstantExpr::getBitCast(SP, GV->getType()));
+    return true;
+  }
+
   if (!(GV->hasName() && (GV->getName() == "llvm.global_ctors" ||
                           GV->getName() == "llvm.global_dtors")) ||
       !GV->hasInitializer())
-    return nullptr;
+    return false;
   ArrayType *ATy = dyn_cast<ArrayType>(GV->getValueType());
   if (!ATy)
-    return nullptr;
+    return false;
   StructType *STy = dyn_cast<StructType>(ATy->getElementType());
   if (!STy || STy->getNumElements() != 2)
-    return nullptr;
+    return false;
 
   LLVMContext &C = GV->getContext();
   IRBuilder<> IRB(C);
   auto EltTy = StructType::get(STy->getElementType(0), STy->getElementType(1),
                                IRB.getInt8PtrTy());
   Constant *Init = GV->getInitializer();
   unsigned N = Init->getNumOperands();
   std::vector<Constant *> NewCtors(N);
   for (unsigned i = 0; i != N; ++i) {
     auto Ctor = cast<Constant>(Init->getOperand(i));
     NewCtors[i] = ConstantStruct::get(
         EltTy, Ctor->getAggregateElement(0u), Ctor->getAggregateElement(1),
         Constant::getNullValue(IRB.getInt8PtrTy()));
   }
   Constant *NewInit = ConstantArray::get(ArrayType::get(EltTy, N), NewCtors);
 
-  return new GlobalVariable(NewInit->getType(), false, GV->getLinkage(),
+  NewGV = new GlobalVariable(NewInit->getType(), false, GV->getLinkage(),
                              NewInit, GV->getName());
+  return true;
 }
 
 // Handles upgrading SSE2/AVX2/AVX512BW PSLLDQ intrinsics by converting them
 // to byte shuffles.
 static Value *UpgradeX86PSLLDQIntrinsics(IRBuilder<> &Builder,
                                          Value *Op, unsigned Shift) {
   auto *ResultTy = cast<FixedVectorType>(Op->getType());
   unsigned NumElts = ResultTy->getNumElements() * 8;

llvm/lib/IR/ConstantFold.cpp

 ///
 static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2,
                                                 bool isSigned) {
   assert(V1->getType() == V2->getType() &&
          "Cannot compare different types of values!");
   if (V1 == V2) return ICmpInst::ICMP_EQ;
 
   if (!isa<ConstantExpr>(V1) && !isa<GlobalValue>(V1) &&
-      !isa<BlockAddress>(V1)) {
+      !isa<BlockAddress>(V1) && !isa<ConstantPtrAuth>(V1)) {
     if (!isa<GlobalValue>(V2) && !isa<ConstantExpr>(V2) &&
-        !isa<BlockAddress>(V2)) {
+        !isa<BlockAddress>(V2) && !isa<ConstantPtrAuth>(V2)) {
       // We distilled this down to a simple case, use the standard constant
       // folder.
       ConstantInt *R = nullptr;
       ICmpInst::Predicate pred = ICmpInst::ICMP_EQ;
       R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
       if (R && !R->isZero())
         return pred;
       pred = isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
if (const BlockAddress *BA2 = dyn_cast<BlockAddress>(V2)) {
       if (BA2->getFunction() != BA->getFunction())
         return ICmpInst::ICMP_NE;
     } else {
       // Block addresses aren't null, don't equal the address of globals.
       assert((isa<ConstantPointerNull>(V2) || isa<GlobalValue>(V2)) &&
              "Canonicalization guarantee!");
       return ICmpInst::ICMP_NE;
     }
+  } else if (const ConstantPtrAuth *SP = dyn_cast<ConstantPtrAuth>(V1)) {
+    return ICmpInst::BAD_ICMP_PREDICATE;
   } else {
     // Ok, the LHS is known to be a constantexpr.  The RHS can be any of a
     // constantexpr, a global, block address, or a simple constant.
     ConstantExpr *CE1 = cast<ConstantExpr>(V1);
     Constant *CE1Op0 = CE1->getOperand(0);
 
     switch (CE1->getOpcode()) {
     case Instruction::Trunc:

llvm/lib/IR/Constants.cpp

case Constant::ConstantTokenNoneVal:
     delete static_cast<ConstantTokenNone *>(C);
     break;
   case Constant::BlockAddressVal:
     delete static_cast<BlockAddress *>(C);
     break;
   case Constant::DSOLocalEquivalentVal:
     delete static_cast<DSOLocalEquivalent *>(C);
     break;
+  case Constant::ConstantPtrAuthVal:
+    delete static_cast<ConstantPtrAuth *>(C);
+    break;
   case Constant::UndefValueVal:
     delete static_cast<UndefValue *>(C);
     break;
   case Constant::PoisonValueVal:
     delete static_cast<PoisonValue *>(C);
     break;
   case Constant::ConstantExprVal:
     if (isa<UnaryConstantExpr>(C))
Value *DSOLocalEquivalent::handleOperandChangeImpl(Value *From, Value *To) {
 
   // Replace this with the new one.
   getContext().pImpl->DSOLocalEquivalents.erase(getGlobalValue());
   NewEquiv = this;
   setOperand(0, Func);
   return nullptr;
 }
 
+//---- ConstantPtrAuth::get() implementations.
+//
+
+static bool areEquivalentAddrDiscriminators(const Value *V1, const Value *V2,
+                                            const DataLayout &DL) {
+  APInt V1Off(DL.getPointerSizeInBits(), 0);
+  APInt V2Off(DL.getPointerSizeInBits(), 0);
+
+  if (auto *V1Cast = dyn_cast<PtrToIntOperator>(V1))
+    V1 = V1Cast->getPointerOperand();
+  if (auto *V2Cast = dyn_cast<PtrToIntOperator>(V2))
+    V2 = V2Cast->getPointerOperand();
+  auto *V1Base = V1->stripAndAccumulateConstantOffsets(
+      DL, V1Off, /*AllowNonInbounds=*/true);
+  auto *V2Base = V2->stripAndAccumulateConstantOffsets(
+      DL, V2Off, /*AllowNonInbounds=*/true);
+  return V1Base == V2Base && V1Off == V2Off;
+}
+
+static bool areEquivalentDiscriminators(const ConstantInt *D1,
+                                        const Value *D2) {
+  if (auto D2C = dyn_cast<ConstantInt>(D2))
+    return D2C->getZExtValue() == D1->getZExtValue();
+  return false;
+}
+
+bool ConstantPtrAuth::isCompatibleWith(const Value *Key,
+                                       const Value *Discriminator,
+                                       const DataLayout &DL) const {
+  // If the keys are different, there's no chance for this to be compatible.
+  if (Key != getKey())
+    return false;
+
+  // If the discriminators are the same, this is compatible iff there is no
+  // address discriminator.
+  if (areEquivalentDiscriminators(getDiscriminator(), Discriminator))
+    return getAddrDiscriminator()->isNullValue();
+
+  // If we don't have a non-address discriminator, we don't need a blend in
+  // the first place:  accept the address discriminator as the discriminator.
+  if (getDiscriminator()->isNullValue() &&
+      areEquivalentAddrDiscriminators(getAddrDiscriminator(), Discriminator,
+                                      DL))
+    return true;
+
+  // Otherwise, we don't know.
+  return false;
+}
+
+bool ConstantPtrAuth::hasSpecialAddressDiscriminator(uint64_t value) const {
+  auto *CastV = dyn_cast<ConstantExpr>(getAddrDiscriminator());
+  if (!CastV || CastV->getOpcode() != Instruction::IntToPtr)
+    return false;
+
+  auto IntVal = dyn_cast<ConstantInt>(CastV->getOperand(0));
+  if (!IntVal)
+    return false;
+
+  return IntVal->getValue() == value;
+}
+
+ConstantPtrAuth *ConstantPtrAuth::getWithSameSchema(Constant *Pointer) const {
+  return get(Pointer, getKey(), getAddrDiscriminator(), getDiscriminator());
+}
+
+ConstantPtrAuth *ConstantPtrAuth::get(Constant *Ptr, ConstantInt *Key,
+                                      Constant *AddrDisc, ConstantInt *Disc) {
+  Constant *ArgVec[] = {Ptr, Key, AddrDisc, Disc};
+  ConstantPtrAuthKeyType MapKey(ArgVec);
+  LLVMContextImpl *pImpl = Ptr->getContext().pImpl;
+  return pImpl->ConstantPtrAuths.getOrCreate(Ptr->getType(), MapKey);
+}
+
+ConstantPtrAuth::ConstantPtrAuth(Constant *Ptr, ConstantInt *Key,
+                                 Constant *AddrDisc, ConstantInt *Disc)
+    : Constant(Ptr->getType(), Value::ConstantPtrAuthVal, &Op<0>(), 4) {
+#ifndef NDEBUG
+  assert(Ptr->getType()->isPointerTy());
+  assert(Key->getBitWidth() == 32);
+  assert(AddrDisc->getType()->isPointerTy());
+  assert(Disc->getBitWidth() == 16);
+#endif
+  setOperand(0, Ptr);
+  setOperand(1, Key);
+  setOperand(2, AddrDisc);
+  setOperand(3, Disc);
+}
+
+/// Remove the constant from the constant table.
+void ConstantPtrAuth::destroyConstantImpl() {
+  getType()->getContext().pImpl->ConstantPtrAuths.remove(this);
+}
+
+Value *ConstantPtrAuth::handleOperandChangeImpl(Value *From, Value *ToV) {
+  assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!");
+  Constant *To = cast<Constant>(ToV);
+
+  SmallVector<Constant *, 8> Values;
+  Values.reserve(getNumOperands()); // Build replacement array.
+
+  // Fill values with the modified operands of the constant array.  Also,
+  // compute whether this turns into an all-zeros array.
+  unsigned NumUpdated = 0;
+
+  Use *OperandList = getOperandList();
+  unsigned OperandNo = 0;
+  for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O) {
+    Constant *Val = cast<Constant>(O->get());
+    if (Val == From) {
+      OperandNo = (O - OperandList);
+      Val = To;
+      ++NumUpdated;
+    }
+    Values.push_back(Val);
+  }
+
+  // FIXME: shouldn't we check it's not already there?
+  return getContext().pImpl->ConstantPtrAuths.replaceOperandsInPlace(
+      Values, this, From, To, NumUpdated, OperandNo);
+}
+
 //---- ConstantExpr::get() implementations.
 //
 
 /// This is a utility function to handle folding of casts and lookup of the
 /// cast in the ExprConstants map. It is used by the various get* methods below.
 static Constant *getFoldedCast(Instruction::CastOps opc, Constant *C, Type *Ty,
                                bool OnlyIfReduced = false) {
   assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!");

llvm/lib/IR/ConstantsContext.h

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"

 template <>
 struct OperandTraits<CompareConstantExpr>
     : public FixedNumOperandTraits<CompareConstantExpr, 2> {};
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CompareConstantExpr, Value)
 
 template <class ConstantClass> struct ConstantAggrKeyType;
 struct InlineAsmKeyType;
 struct ConstantExprKeyType;
+struct ConstantPtrAuthKeyType;
 
 template <class ConstantClass> struct ConstantInfo;
 template <> struct ConstantInfo<ConstantExpr> {
   using ValType = ConstantExprKeyType;
   using TypeClass = Type;
 };
 template <> struct ConstantInfo<InlineAsm> {
   using ValType = InlineAsmKeyType;
   using TypeClass = PointerType;
 };
 template <> struct ConstantInfo<ConstantArray> {
   using ValType = ConstantAggrKeyType<ConstantArray>;
   using TypeClass = ArrayType;
 };
 template <> struct ConstantInfo<ConstantStruct> {
   using ValType = ConstantAggrKeyType<ConstantStruct>;
   using TypeClass = StructType;
 };
 template <> struct ConstantInfo<ConstantVector> {
   using ValType = ConstantAggrKeyType<ConstantVector>;
   using TypeClass = VectorType;
 };
+template <> struct ConstantInfo<ConstantPtrAuth> {
+  using ValType = ConstantPtrAuthKeyType;
+  using TypeClass = Type;
+};
 
 template <class ConstantClass> struct ConstantAggrKeyType {
   ArrayRef<Constant *> Operands;
 
   ConstantAggrKeyType(ArrayRef<Constant *> Operands) : Operands(Operands) {}
 
   ConstantAggrKeyType(ArrayRef<Constant *> Operands, const ConstantClass *)
       : Operands(Operands) {}
case Instruction::ICmp:
                                      Ops[0], Ops[1]);
     case Instruction::FCmp:
       return new CompareConstantExpr(Ty, Instruction::FCmp, SubclassData,
                                      Ops[0], Ops[1]);
     }
   }
 };
 
+struct ConstantPtrAuthKeyType {
+  ArrayRef<Constant *> Operands;
+
+  ConstantPtrAuthKeyType(ArrayRef<Constant *> Operands) : Operands(Operands) {}
+
+  ConstantPtrAuthKeyType(ArrayRef<Constant *> Operands, const ConstantPtrAuth *)
+      : Operands(Operands) {}
+
+  ConstantPtrAuthKeyType(const ConstantPtrAuth *C,
+                         SmallVectorImpl<Constant *> &Storage) {
+    assert(Storage.empty() && "Expected empty storage");
+    for (unsigned I = 0, E = C->getNumOperands(); I != E; ++I)
+      Storage.push_back(cast<Constant>(C->getOperand(I)));
+    Operands = Storage;
+  }
+
+  bool operator==(const ConstantPtrAuthKeyType &X) const {
+    return Operands == X.Operands;
+  }
+
+  bool operator==(const ConstantPtrAuth *C) const {
+    if (Operands.size() != C->getNumOperands())
+      return false;
+    for (unsigned I = 0, E = Operands.size(); I != E; ++I)
+      if (Operands[I] != C->getOperand(I))
+        return false;
+    return true;
+  }
+
+  unsigned getHash() const {
+    return hash_combine_range(Operands.begin(), Operands.end());
+  }
+
+  using TypeClass = typename ConstantInfo<ConstantPtrAuth>::TypeClass;
+
+  ConstantPtrAuth *create(TypeClass *Ty) const {
+    return new ConstantPtrAuth(Operands[0], cast<ConstantInt>(Operands[1]),
+                               Operands[2], cast<ConstantInt>(Operands[3]));
+  }
+};
+
 // Free memory for a given constant.  Assumes the constant has already been
 // removed from all relevant maps.
 void deleteConstant(Constant *C);
 
 template <class ConstantClass> class ConstantUniqueMap {
 public:
   using ValType = typename ConstantInfo<ConstantClass>::ValType;
   using TypeClass = typename ConstantInfo<ConstantClass>::TypeClass;

llvm/lib/IR/LLVMContextImpl.h

#include "llvm/IR/Metadata.def"
 
   StringMap<std::unique_ptr<ConstantDataSequential>> CDSConstants;
 
   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
     BlockAddresses;
 
   DenseMap<const GlobalValue *, DSOLocalEquivalent *> DSOLocalEquivalents;
 
+  ConstantUniqueMap<ConstantPtrAuth> ConstantPtrAuths;
+
   ConstantUniqueMap<ConstantExpr> ExprConstants;
 
   ConstantUniqueMap<InlineAsm> InlineAsms;
 
   ConstantInt *TheTrueVal = nullptr;
   ConstantInt *TheFalseVal = nullptr;
 
   std::unique_ptr<ConstantTokenNone> TheNoneToken;

llvm/lib/IR/Verifier.cpp

void verifyAttributeTypes(AttributeSet Attrs, bool IsFunction,
                             const Value *V);
   void verifyParameterAttrs(AttributeSet Attrs, Type *Ty, const Value *V);
   void verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
                            const Value *V, bool IsIntrinsic);
   void verifyFunctionMetadata(ArrayRef<std::pair<unsigned, MDNode *>> MDs);
 
   void visitConstantExprsRecursively(const Constant *EntryC);
   void visitConstantExpr(const ConstantExpr *CE);
+  void visitConstantPtrAuth(const ConstantPtrAuth *SP);
   void verifyStatepoint(const CallBase &Call);
   void verifyFrameRecoverIndices();
   void verifySiblingFuncletUnwinds();
 
   void verifyFragmentExpression(const DbgVariableIntrinsic &I);
   template <typename ValueOrMetadata>
   void verifyFragmentExpression(const DIVariable &V,
                                 DIExpression::FragmentInfo Fragment,
void Verifier::visitConstantExprsRecursively(const Constant *EntryC) {
 
   while (!Stack.empty()) {
     const Constant *C = Stack.pop_back_val();
 
     // Check this constant expression.
     if (const auto *CE = dyn_cast<ConstantExpr>(C))
       visitConstantExpr(CE);
 
+    if (const auto *SP = dyn_cast<ConstantPtrAuth>(C))
+      visitConstantPtrAuth(SP);
+
     if (const auto *GV = dyn_cast<GlobalValue>(C)) {
       // Global Values get visited separately, but we do need to make sure
       // that the global value is in the correct module
       Assert(GV->getParent() == &M, "Referencing global in another module!",
              EntryC, &M, GV, GV->getParent());
       continue;
     }
 
StringRef Msg = CE->getOpcode() == Instruction::IntToPtr
                         ? "inttoptr not supported for non-integral pointers"
                         : "ptrtoint not supported for non-integral pointers";
     Assert(
         !DL.isNonIntegralPointerType(cast<PointerType>(PtrTy->getScalarType())),
         Msg);
   }
 }
 
+void Verifier::visitConstantPtrAuth(const ConstantPtrAuth *SP) {
+  Assert(SP->getPointer()->getType()->isPointerTy(),
+         "signed pointer must be a pointer");
+
+  Assert(SP->getKey()->getBitWidth() == 32,
+         "signed pointer key must be i32 constant integer");
+
+  Assert(SP->getAddrDiscriminator()->getType()->isPointerTy(),
+         "signed pointer address discriminator must be a pointer");
+
+  Assert(SP->getDiscriminator()->getBitWidth() == 16,
+         "signed pointer discriminator must be i16 constant integer");
+}
+
 bool Verifier::verifyAttributeCount(AttributeList Attrs, unsigned Params) {
   // There shouldn't be more attribute sets than there are parameters plus the
   // function and return value.
   return Attrs.getNumAttrSets() <= Params + 2;
 }
 
 /// Verify that statepoint intrinsic is well formed.
 void Verifier::verifyStatepoint(const CallBase &Call) {
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
     } else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) {
       Assert(GV->getParent() == &M, "Referencing global in another module!", &I,
              &M, GV, GV->getParent());
     } else if (isa<Instruction>(I.getOperand(i))) {
       verifyDominatesUse(I, i);
     } else if (isa<InlineAsm>(I.getOperand(i))) {
       Assert(CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i),
              "Cannot take the address of an inline asm!", &I);
+    } else if (auto SP = dyn_cast<ConstantPtrAuth>(I.getOperand(i))) {
+      visitConstantExprsRecursively(SP);
     } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i))) {
       if (CE->getType()->isPtrOrPtrVectorTy() ||
           !DL.getNonIntegralAddressSpaces().empty()) {
         // If we have a ConstantExpr pointer, we need to see if it came from an
         // illegal bitcast.  If the datalayout string specifies non-integral
         // address spaces then we also need to check for illegal ptrtoint and
         // inttoptr expressions.
         visitConstantExprsRecursively(CE);

llvm/test/Assembler/invalid-ptrauth-const1.ll

+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+
+@var = global i32 0
+
+; CHECK: error: signed pointer must be a pointer
+@auth_var = global i32* ptrauth (i32 42, i32 0, i8* null, i16 65535)

llvm/test/Assembler/invalid-ptrauth-const2.ll

+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+
+@var = global i32 0
+
+; CHECK: error: signed pointer key must be i32 constant integer
+@auth_var = global i32* ptrauth (i32* @var, i32 ptrtoint(i32* @var to i32), i8* null, i16 65535)

llvm/test/Assembler/invalid-ptrauth-const3.ll

+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+
+@var = global i32 0
+
+; CHECK: error: signed pointer address discriminator must be a pointer
+@auth_var = global i32* ptrauth (i32* @var, i32 2, i8 0, i16 65535)

llvm/test/Assembler/invalid-ptrauth-const4.ll

+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+
+@var = global i32 0
+
+; CHECK: error: signed pointer address discriminator must be a pointer
+@auth_var = global i32* ptrauth (i32* @var, i32 2, i8 0, i16 65535)

llvm/test/Assembler/invalid-ptrauth-const5.ll

+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+
+@var = global i32 0
+
+; CHECK: error: signed pointer discriminator must be i16 constant integer
+@auth_var = global i32* ptrauth (i32* @var, i32 2, i8* null, i16 ptrtoint(i32* @var to i16))

llvm/test/Assembler/invalid-ptrauth-const6.ll

+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+
+@var = global i32 0
+
+; CHECK: error: signed pointer address discriminator must be a pointer
+@auth_var = global i32* ptrauth (i32* @var, i32 2, i8 0, i32 1000000)

llvm/test/Assembler/ptrauth-const.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+@var = global i32 0
+
+; CHECK: @auth_var = global i32* ptrauth (i32* @var, i32 0, i8* null, i16 -1)
+@auth_var = global i32* ptrauth (i32* @var, i32 0, i8* null, i16 65535)
+
+
+; CHECK: @addrdisc_var = global i32* ptrauth (i32* @var, i32 0, i32** @addrdisc_var, i16 1234)
+@addrdisc_var = global i32* ptrauth (i32* @var, i32 0, i32** @addrdisc_var, i16 1234)
+
+; CHECK: @keyed_var = global i32* ptrauth (i32* @var, i32 3, i8* null, i16 0)
+@keyed_var = global i32* ptrauth (i32* @var, i32 3, i8* null, i16 0)

llvm/test/Bitcode/compatibility.ll

 ; CHECK: @llvm.used = appending global [1 x i32*] [i32* @g.used1], section "llvm.metadata"
 @llvm.compiler.used = appending global [1 x i32*] [i32* @g.used2], section "llvm.metadata"
 ; CHECK: @llvm.compiler.used = appending global [1 x i32*] [i32* @g.used2], section "llvm.metadata"
 @llvm.global_ctors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 ; CHECK: @llvm.global_ctors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 @llvm.global_dtors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 ; CHECK: @llvm.global_dtors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 
+; ptrauth constant
+@auth_var = global i32* ptrauth (i32* @g1, i32 0, i8* null, i16 65535)
+; CHECK: @auth_var = global i32* ptrauth (i32* @g1, i32 0, i8* null, i16 -1)
+
 ;; Aliases
 ; Format: @<Name> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal]
 ;                   [unnamed_addr] alias <AliaseeTy> @<Aliasee>
 
 ; Aliases -- Linkage
 @a.private = private alias i32, i32* @g.private
 ; CHECK: @a.private = private alias i32, i32* @g.private
 @a.internal = internal alias i32, i32* @g.internal

 %named_type = type [8 x i8]
 declare void @byval_type(i32* byval(i32) align 2)
 declare void @byval_type2({ i8, i8* }* byval({ i8, i8* }))
 declare void @byval_named_type(%named_type* byval(%named_type))
 ; CHECK: declare void @byval_type(i32* byval(i32) align 2)
 ; CHECK: declare void @byval_type2({ i8, i8* }* byval({ i8, i8* }))
 ; CHECK: declare void @byval_named_type([8 x i8]* byval([8 x i8]))
 
+
 ; CHECK: attributes #0 = { alignstack=4 }
 ; CHECK: attributes #1 = { alignstack=8 }
 ; CHECK: attributes #2 = { alwaysinline }
 ; CHECK: attributes #3 = { cold }
 ; CHECK: attributes #4 = { convergent }
 ; CHECK: attributes #5 = { inlinehint }
 ; CHECK: attributes #6 = { jumptable }
 ; CHECK: attributes #7 = { minsize }

llvm/test/Bitcode/upgrade-ptrauth-global.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+@var = global i32 0
+
[e-mail]1 = constant { i8*, i32, i64, i64 } { i8* bitcast(i32* @var to i8*),
+                                               i32 0,
+                                               i64 0,
+                                               i64 1234 }, section "llvm.ptrauth"
+@var_auth = global i32* bitcast({i8*, i32, i64, i64}* @var.auth1 to i32*)
+; CHECK: @var_auth = global i32* ptrauth (i32* @var, i32 0, i8* null, i16 1234)