[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

@@ -973,6 +973,16 @@ 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.
             Some(def_id) if name.is_none() => self.get_fn_addr(
                 ty::Instance::expect_resolve(
                     tcx,
@@ -981,7 +991,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

@@ -493,8 +493,11 @@ 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.
+    let main_llfn = cx.get_fn_addr(instance, None);
 
     let entry_fn = create_entry_fn::<Bx>(cx, main_llfn, main_def_id, entry_type);
     return Some(entry_fn);
@@ -555,8 +558,8 @@ 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());
+
+            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

@@ -2,6 +2,9 @@
 
 use rustc_hir::LangItem;
 use rustc_hir::attrs::PeImportNameType;
+use rustc_middle::ptrauth::{
+    build_fn_ptr_type_discriminator_input_from_instance, compute_fn_ptr_type_discriminator,
+};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{self, Instance, TyCtxt};
 use rustc_middle::{bug, mir, span_bug};
@@ -117,11 +120,19 @@ 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 mut schema = bx.sess().pointer_authentication_functions().clone();
+
+    if let Some(ref mut s) = schema
+        && 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.
+        let disc_input = build_fn_ptr_type_discriminator_input_from_instance(tcx, instance);
+        let disc = compute_fn_ptr_type_discriminator(tcx, &disc_input) as u16;
+
+        s.constant_discriminator = disc;
+    }
+    (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

@@ -11,6 +11,9 @@ use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lang_items::LangItem;
 use rustc_lint_defs::builtin::TAIL_CALL_TRACK_CALLER;
 use rustc_middle::mir::{self, AssertKind, InlineAsmMacro, SwitchTargets, UnwindTerminateReason};
+use rustc_middle::ptrauth::{
+    build_fn_ptr_type_discriminator_input_from_instance, compute_fn_ptr_type_discriminator,
+};
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, ValidityRequirement};
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
 use rustc_middle::ty::{self, Instance, Ty, TypeVisitableExt};
@@ -684,12 +687,25 @@ 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 mut schema = bx.sess().pointer_authentication_functions().clone();
+
+                if let Some(ref mut s) = schema
+                    && bx.sess().pointer_authentication_fn_ptr_type_discrimination()
+                {
+                    let disc_input =
+                        build_fn_ptr_type_discriminator_input_from_instance(bx.tcx(), drop_fn);
+                    let disc = compute_fn_ptr_type_discriminator(bx.tcx(), &disc_input) as u16;
+
+                    s.constant_discriminator = disc;
+                }
+                (
+                    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
@@ -1102,13 +1118,22 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         )
                         .unwrap();
 
-                        (
-                            None,
-                            Some(bx.get_fn_addr(
+                        let mut schema = bx.sess().pointer_authentication_functions().clone();
+
+                        if let Some(ref mut s) = schema
+                            && bx.sess().pointer_authentication_fn_ptr_type_discrimination()
+                        {
+                            let disc_input = build_fn_ptr_type_discriminator_input_from_instance(
+                                bx.tcx(),
                                 instance,
-                                bx.sess().pointer_authentication_functions(),
-                            )),
-                        )
+                            );
+                            let disc =
+                                compute_fn_ptr_type_discriminator(bx.tcx(), &disc_input) as u16;
+
+                            s.constant_discriminator = disc;
+                        };
+
+                        (None, Some(bx.get_fn_addr(instance, schema)))
                     }
                     _ => (Some(instance), None),
                 }
@@ -1422,7 +1447,19 @@ 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 mut schema = bx.sess().pointer_authentication_functions().clone();
+
+                if let Some(ref mut s) = schema
+                    && bx.sess().pointer_authentication_fn_ptr_type_discrimination()
+                {
+                    let disc_input =
+                        build_fn_ptr_type_discriminator_input_from_instance(bx.tcx(), instance);
+                    let disc = compute_fn_ptr_type_discriminator(bx.tcx(), &disc_input) as u16;
+
+                    s.constant_discriminator = disc;
+                }
+
+                bx.get_fn_addr(instance, schema)
             }
             (_, Some(llfn)) => llfn,
             _ => span_bug!(fn_span, "no instance or llfn for call"),