Convert -Zpointer-authentication to target modifier

jchlanda · jchlanda · commit 809c245fa969 · 2026-07-09T11:37:06.000Z
Also improve the API design of pointer_authentication_functions, by
making it return Option&lt;&amp;PointerAuthSchema&gt;, rather than bool.
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
@@ -165,7 +165,7 @@ pub(crate) fn compile_codegen_unit(
                 if cfg.elf_got {
                     cx.add_ptrauth_elf_got_flag();
                 }
-                if cx.sess().pointer_authentication_functions() {
+                if cx.sess().pointer_authentication_functions().is_some() {
                     cx.add_ptrauth_sign_personality_flag();
                 }
             }
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -2040,7 +2040,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         llfn: &'ll Value,
         fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,
     ) -> Option<llvm::OperandBundleBox<'ll>> {
-        if !self.sess().pointer_authentication_functions() {
+        if self.sess().pointer_authentication_functions().is_none() {
             return None;
         }
         // Pointer authentication support is currently limited to extern "C" calls; filter out other
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
@@ -32,7 +32,7 @@ pub(crate) fn maybe_sign_fn_ptr<'ll, 'tcx>(
     llfn: &'ll llvm::Value,
     schema: &PointerAuthSchema,
 ) -> &'ll llvm::Value {
-    if !cx.tcx.sess.pointer_authentication_functions() {
+    if cx.tcx.sess.pointer_authentication_functions().is_none() {
         return llfn;
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -123,26 +123,8 @@ pub(crate) fn const_alloc_to_llvm<'ll>(
         let address_space = cx.tcx.global_alloc(prov.alloc_id()).address_space(cx);
         let schema = if cx.sess().pointer_authentication() {
             match is_init_fini {
-                IsInitOrFini::Yes => {
-                    if cx.sess().pointer_authentication_init_fini() {
-                        cx.sess()
-                            .pointer_auth_config
-                            .as_ref()
-                            .and_then(|cfg| cfg.init_fini.as_ref())
-                    } else {
-                        None
-                    }
-                }
-                IsInitOrFini::No => {
-                    if cx.sess().pointer_authentication_functions() {
-                        cx.sess()
-                            .pointer_auth_config
-                            .as_ref()
-                            .and_then(|cfg| cfg.function_pointers.as_ref())
-                    } else {
-                        None
-                    }
-                }
+                IsInitOrFini::Yes => cx.sess().pointer_authentication_init_fini(),
+                IsInitOrFini::No => cx.sess().pointer_authentication_functions(),
             }
         } else {
             None
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
@@ -981,10 +981,7 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                     ty::List::empty(),
                     DUMMY_SP,
                 ),
-                tcx.sess
-                    .pointer_auth_config
-                    .as_ref()
-                    .and_then(|cfg| cfg.function_pointers.as_ref()),
+                tcx.sess.pointer_authentication_functions(),
             ),
             _ => {
                 let name = name.unwrap_or("rust_eh_personality");
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
@@ -493,10 +493,7 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         return None;
     }
 
-    let main_llfn = cx.get_fn_addr(
-        instance,
-        cx.sess().pointer_auth_config.as_ref().and_then(|cfg| cfg.function_pointers.as_ref()),
-    );
+    let main_llfn = cx.get_fn_addr(instance, cx.sess().pointer_authentication_functions());
 
     let entry_fn = create_entry_fn::<Bx>(cx, main_llfn, main_def_id, entry_type);
     return Some(entry_fn);
@@ -557,13 +554,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_auth_config
-                    .as_ref()
-                    .and_then(|cfg| cfg.function_pointers.as_ref()),
-            );
+            let start_fn =
+                cx.get_fn_addr(start_instance, cx.sess().pointer_authentication_functions());
 
             let i8_ty = cx.type_i8();
             let arg_sigpipe = bx.const_u8(sigpipe);
diff --git a/compiler/rustc_codegen_ssa/src/common.rs b/compiler/rustc_codegen_ssa/src/common.rs
@@ -119,10 +119,7 @@ pub(crate) fn build_langcall<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     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_auth_config.as_ref().and_then(|cfg| cfg.function_pointers.as_ref()),
-        ),
+        bx.get_fn_addr(instance, tcx.sess.pointer_authentication_functions()),
         instance,
     )
 }
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -686,13 +686,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
             _ => (
                 false,
-                bx.get_fn_addr(
-                    drop_fn,
-                    bx.sess()
-                        .pointer_auth_config
-                        .as_ref()
-                        .and_then(|cfg| cfg.function_pointers.as_ref()),
-                ),
+                bx.get_fn_addr(drop_fn, bx.sess().pointer_authentication_functions()),
                 bx.fn_abi_of_instance(drop_fn, ty::List::empty()),
                 drop_fn,
             ),
