[PAC] Propagate function pointer type discrimination through get_fn_addr call sites

Fill in function pointer type discriminators logic across remaining
`get_fn_addr` call sites and explicitly avoid applying it where
discrimination is not meaningful.

Some uses of `get_fn_addr` are intentionally left unsigned, including
the EH personality function, entry wrappers, and compiler-generated Rust
ABI shims.

Author: jchlanda

compiler/rustc_codegen_llvm/src/context.rs

@@ -977,6 +977,18 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 
         let tcx = self.tcx;
         let llfn = match tcx.lang_items().eh_personality() {
+            // We intentionally do not apply pointer authentication (and/or function type
+            // discriminators to the EH personality function).
+            //
+            // Although `get_fn_addr` normally produces a signed function pointer for
+            // externally-callable functions, the EH personality is not an indirect call
+            // target in the SSA sense. Instead, it is a compile-time constant attached to
+            // the Function object (via LLVM's `setPersonalityFn`) and consumed only by
+            // exception handling metadata generation (landing pads / unwind tables).
+            // LLVM never loads or invokes the personality via a function pointer value;
+            // it is not part of the program's call graph or data flow.
+            // It's backend's responsibility to apply ABI-specific personality signing
+            // when emitting the pointer in the object file.
             Some(def_id) if name.is_none() => self.get_fn_addr(
                 ty::Instance::expect_resolve(
                     tcx,
@@ -985,7 +997,7 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                     ty::List::empty(),
                     DUMMY_SP,
                 ),
-                tcx.sess.pointer_authentication_functions(),
+                None,
             ),
             _ => {
                 let name = name.unwrap_or("rust_eh_personality");

compiler/rustc_codegen_ssa/src/base.rs

@@ -4,7 +4,7 @@ use std::time::{Duration, Instant};
 use std::{cmp, iter};
 
 use itertools::Itertools;
-use rustc_abi::FIRST_VARIANT;
+use rustc_abi::{ExternAbi, FIRST_VARIANT};
 use rustc_ast::expand::allocator::{
     ALLOC_ERROR_HANDLER, ALLOCATOR_METHODS, AllocatorKind, AllocatorMethod, AllocatorMethodInput,
     AllocatorTy,
@@ -515,8 +515,18 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         // We want to create the wrapper only when the codegen unit is the primary one
         return None;
     }
-
-    let main_llfn = cx.get_fn_addr(instance, cx.sess().pointer_authentication_functions());
+    // No function pointer signing / type discriminator is needed here. Although `get_fn_addr` is
+    // used to obtain function pointers, both the user's `main` and `LangItem::Start` use the Rust
+    // ABI (currently pointer authentication is only supported for C/System ABI). The same applies
+    // to the logic in `create_entry_fn` further below.
+    assert!(
+        !matches!(
+            cx.tcx().fn_sig(main_def_id).skip_binder().abi(),
+            ExternAbi::C { .. } | ExternAbi::System { .. }
+        ),
+        "entry wrapper assumes Rust ABI"
+    );
+    let main_llfn = cx.get_fn_addr(instance, /* pointer_auth_schema */ None);
 
     let entry_fn = create_entry_fn::<Bx>(cx, main_llfn, main_def_id, entry_type);
     return Some(entry_fn);
@@ -577,8 +587,16 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
                 cx.tcx().mk_args(&[main_ret_ty.into()]),
                 DUMMY_SP,
             );
-            let start_fn =
-                cx.get_fn_addr(start_instance, cx.sess().pointer_authentication_functions());
+            // Start instance doesn't require signing, as it uses Rust ABI, hence pass `None` to
+            // `get_fn_addr`.
+            assert!(
+                !matches!(
+                    cx.tcx().fn_sig(start_instance.def_id()).skip_binder().abi(),
+                    ExternAbi::C { .. } | ExternAbi::System { .. }
+                ),
+                "LangItem::Start unexpectedly uses the C/System ABI",
+            );
+            let start_fn = cx.get_fn_addr(start_instance, None);
 
             let i8_ty = cx.type_i8();
             let arg_sigpipe = bx.const_u8(sigpipe);

compiler/rustc_codegen_ssa/src/common.rs

@@ -3,6 +3,7 @@
 use rustc_hir::LangItem;
 use rustc_hir::attrs::PeImportNameType;
 use rustc_middle::mir::interpret::{GlobalAlloc, PointerArithmetic, Scalar};
+use rustc_middle::ptrauth::ptrauth_clone_discriminated_schema_for;
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{self, Instance, ScalarInt, TyCtxt};
 use rustc_middle::{bug, span_bug};
@@ -118,11 +119,20 @@ pub(crate) fn build_langcall<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     let tcx = bx.tcx();
     let def_id = tcx.require_lang_item(li, span);
     let instance = ty::Instance::mono(tcx, def_id);
-    (
-        bx.fn_abi_of_instance(instance, ty::List::empty()),
-        bx.get_fn_addr(instance, tcx.sess.pointer_authentication_functions()),
-        instance,
-    )
+
+    let schema = if bx.sess().pointer_authentication_fn_ptr_type_discrimination() {
+        // It is unlikely that any of LangItem will follow the extern C/System ABI, but it future
+        // proofs the implementation.
+        ptrauth_clone_discriminated_schema_for(
+            bx.tcx(),
+            bx.sess().pointer_authentication_functions(),
+            instance,
+        )
+    } else {
+        bx.sess().pointer_authentication_functions().clone()
+    };
+
+    (bx.fn_abi_of_instance(instance, ty::List::empty()), bx.get_fn_addr(instance, schema), instance)
 }
 
 pub(crate) fn shift_mask_val<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -13,6 +13,7 @@ use rustc_hir::lang_items::LangItem;
 use rustc_lint_defs::builtin::TAIL_CALL_TRACK_CALLER;
 use rustc_middle::mir::interpret::{CTFE_ALLOC_SALT, Scalar};
 use rustc_middle::mir::{self, AssertKind, InlineAsmMacro, SwitchTargets, UnwindTerminateReason};
