Discussion: atrosinenko/pauth-blend-removal

clang/lib/CodeGen/CGBuiltin.cpp

@@ -5622,43 +5622,79 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
   case Builtin::BI__builtin_ptrauth_sign_constant:
     return RValue::get(ConstantEmitter(*this).emitAbstract(E, E->getType()));
 
+  case Builtin::BI__builtin_ptrauth_blend_discriminator: {
+    CGM.Error(E->getExprLoc(), "Standalone blend builtin is not supported");
+    llvm::Type *Ty = ConvertType(E->getType());
+    return RValue::get(llvm::UndefValue::get(Ty));
+  }
+
   case Builtin::BI__builtin_ptrauth_auth:
   case Builtin::BI__builtin_ptrauth_auth_and_resign:
-  case Builtin::BI__builtin_ptrauth_blend_discriminator:
   case Builtin::BI__builtin_ptrauth_sign_generic_data:
   case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
   case Builtin::BI__builtin_ptrauth_strip: {
-    // Emit the arguments.
-    SmallVector<llvm::Value *, 5> Args;
-    for (auto argExpr : E->arguments())
-      Args.push_back(EmitScalarExpr(argExpr));
+    SmallVector<llvm::Value *, 2> Args;
+    SmallVector<llvm::OperandBundleDef, 2> OBs;
+
+    auto ConvertToInt64 = [&](llvm::Value *V) {
+      if (V->getType()->isPointerTy())
+        return Builder.CreatePtrToInt(V, IntPtrTy);
+      return Builder.CreateZExt(V, IntPtrTy);
+    };
+
+    auto AddPtrAuthBundle = [&](const Expr *KeyExpr, const Expr *DiscrExpr) {
+      llvm::Value *Key = ConvertToInt64(EmitScalarExpr(KeyExpr));
+      llvm::Value *IntDiscr = Builder.getInt64(0);
+      llvm::Value *AddrDiscr = Builder.getInt64(0);
+
+      const CallExpr *MaybeBlend = dyn_cast<CallExpr>(DiscrExpr);
+      if (MaybeBlend && MaybeBlend->getBuiltinCallee() ==
+                        Builtin::BI__builtin_ptrauth_blend_discriminator) {
+        // Assign modifiers according to blend arguments.
+        IntDiscr = ConvertToInt64(EmitScalarExpr(MaybeBlend->getArg(1)));
+        AddrDiscr = ConvertToInt64(EmitScalarExpr(MaybeBlend->getArg(0)));
+      } else {
+        // Check if discriminator is a small integer constant and fallback to
+        // passing an arbitrary raw value otherwise.
+        llvm::Value *Discr = ConvertToInt64(EmitScalarExpr(DiscrExpr));
+        llvm::ConstantInt *DiscrConst = dyn_cast<llvm::ConstantInt>(Discr);
+        if (DiscrConst && isUInt<16>(DiscrConst->getZExtValue()))
+          IntDiscr = Discr;
+        else
+          AddrDiscr = Discr;
+      }
+      llvm::Value *Inputs[] = {Key, IntDiscr, AddrDiscr};
+      OBs.emplace_back("ptrauth", Inputs);
+    };
 
     // Cast the value to intptr_t, saving its original type.
+    Args.push_back(EmitScalarExpr(E->getArg(0)));
     llvm::Type *OrigValueType = Args[0]->getType();
-    if (OrigValueType->isPointerTy())
-      Args[0] = Builder.CreatePtrToInt(Args[0], IntPtrTy);
+    Args[0] = ConvertToInt64(Args[0]);
 
     switch (BuiltinID) {
+    default:
+      llvm_unreachable("bad ptrauth intrinsic");
     case Builtin::BI__builtin_ptrauth_auth_and_resign:
-      if (Args[4]->getType()->isPointerTy())
-        Args[4] = Builder.CreatePtrToInt(Args[4], IntPtrTy);
-      [[fallthrough]];
+      AddPtrAuthBundle(E->getArg(1), E->getArg(2));
+      AddPtrAuthBundle(E->getArg(3), E->getArg(4));
+      break;
 
     case Builtin::BI__builtin_ptrauth_auth:
     case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
-      if (Args[2]->getType()->isPointerTy())
-        Args[2] = Builder.CreatePtrToInt(Args[2], IntPtrTy);
+      AddPtrAuthBundle(E->getArg(1), E->getArg(2));
       break;
 
     case Builtin::BI__builtin_ptrauth_sign_generic_data:
-      if (Args[1]->getType()->isPointerTy())
-        Args[1] = Builder.CreatePtrToInt(Args[1], IntPtrTy);
+      Args.push_back(ConvertToInt64(EmitScalarExpr(E->getArg(1))));
       break;
 
-    case Builtin::BI__builtin_ptrauth_blend_discriminator:
-    case Builtin::BI__builtin_ptrauth_strip:
+    case Builtin::BI__builtin_ptrauth_strip: {
+      llvm::Value *Key = ConvertToInt64(EmitScalarExpr(E->getArg(1)));
+      OBs.emplace_back("ptrauth", ArrayRef({Key}));
       break;
     }
+    }
 
     // Call the intrinsic.
     auto IntrinsicID = [&]() -> unsigned {
@@ -5667,8 +5703,6 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
         return Intrinsic::ptrauth_auth;
       case Builtin::BI__builtin_ptrauth_auth_and_resign:
         return Intrinsic::ptrauth_resign;
-      case Builtin::BI__builtin_ptrauth_blend_discriminator:
-        return Intrinsic::ptrauth_blend;
       case Builtin::BI__builtin_ptrauth_sign_generic_data:
         return Intrinsic::ptrauth_sign_generic;
       case Builtin::BI__builtin_ptrauth_sign_unauthenticated:
@@ -5679,10 +5713,9 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
       llvm_unreachable("bad ptrauth intrinsic");
     }();
     auto Intrinsic = CGM.getIntrinsic(IntrinsicID);
-    llvm::Value *Result = EmitRuntimeCall(Intrinsic, Args);
+    llvm::Value *Result = EmitRuntimeCall(Intrinsic, Args, OBs);
 
     if (BuiltinID != Builtin::BI__builtin_ptrauth_sign_generic_data &&
-        BuiltinID != Builtin::BI__builtin_ptrauth_blend_discriminator &&
         OrigValueType->isPointerTy()) {
       Result = Builder.CreateIntToPtr(Result, OrigValueType);
     }

clang/lib/CodeGen/CGCall.cpp

@@ -5039,10 +5039,21 @@ CodeGenFunction::getBundlesForFunclet(llvm::Value *Callee) {
 llvm::CallInst *CodeGenFunction::EmitRuntimeCall(llvm::FunctionCallee callee,
                                                  ArrayRef<llvm::Value *> args,
                                                  const llvm::Twine &name) {
+  return EmitRuntimeCall(callee, args, {}, name);
+}
+
+llvm::CallInst *CodeGenFunction::EmitRuntimeCall(
+      llvm::FunctionCallee callee, ArrayRef<llvm::Value *> args,
+      ArrayRef<llvm::OperandBundleDef> extraBundles, const Twine &name) {
+  SmallVector<llvm::OperandBundleDef, 3> allBundles;
+  llvm::append_range(allBundles, getBundlesForFunclet(callee.getCallee()));
+  llvm::append_range(allBundles, extraBundles);
   llvm::CallInst *call = Builder.CreateCall(
-      callee, args, getBundlesForFunclet(callee.getCallee()), name);
+      callee, args, allBundles, name);
   call->setCallingConv(getRuntimeCC());
 
+  // FIXME Attach "convergencectrl" bundle right away instead of re-creating
+  //       the call instruction.
   if (CGM.shouldEmitConvergenceTokens() && call->isConvergent())
     return cast<llvm::CallInst>(addConvergenceControlToken(call));
   return call;

clang/lib/CodeGen/CGClass.cpp

@@ -2775,7 +2775,7 @@ llvm::Value *CodeGenFunction::GetVTablePtr(Address This,
     } else {
       VTable = cast<llvm::Instruction>(EmitPointerAuthAuth(
           CGPointerAuthInfo(0, PointerAuthenticationMode::Strip, false, false,
-                            nullptr),
+                            0, nullptr),
           VTable));
     }
   }

clang/lib/CodeGen/CGExprConstant.cpp

@@ -2227,9 +2227,7 @@ ConstantLValueEmitter::tryEmitBase(const APValue::LValueBase &base) {
           return ConstantLValue(nullptr);
 
         C = applyOffset(C);
-        C = CGM.getConstantSignedPointer(
-            C, AuthInfo.getKey(), nullptr,
-            cast_or_null<llvm::ConstantInt>(AuthInfo.getDiscriminator()));
+        C = CGM.getConstantSignedPointer(C, AuthInfo);
         return ConstantLValue(C, /*applied offset*/ true, /*signed*/ true);
       }