@@ -1110,15 +1104,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
                         (
                             None,
-                            Some(
-                                bx.get_fn_addr(
-                                    instance,
-                                    bx.sess()
-                                        .pointer_auth_config
-                                        .as_ref()
-                                        .and_then(|cfg| cfg.function_pointers.as_ref()),
-                                ),
-                            ),
+                            Some(bx.get_fn_addr(
+                                instance,
+                                bx.sess().pointer_authentication_functions(),
+                            )),
                         )
                     }
                     _ => (Some(instance), None),
@@ -1432,13 +1421,9 @@ 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_auth_config
-                    .as_ref()
-                    .and_then(|cfg| cfg.function_pointers.as_ref()),
-            ),
+            (Some(instance), None) => {
+                bx.get_fn_addr(instance, bx.sess().pointer_authentication_functions())
+            }
             (_, Some(llfn)) => llfn,
             _ => span_bug!(fn_span, "no instance or llfn for call"),
         };
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -440,10 +440,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 OperandValue::Immediate(
                                     bx.get_fn_addr(
                                         instance,
-                                        bx.sess()
-                                            .pointer_auth_config
-                                            .as_ref()
-                                            .and_then(|cfg| cfg.function_pointers.as_ref()),
+                                        bx.sess().pointer_authentication_functions(),
                                     ),
                                 )
                             }
@@ -462,10 +459,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 OperandValue::Immediate(
                                     bx.cx().get_fn_addr(
                                         instance,
-                                        bx.sess()
-                                            .pointer_auth_config
-                                            .as_ref()
-                                            .and_then(|cfg| cfg.function_pointers.as_ref()),
+                                        bx.sess().pointer_authentication_functions(),
                                     ),
                                 )
                             }
@@ -687,13 +681,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         def: ty::InstanceKind::Shim(ty::ShimKind::ThreadLocal(def_id)),
                         args: ty::GenericArgs::empty(),
                     };