+use rustc_middle::ptrauth::ptrauth_clone_discriminated_schema_for;
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout, ValidityRequirement};
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
 use rustc_middle::ty::{self, Instance, Ty, TypeVisitableExt};
@@ -695,12 +696,23 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     virtual_drop,
                 )
             }
-            _ => (
-                false,
-                bx.get_fn_addr(drop_fn, bx.sess().pointer_authentication_functions()),
-                bx.fn_abi_of_instance(drop_fn, ty::List::empty()),
-                drop_fn,
-            ),
+            _ => {
+                let schema = if bx.sess().pointer_authentication_fn_ptr_type_discrimination() {
+                    ptrauth_clone_discriminated_schema_for(
+                        bx.tcx(),
+                        bx.sess().pointer_authentication_functions(),
+                        drop_fn,
+                    )
+                } else {
+                    bx.sess().pointer_authentication_functions().clone()
+                };
+                (
+                    false,
+                    bx.get_fn_addr(drop_fn, schema),
+                    bx.fn_abi_of_instance(drop_fn, ty::List::empty()),
+                    drop_fn,
+                )
+            }
         };
 
         // We generate a null check for the drop_fn. This saves a bunch of relocations being
@@ -1112,14 +1124,18 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             generic_args.no_bound_vars().unwrap(),
                         )
                         .unwrap();
+                        let schema =
+                            if bx.sess().pointer_authentication_fn_ptr_type_discrimination() {
+                                ptrauth_clone_discriminated_schema_for(
+                                    bx.tcx(),
+                                    bx.sess().pointer_authentication_functions(),
+                                    instance,
+                                )
+                            } else {
+                                bx.sess().pointer_authentication_functions().clone()
+                            };
 
-                        (
-                            None,
-                            Some(bx.get_fn_addr(
-                                instance,
-                                bx.sess().pointer_authentication_functions(),
-                            )),
-                        )
+                        (None, Some(bx.get_fn_addr(instance, schema)))
                     }
                     _ => (Some(instance), None),
                 }
@@ -1433,7 +1449,17 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
         let fn_ptr = match (instance, llfn) {
             (Some(instance), None) => {
-                bx.get_fn_addr(instance, bx.sess().pointer_authentication_functions())
+                let schema = if bx.sess().pointer_authentication_fn_ptr_type_discrimination() {
+                    ptrauth_clone_discriminated_schema_for(
+                        bx.tcx(),
+                        bx.sess().pointer_authentication_functions(),
+                        instance,
+                    )
+                } else {
+                    bx.sess().pointer_authentication_functions().clone()
+                };
+
+                bx.get_fn_addr(instance, schema)
             }
             (_, Some(llfn)) => llfn,
             _ => span_bug!(fn_span, "no instance or llfn for call"),