-                    let fn_ptr = bx.get_fn_addr(
-                        instance,
-                        bx.sess()
-                            .pointer_auth_config
-                            .as_ref()
-                            .and_then(|cfg| cfg.function_pointers.as_ref()),
-                    );
+                    let fn_ptr =
+                        bx.get_fn_addr(instance, bx.sess().pointer_authentication_functions());
                     let fn_abi = bx.fn_abi_of_instance(instance, ty::List::empty());
                     let fn_ty = bx.fn_decl_backend_type(fn_abi);
                     let fn_attrs = if bx.tcx().def_kind(instance.def_id()).has_codegen_attrs() {
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
@@ -1602,11 +1602,12 @@ pub struct BranchProtection {
     pub gcs: bool,
 }
 
-#[derive(Clone, Copy, Hash, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialOrd, PartialEq)]
 pub enum PointerAuthOption {
     // See <compiler/rustc_session/src/options.rs> and Clang's command line reference:
     // <https://clang.llvm.org/docs/ClangCommandLineReference.html#cmdoption-clang-fptrauth-auth-traps>
     // for the origin and meaning of the enum values.
+    // tidy-alphabetical-start
     Aarch64JumpTableHardening,
     AuthTraps,
     Calls,
@@ -1620,6 +1621,7 @@ pub enum PointerAuthOption {
     TypeInfoVTPtrDisc,
     VTPtrAddrDisc,
     VTPtrTypeDisc,
+    // tidy-alphabetical-end
 }
 impl PointerAuthOption {
     pub fn parse(s: &str) -> Option<Self> {
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
@@ -1041,22 +1041,31 @@ pub mod parse {
         slot: &mut Vec<(PointerAuthOption, bool)>,
         v: Option<&str>,
     ) -> bool {
-        match v {
-            Some(s) => {
-                for item in s.split(',') {
-                    let Some(name) = item.strip_prefix(&['+', '-'][..]) else {
-                        return false;
-                    };
-                    let Some(opt) = PointerAuthOption::parse(name) else {
-                        return false; // failed to parse, return.
-                    };
-                    let enabled = &item[..1] == "+";
-                    slot.push((opt, enabled));
-                }
-                true
-            }
-            None => false,
+        let Some(s) = v else {
+            return false;
+        };
+
+        let mut map = BTreeMap::<PointerAuthOption, bool>::new();
+
+        for item in s.split(',') {
+            let Some(name) = item.strip_prefix(&['+', '-'][..]) else {
+                return false;
+            };
+
+            let Some(opt) = PointerAuthOption::parse(name) else {
+                return false;
+            };
+
+            let enabled = item.starts_with('+');
+
+            // Last occurrence wins.
+            map.insert(opt, enabled);
         }
+
+        slot.clear();
+        slot.extend(map);
+
+        true
     }
 
     pub(crate) fn parse_fmt_debug(opt: &mut FmtDebug, v: Option<&str>) -> bool {
@@ -2651,7 +2660,11 @@ options! {
         "whether to use the PLT when calling into shared libraries;
         only has effect for PIC code on systems with ELF binaries
         (default: PLT is disabled if full relro is enabled on x86_64)"),
-    pointer_authentication: Vec<(PointerAuthOption, bool)> = (Vec::new(), parse_pointer_authentication_list_with_polarity, [TRACKED],
+    pointer_authentication: Vec<(PointerAuthOption, bool)> = (
+        Vec::new(),
+        parse_pointer_authentication_list_with_polarity,
+        [TRACKED]
+        { TARGET_MODIFIER: PointerAuthentication },
         "A comma-separated list of pointer authentication options, each prefixed with `+` (enable) or `-` (disable). Available options:
         `aarch64-jump-table-hardening` - enable hardened lowering for jump-table dispatch
         `auth-traps` - trap immediately on pointer authentication failure
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
@@ -1192,12 +1192,12 @@ impl Session {
         self.pointer_auth_config.is_some()
     }
 
-    pub fn pointer_authentication_functions(&self) -> bool {
-        self.pointer_auth_config.as_ref().and_then(|cfg| cfg.function_pointers.as_ref()).is_some()
+    pub fn pointer_authentication_functions(&self) -> Option<&PointerAuthSchema> {
+        self.pointer_auth_config.as_ref().and_then(|cfg| cfg.function_pointers.as_ref())
     }
 
-    pub fn pointer_authentication_init_fini(&self) -> bool {
-        self.pointer_auth_config.as_ref().and_then(|cfg| cfg.init_fini.as_ref()).is_some()
+    pub fn pointer_authentication_init_fini(&self) -> Option<&PointerAuthSchema> {
+        self.pointer_auth_config.as_ref().and_then(|cfg| cfg.init_fini.as_ref())
     }
 }
 
diff --git a/src/doc/rustc/src/platform-support/aarch64-unknown-linux-pauthtest.md b/src/doc/rustc/src/platform-support/aarch64-unknown-linux-pauthtest.md
@@ -403,6 +403,35 @@ other toolchain components. The ABI version value is computed from the enabled
 pointer authentication features according to the AArch64 ELF PAuth ABI
 specification. The bit layout matches LLVM/Clang definitions.
 
+### Option semantics and compatibility
+
+The `-Zpointer-authentication` option is a [target
+modifier](https://rust-lang.github.io/rfcs/3716-target-modifiers.html). Target
+modifiers are compiler options that affect the ABI, making it unsafe to link
+together Rust crates built with different values. The selected pointer
+authentication configuration becomes part of a crate's compilation
+configuration, and `rustc` verifies that all crates in the dependency graph
+agree on its value. If an incompatibility is detected, compilation is rejected
+with an ABI mismatch error before invoking the linker, providing a clear
+diagnostic. See `tests/ui/target_modifiers/incompatible_pauth.rs` for a sample
+use case.
+
+The order of options is not significant. The compiler canonicalizes the
+specified feature set before recording it, so the following are equivalent:
+
+```text
+-Zpointer-authentication=+calls,+init-fini
+-Zpointer-authentication=+init-fini,+calls
+```
+
+If the same option is specified multiple times, the last occurrence takes
+precedence, matching Clang's behavior. For example, the following would leave
+`init-fini` disable:
+
+```text
+-Zpointer-authentication=+init-fini,-init-fini
+```
+
 ## Cross-compilation toolchains and C code
 
 This target supports interoperability with C code. A
@@ -444,6 +473,7 @@ The following categories are supported (all present in tree):
   * enable_pointer_authentication_validation.rs
   * invalid_target_pointer_authentication.rs
   * type_discrimination_not_supported_pointer_authentication.rs
+  * incompatible_pauth.rs
 
 All tests from `assembly-llvm`, `codegen-llvm`, `codegen-units`, `coverage`,
 `crashes`, `incremental`, `library`, `mir-opt`, `run-make`, `ui` and
@@ -469,7 +499,8 @@ x.py test --target aarch64-unknown-linux-pauthtest --force-rerun assembly-llvm \
   tests/ui/statics/crt-static-pauthtest.rs \
   tests/ui/pointer_authentication/enable_pointer_authentication_validation.rs \
   tests/ui/pointer_authentication/invalid_target_pointer_authentication.rs \
-  tests/ui/pointer_authentication/type_discrimination_not_supported_pointer_authentication.rs
+  tests/ui/pointer_authentication/type_discrimination_not_supported_pointer_authentication.rs \
+  tests/ui/target_modifiers/incompatible_pauth.rs
 ```
 
 ## Limitations
diff --git a/tests/codegen-llvm/pauth/pauth-attr-cli-flags.rs b/tests/codegen-llvm/pauth/pauth-attr-cli-flags.rs
@@ -2,6 +2,14 @@
 //@ only-pauthtest
 //@ revisions: DEFAULT ALL DISABLE_JUMP DISABLE_AUTH_TRAPS DISABLE_CALLS DISABLE_INDIRCT_GOTOS DISABLE_RETURNS DISABLE_INTRINSICS DISABLE_TYPEINFO DISABLE_VT_PTR_ADDR DISABLE_VT_PTR_TYPE NONE
 
+//@ add-minicore
+#![crate_type = "lib"]
+#![no_std]
+#![no_core]
+#![feature(no_core)]
+
+extern crate minicore;
+
 //@[DEFAULT] needs-llvm-components: aarch64
 //@[DEFAULT] compile-flags: --target=aarch64-unknown-linux-pauthtest
 //@[ALL] needs-llvm-components: aarch64
@@ -27,8 +35,9 @@
 //@[NONE] needs-llvm-components: aarch64
 //@[NONE] compile-flags: --target=aarch64-unknown-linux-pauthtest  -Zpointer-authentication=-aarch64-jump-table-hardening,-auth-traps,-calls,-indirect-gotos,-return-addresses,-init-fini,-init-fini-address-discrimination,-intrinsics,-typeinfo-vt-ptr-discrimination,-vt-ptr-addr-discrimination,-vt-ptr-type-discrimination
 
-// CHECK: define {{.*}} @main{{.*}} [[ATTR_MAIN:#[0-9]+]]
-fn main() {}
+// CHECK: define {{.*}} @{{.*}}main{{.*}} [[ATTR_MAIN:#[0-9]+]]
+#[inline(never)]
+pub fn main() {}
 // DEFAULT: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
 // DEFAULT-SAME: "ptrauth-auth-traps"
 // DEFAULT-SAME: "ptrauth-calls"
diff --git a/tests/ui/target_modifiers/auxiliary/pauth.rs b/tests/ui/target_modifiers/auxiliary/pauth.rs
@@ -0,0 +1,7 @@
+//@ compile-flags: --target aarch64-unknown-linux-pauthtest -Zpointer-authentication=+calls,+init-fini
+//@ needs-llvm-components: aarch64
+//@ only-pauthtest
+
+#![feature(no_core)]
+#![crate_type = "rlib"]
+#![no_core]
diff --git a/tests/ui/target_modifiers/incompatible_pauth.error_generated.stderr b/tests/ui/target_modifiers/incompatible_pauth.error_generated.stderr
diff --git a/tests/ui/target_modifiers/incompatible_pauth.rs b/tests/ui/target_modifiers/incompatible_pauth.rs

Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ pub(crate) fn compile_codegen_unit(`
`165`	`165`	`if cfg.elf_got {`
`166`	`166`	`cx.add_ptrauth_elf_got_flag();`
`167`	`167`	`}`
`168`		`- if cx.sess().pointer_authentication_functions() {`
	`168`	`+ if cx.sess().pointer_authentication_functions().is_some() {`
`169`	`169`	`cx.add_ptrauth_sign_personality_flag();`
`170`	`170`	`}`
`171`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2040,7 +2040,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {`
`2040`	`2040`	`llfn: &'ll Value,`
`2041`	`2041`	`fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,`
`2042`	`2042`	`) -> Option<llvm::OperandBundleBox<'ll>> {`
`2043`		`- if !self.sess().pointer_authentication_functions() {`
	`2043`	`+ if self.sess().pointer_authentication_functions().is_none() {`
`2044`	`2044`	`return None;`
`2045`	`2045`	`}`
`2046`	`2046`	`// Pointer authentication support is currently limited to extern "C" calls; filter out other`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ pub(crate) fn maybe_sign_fn_ptr<'ll, 'tcx>(`
`32`	`32`	`llfn: &'ll llvm::Value,`
`33`	`33`	`schema: &PointerAuthSchema,`
`34`	`34`	`) -> &'ll llvm::Value {`
`35`		`- if !cx.tcx.sess.pointer_authentication_functions() {`
	`35`	`+ if cx.tcx.sess.pointer_authentication_functions().is_none() {`
`36`	`36`	`return llfn;`
`37`	`37`	`}`
`38`	`38`
Original file line number	Diff line number	Diff line change
`@@ -119,10 +119,7 @@ pub(crate) fn build_langcall<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(`
`119`	`119`	`let instance = ty::Instance::mono(tcx, def_id);`
`120`	`120`	`(`
`121`	`121`	`bx.fn_abi_of_instance(instance, ty::List::empty()),`
`122`		`- bx.get_fn_addr(`
`123`		`- instance,`
`124`		`- tcx.sess.pointer_auth_config.as_ref().and_then(\|cfg\| cfg.function_pointers.as_ref()),`
`125`		`- ),`
	`122`	`+ bx.get_fn_addr(instance, tcx.sess.pointer_authentication_functions()),`
`126`	`123`	`instance,`
`127`	`124`	`)`
`128`	`125`	`}`