diff --git a/compiler/rustc_codegen_gcc/src/common.rs b/compiler/rustc_codegen_gcc/src/common.rs
index 7450f11f3ce80..e73b8aab54d73 100644
--- a/compiler/rustc_codegen_gcc/src/common.rs
+++ b/compiler/rustc_codegen_gcc/src/common.rs
@@ -2,12 +2,12 @@ use gccjit::{LValue, RValue, ToRValue, Type};
 use rustc_abi::Primitive::Pointer;
 use rustc_abi::{self as abi, HasDataLayout};
 use rustc_codegen_ssa::traits::{
-    BaseTypeCodegenMethods, ConstCodegenMethods, MiscCodegenMethods, PacMetadata,
-    StaticCodegenMethods,
+    BaseTypeCodegenMethods, ConstCodegenMethods, MiscCodegenMethods, StaticCodegenMethods,
 };
 use rustc_middle::mir::Mutability;
 use rustc_middle::mir::interpret::{GlobalAlloc, PointerArithmetic, Scalar};
 use rustc_middle::ty::layout::LayoutOf;
+use rustc_session::PointerAuthSchema;
 
 use crate::consts::const_alloc_to_gcc;
 use crate::context::{CodegenCx, new_array_type};
@@ -247,7 +247,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods for CodegenCx<'gcc, 'tcx> {
         cv: Scalar,
         layout: abi::Scalar,
         ty: Type<'gcc>,
-        _pac: Option<PacMetadata>,
+        _schema: Option<&PointerAuthSchema>,
     ) -> RValue<'gcc> {
         let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() };
         match cv {
diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs
index 3a6c415b38963..0e3fa72fbcfb3 100644
--- a/compiler/rustc_codegen_gcc/src/context.rs
+++ b/compiler/rustc_codegen_gcc/src/context.rs
@@ -5,9 +5,7 @@ use gccjit::{Block, CType, Context, Function, FunctionType, LValue, Location, RV
 use rustc_abi::{Align, HasDataLayout, PointeeInfo, Size, TargetDataLayout, VariantIdx};
 use rustc_codegen_ssa::base::wants_msvc_seh;
 use rustc_codegen_ssa::errors as ssa_errors;
-use rustc_codegen_ssa::traits::{
-    BackendTypes, BaseTypeCodegenMethods, MiscCodegenMethods, PacMetadata,
-};
+use rustc_codegen_ssa::traits::{BackendTypes, BaseTypeCodegenMethods, MiscCodegenMethods};
 use rustc_data_structures::base_n::{ALPHANUMERIC_ONLY, ToBaseN};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_middle::mir::interpret::Allocation;
@@ -18,9 +16,9 @@ use rustc_middle::ty::layout::{
     LayoutOfHelpers,
 };
 use rustc_middle::ty::{self, ExistentialTraitRef, Instance, Ty, TyCtxt};
-use rustc_session::Session;
 #[cfg(feature = "master")]
 use rustc_session::config::DebugInfo;
+use rustc_session::{PointerAuthSchema, Session};
 use rustc_span::{DUMMY_SP, Span, Symbol, respan};
 use rustc_target::spec::{HasTargetSpec, HasX86AbiOpt, Target, TlsModel, X86Abi};
 
@@ -400,7 +398,11 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         get_fn(self, instance)
     }
 
-    fn get_fn_addr(&self, instance: Instance<'tcx>, _pac: Option<PacMetadata>) -> RValue<'gcc> {
+    fn get_fn_addr(
+        &self,
+        instance: Instance<'tcx>,
+        _pointer_auth_schema: Option<&PointerAuthSchema>,
+    ) -> RValue<'gcc> {
         let func_name = self.tcx.symbol_name(instance).name;
 
         let func = if let Some(variable) = self.get_declared_value(func_name) {
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index ee6035359d649..2678e0ac7e647 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -12,12 +12,9 @@ use rustc_session::config::{
 };
 use rustc_span::sym;
 use rustc_symbol_mangling::mangle_internal_symbol;
-use rustc_target::spec::{
-    Arch, FramePointer, LlvmAbi, SanitizerSet, StackProbeType, StackProtector,
-};
+use rustc_target::spec::{Arch, FramePointer, SanitizerSet, StackProbeType, StackProtector};
 use smallvec::SmallVec;
 
-use crate::common::pauth_fn_attrs;
 use crate::context::SimpleCx;
 use crate::errors::{PackedStackBackchainNeedsSoftfloat, SanitizerMemtagRequiresMte};
 use crate::llvm::AttributePlace::Function;
@@ -646,8 +643,9 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         }
     }
 
-    if sess.target.llvm_abiname == LlvmAbi::Pauthtest {
-        for &ptrauth_attr in pauth_fn_attrs() {
+    if sess.pointer_authentication() {
+        let cfg = sess.pointer_auth_config.as_ref().unwrap();
+        for ptrauth_attr in cfg.fn_attrs() {
             to_add.push(llvm::CreateAttrString(cx.llcx, ptrauth_attr));
         }
     }
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
index bb4ae6e64560a..1f2df013d95c5 100644
--- a/compiler/rustc_codegen_llvm/src/base.rs
+++ b/compiler/rustc_codegen_llvm/src/base.rs
@@ -25,13 +25,12 @@ use rustc_middle::mono::Visibility;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{DebugInfo, Offload};
 use rustc_span::Symbol;
-use rustc_target::spec::{LlvmAbi, SanitizerSet};
+use rustc_target::spec::SanitizerSet;
 
 use super::ModuleLlvm;
 use crate::attributes;
 use crate::builder::Builder;
 use crate::builder::gpu_offload::OffloadGlobals;
-use crate::common::pauth_fn_attrs;
 use crate::context::CodegenCx;
 use crate::llvm::{self, Value};
 
@@ -131,8 +130,9 @@ pub(crate) fn compile_codegen_unit(
                 // FIXME(jchlanda) If it ever becomes necessary to ensure that all compiler
                 // generated functions receive the ptrauth-* attributes, `declare_fn` or
                 // `declare_raw_fn` could be used to provide those.
-                if cx.sess().target.llvm_abiname == LlvmAbi::Pauthtest {
-                    for &ptrauth_attr in pauth_fn_attrs() {
+                if cx.sess().pointer_authentication() {
+                    let cfg = cx.sess().pointer_auth_config.as_ref().unwrap();
+                    for ptrauth_attr in cfg.fn_attrs() {
                         attrs.push(llvm::CreateAttrString(cx.llcx, ptrauth_attr));
                     }
                 }
@@ -152,28 +152,22 @@ pub(crate) fn compile_codegen_unit(
                 cx.add_objc_module_flags();
             }
 
-            if cx.sess().target.llvm_abiname == LlvmAbi::Pauthtest {
-                // FIXME(jchlanda): In LLVM/Clang, there are also `aarch64-elf-pauthabi-platform`
-                // and `aarch64-elf-pauthabi-version` module flags. These are emitted into the
-                // PAuth core info section of the resulting ELF, which the linker uses to enforce
-                // binary compatibility.
-                //
-                // We intentionally do not emit these flags now, since only a subset of features
-                // included in clang's pauthtest is currently supported. By default, the absence of
-                // this info is treated as compatible with any binary.
-                //
-                // Please note, that this would cause compatibility issues, specifically runtime
-                // crashes due to authentication failures (while compiling and linking
-                // successfully) when linking against binaries that support larger set of features
-                // (for example, signing of C++ member function pointers, virtual function
-                // pointers, virtual table pointers).
-                //
-                // Link to PAuth core info documentation:
-                // <https://github.com/ARM-software/abi-aa/blob/2025Q4/pauthabielf64/pauthabielf64.rst#core-information>
-                if cx.sess().opts.unstable_opts.ptrauth_elf_got {
+            if cx.sess().pointer_authentication() {
+                let cfg = cx.sess().pointer_auth_config.as_ref().unwrap();
+
+                let aarch64_elf_pauthabi_version =
+                    cfg.calculate_pauth_abi_version(&cx.sess().target);
+                if aarch64_elf_pauthabi_version != 0 {
+                    cx.add_ptrauth_pauthabi_version_and_platform_flags(
+                        aarch64_elf_pauthabi_version,
+                    );
+                }
+                if cfg.elf_got {
                     cx.add_ptrauth_elf_got_flag();
                 }
-                cx.add_ptrauth_sign_personality_flag();
+                if cx.sess().pointer_authentication_functions() {
+                    cx.add_ptrauth_sign_personality_flag();
+                }
             }
 
             // Finalize code coverage by injecting the coverage map. Note, the coverage map will
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 58a62145d576e..604b337c3c6f6 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -26,7 +26,7 @@ use rustc_sanitizers::{cfi, kcfi};
 use rustc_session::config::OptLevel;
 use rustc_span::Span;
 use rustc_target::callconv::{FnAbi, PassMode};
-use rustc_target::spec::{Arch, HasTargetSpec, LlvmAbi, SanitizerSet, Target};
+use rustc_target::spec::{Arch, HasTargetSpec, SanitizerSet, Target};
 use smallvec::SmallVec;
 use tracing::{debug, instrument};
 
@@ -2042,7 +2042,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().target.llvm_abiname != LlvmAbi::Pauthtest {
+        if !self.sess().pointer_authentication_functions() {
             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
index 1c26738b7cf9c..030d62b25e92e 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -16,7 +16,7 @@ use rustc_middle::bug;
 use rustc_middle::mir::interpret::{GlobalAlloc, PointerArithmetic, Scalar};
 use rustc_middle::ty::{Instance, TyCtxt};
 use rustc_session::cstore::DllImport;
-use rustc_target::spec::LlvmAbi;
+use rustc_session::{PointerAuthAddressDiscriminator, PointerAuthSchema};
 use tracing::debug;
 
 use crate::consts::{IsInitOrFini, IsStatic, const_alloc_to_llvm};
@@ -26,27 +26,13 @@ use crate::llvm::{
     self, BasicBlock, ConstantInt, FALSE, TRUE, ToLlvmBool, Type, Value, const_ptr_auth,
 };
 
-#[inline]
-pub(crate) fn pauth_fn_attrs() -> &'static [&'static str] {
-    // FIXME(jchlanda) This is not an exhaustive list of all `ptrauth`-related attributes, but only
-    // those currently supported. The list is expected to grow as additional functionality is
-    // implemented, particularly for C++ interoperability.
-    &[
-        "aarch64-jump-table-hardening",
-        "ptrauth-indirect-gotos",
-        "ptrauth-calls",
-        "ptrauth-returns",
-        "ptrauth-auth-traps",
-    ]
-}
-
 pub(crate) fn maybe_sign_fn_ptr<'ll, 'tcx>(
     cx: &CodegenCx<'ll, '_>,
     instance: Instance<'tcx>,
     llfn: &'ll llvm::Value,
-    pac: PacMetadata,
+    schema: &PointerAuthSchema,
 ) -> &'ll llvm::Value {
-    if cx.sess().target.llvm_abiname != LlvmAbi::Pauthtest {
+    if !cx.tcx.sess.pointer_authentication_functions() {
         return llfn;
     }
 
@@ -68,16 +54,16 @@ pub(crate) fn maybe_sign_fn_ptr<'ll, 'tcx>(
         return llfn;
     }
 
-    let addr_diversity = match pac.addr_diversity {
-        AddressDiversity::None => None,
-        AddressDiversity::Real => Some(llfn),
-        AddressDiversity::Synthetic(val) => {
+    let addr_diversity = match schema.is_address_discriminated {
+        PointerAuthAddressDiscriminator::HardwareAddress(true) => Some(llfn),
+        PointerAuthAddressDiscriminator::HardwareAddress(false) => None,
+        PointerAuthAddressDiscriminator::Synthetic(val) => {
             let llval = cx.const_u64(val);
             let llty = cx.val_ty(llfn);
             Some(unsafe { llvm::LLVMConstIntToPtr(llval, llty) })
         }
     };
-    const_ptr_auth(llfn, pac.key, pac.disc, addr_diversity)
+    const_ptr_auth(llfn, schema.key as u32, schema.constant_discriminator as u64, addr_diversity)
 }
 
 /*
@@ -331,7 +317,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
         cv: Scalar,
         layout: abi::Scalar,
         llty: &'ll Type,
-        pac: Option<PacMetadata>,
+        schema: Option<&PointerAuthSchema>,
     ) -> &'ll Value {
         let bitsize = if layout.is_bool() { 1 } else { layout.size(self).bits() };
         match cv {
@@ -387,7 +373,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                             value
                         }
                     }
-                    GlobalAlloc::Function { instance, .. } => self.get_fn_addr(instance, pac),
+                    GlobalAlloc::Function { instance, .. } => self.get_fn_addr(instance, schema),
                     GlobalAlloc::VTable(ty, dyn_ty) => {
                         let alloc = self
                             .tcx
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index a4d52c18c890b..aa2d976a9cab2 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -17,7 +17,7 @@ use rustc_middle::ty::layout::{HasTypingEnv, LayoutOf};
 use rustc_middle::ty::{self, Instance};
 use rustc_middle::{bug, span_bug};
 use rustc_span::Symbol;
-use rustc_target::spec::{Arch, LlvmAbi};
+use rustc_target::spec::Arch;
 use tracing::{debug, instrument, trace};
 
 use crate::common::CodegenCx;
@@ -32,6 +32,7 @@ pub(crate) enum IsStatic {
     No,
 }
 /// Indicates whether a symbol is part of `.init_array` or `.fini_array`.
+#[derive(PartialEq)]
 pub(crate) enum IsInitOrFini {
     Yes,
     No,
@@ -120,23 +121,32 @@ pub(crate) fn const_alloc_to_llvm<'ll>(
             as u64;
 
         let address_space = cx.tcx.global_alloc(prov.alloc_id()).address_space(cx);
-        // Under pointer authentication, function pointers stored in init/fini arrays need special
-        // handling.
-        let pac_metadata = Some(
-            if cx.sess().target.llvm_abiname == LlvmAbi::Pauthtest
-                && matches!(is_init_fini, IsInitOrFini::Yes)
-            {
-                PacMetadata {
-                    // Must correspond to ptrauth_key_init_fini_pointer from `ptrauth.h`.
-                    key: 0,
-                    // ptrauth_string_discriminator("init_fini")
-                    disc: 0xd9d4,
-                    addr_diversity: AddressDiversity::Synthetic(1),
+        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
+                    }
                 }
-            } else {
-                PacMetadata::default()
-            },
-        );
+                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
+                    }
+                }
+            }
+        } else {
+            None
+        };
         llvals.push(cx.scalar_to_backend_with_pac(
             InterpScalar::from_pointer(Pointer::new(prov, Size::from_bytes(ptr_offset)), &cx.tcx),
             Scalar::Initialized {
@@ -144,7 +154,7 @@ pub(crate) fn const_alloc_to_llvm<'ll>(
                 valid_range: WrappingRange::full(pointer_size),
             },
             cx.type_ptr_ext(address_space),
-            pac_metadata,
+            schema,
         ));
         next_offset = offset + pointer_size_bytes;
     }
@@ -221,7 +231,7 @@ fn check_and_apply_linkage<'ll, 'tcx>(
                 let fn_sig = sig.with(*header);
                 let fn_abi = cx.fn_abi_of_fn_ptr(fn_sig, ty::List::empty());
                 // Decide if the initializer needs to be signed
-                if cx.sess().target.llvm_abiname == LlvmAbi::Pauthtest
+                if cx.sess().pointer_authentication()
                     && matches!(fn_sig.abi(), ExternAbi::C { .. } | ExternAbi::System { .. })
                 {
                     should_sign = true;
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 96fc781b15f9d..d69e68df497a1 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -21,10 +21,10 @@ use rustc_middle::ty::layout::{
 };
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
-use rustc_session::Session;
 use rustc_session::config::{
     BranchProtection, CFGuard, CFProtection, CrateType, DebugInfo, FunctionReturn, PAuthKey, PacRet,
 };
+use rustc_session::{PointerAuthSchema, Session};
 use rustc_span::{DUMMY_SP, Span, Spanned, Symbol, sym};
 use rustc_target::spec::{
     Arch, CfgAbi, Env, FramePointer, HasTargetSpec, Os, RelocModel, SmallDataThresholdSupport,
@@ -745,6 +745,29 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
         );
     }
 
+    pub(crate) fn add_ptrauth_pauthabi_version_and_platform_flags(
+        &self,
+        aarch64_elf_pauthabi_version: u32,
+    ) {
+        // NOTE: This must correspond to llvm's AARCH64_PAUTH_PLATFORM_LLVM_LINUX, as defined in
+        // <llvm_root>/llvm/include/llvm/BinaryFormat/ELF.h.
+        // FIXME (jchlanda) extend possible values once we start supporting other platforms (for
+        // example: AARCH64_PAUTH_PLATFORM_BAREMETAL = 0x1);
+        const AARCH64_PAUTH_PLATFORM_LLVM_LINUX: u32 = 0x10000002;
+        llvm::add_module_flag_u32(
+            self.llmod,
+            llvm::ModuleFlagMergeBehavior::Error,
+            "aarch64-elf-pauthabi-platform",
+            AARCH64_PAUTH_PLATFORM_LLVM_LINUX,
+        );
+        llvm::add_module_flag_u32(
+            self.llmod,
+            llvm::ModuleFlagMergeBehavior::Error,
+            "aarch64-elf-pauthabi-version",
+            aarch64_elf_pauthabi_version,
+        );
+    }
+
     // We do our best here to match what Clang does when compiling Objective-C natively.
     // See Clang's `CGObjCCommonMac::EmitImageInfo`:
     // https://github.com/llvm/llvm-project/blob/llvmorg-20.1.8/clang/lib/CodeGen/CGObjCMac.cpp#L5085
@@ -889,7 +912,11 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         get_fn(self, instance)
     }
 
-    fn get_fn_addr(&self, instance: Instance<'tcx>, pac: Option<PacMetadata>) -> &'ll Value {
+    fn get_fn_addr(
+        &self,
+        instance: Instance<'tcx>,
+        pointer_auth_schema: Option<&PointerAuthSchema>,
+    ) -> &'ll Value {
         // When pointer authentication metadata is provided, `get_fn_addr` will
         // attempt to sign the pointer using LLVM's `ConstPtrAuth` constant
         // expression.
@@ -903,8 +930,8 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         // <https://github.com/rust-lang/rust/issues/152532>, and comment in
         // builder's `ptrauth_operand_bundle`.
         let llfn = get_fn(self, instance);
-        match pac {
-            Some(pac) => common::maybe_sign_fn_ptr(self, instance, llfn, pac),
+        match pointer_auth_schema {
+            Some(schema) => common::maybe_sign_fn_ptr(self, instance, llfn, schema),
             None => llfn,
         }
     }
@@ -956,7 +983,10 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                     ty::List::empty(),
                     DUMMY_SP,
                 ),
-                Some(PacMetadata::default()),
+                tcx.sess
+                    .pointer_auth_config
+                    .as_ref()
+                    .and_then(|cfg| cfg.function_pointers.as_ref()),
             ),
             _ => {
                 let name = name.unwrap_or("rust_eh_personality");
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 7bd604bdbbd76..7ba6e5babbb5d 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -28,7 +28,7 @@ use rustc_session::lint::builtin::DEPRECATED_LLVM_INTRINSIC;
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 use rustc_symbol_mangling::{mangle_internal_symbol, symbol_name_for_instance_in_crate};
 use rustc_target::callconv::PassMode;
-use rustc_target::spec::{Arch, LlvmAbi};
+use rustc_target::spec::Arch;
 use tracing::debug;
 
 use crate::abi::FnAbiLlvmExt;
@@ -37,7 +37,6 @@ use crate::builder::autodiff::{adjust_activity_to_abi, generate_enzyme_call};
 use crate::builder::gpu_offload::{
     OffloadKernelDims, gen_call_handling, gen_define_handling, register_offload,
 };
-use crate::common::pauth_fn_attrs;
 use crate::context::CodegenCx;
 use crate::declare::declare_raw_fn;
 use crate::errors::{
@@ -1712,9 +1711,12 @@ fn get_rust_try_fn<'a, 'll, 'tcx>(
         hir::Safety::Unsafe,
     ));
     let rust_try = gen_fn(cx, "__rust_try", rust_fn_sig, codegen);
-    if cx.sess().target.llvm_abiname == LlvmAbi::Pauthtest {
+
+    if cx.sess().pointer_authentication() {
+        let cfg = cx.sess().pointer_auth_config.as_ref().unwrap();
         let attrs: Vec<&Attribute> =
-            pauth_fn_attrs().iter().map(|name| llvm::CreateAttrString(cx.llcx, name)).collect();
+            cfg.fn_attrs().into_iter().map(|name| llvm::CreateAttrString(cx.llcx, name)).collect();
+
         let (_ty, rust_try_fn) = rust_try;
         crate::attributes::apply_to_llfn(rust_try_fn, AttributePlace::Function, &attrs);
     }
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 4e979df471318..642a5651bcbe6 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -493,7 +493,10 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         return None;
     }
 
-    let main_llfn = cx.get_fn_addr(instance, Some(PacMetadata::default()));
+    let main_llfn = cx.get_fn_addr(
+        instance,
+        cx.sess().pointer_auth_config.as_ref().and_then(|cfg| cfg.function_pointers.as_ref()),
+    );
 
     let entry_fn = create_entry_fn::<Bx>(cx, main_llfn, main_def_id, entry_type);
     return Some(entry_fn);
@@ -554,7 +557,13 @@ 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, Some(PacMetadata::default()));
+            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 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
index 3a2ff3ab5d2ae..cf3a9bb57313c 100644
--- a/compiler/rustc_codegen_ssa/src/common.rs
+++ b/compiler/rustc_codegen_ssa/src/common.rs
@@ -119,7 +119,10 @@ 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, Some(PacMetadata::default())),
+        bx.get_fn_addr(
+            instance,
+            tcx.sess.pointer_auth_config.as_ref().and_then(|cfg| cfg.function_pointers.as_ref()),
+        ),
         instance,
     )
 }
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index 0173b84a4d9a1..7a82fcf05ebae 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -686,7 +686,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
             _ => (
                 false,
-                bx.get_fn_addr(drop_fn, Some(PacMetadata::default())),
+                bx.get_fn_addr(
+                    drop_fn,
+                    bx.sess()
+                        .pointer_auth_config
+                        .as_ref()
+                        .and_then(|cfg| cfg.function_pointers.as_ref()),
+                ),
                 bx.fn_abi_of_instance(drop_fn, ty::List::empty()),
                 drop_fn,
             ),
@@ -1097,7 +1103,18 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         )
                         .unwrap();
 
-                        (None, Some(bx.get_fn_addr(instance, Some(PacMetadata::default()))))
+                        (
+                            None,
+                            Some(
+                                bx.get_fn_addr(
+                                    instance,
+                                    bx.sess()
+                                        .pointer_auth_config
+                                        .as_ref()
+                                        .and_then(|cfg| cfg.function_pointers.as_ref()),
+                                ),
+                            ),
+                        )
                     }
                     _ => (Some(instance), None),
                 }
@@ -1410,7 +1427,13 @@ 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, Some(PacMetadata::default())),
+            (Some(instance), None) => bx.get_fn_addr(
+                instance,
+                bx.sess()
+                    .pointer_auth_config
+                    .as_ref()
+                    .and_then(|cfg| cfg.function_pointers.as_ref()),
+            ),
             (_, 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
index 49f03fe1376e2..8985326e8531e 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -437,7 +437,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 OperandValue::Immediate(
                                     bx.get_fn_addr(
                                         instance,
-                                        Some(PacMetadata::default()),
+                                        bx.sess()
+                                            .pointer_auth_config
+                                            .as_ref()
+                                            .and_then(|cfg| cfg.function_pointers.as_ref()),
                                     ),
                                 )
                             }
@@ -456,7 +459,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 OperandValue::Immediate(
                                     bx.cx().get_fn_addr(
                                         instance,
-                                        Some(PacMetadata::default()),
+                                        bx.sess()
+                                            .pointer_auth_config
+                                            .as_ref()
+                                            .and_then(|cfg| cfg.function_pointers.as_ref()),
                                     ),
                                 )
                             }
@@ -678,7 +684,13 @@ 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, Some(PacMetadata::default()));
+                    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_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_codegen_ssa/src/traits/consts.rs b/compiler/rustc_codegen_ssa/src/traits/consts.rs
index 20738ba79e9fb..b4eba38d39c19 100644
--- a/compiler/rustc_codegen_ssa/src/traits/consts.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/consts.rs
@@ -1,8 +1,8 @@
 use rustc_abi as abi;
 use rustc_middle::mir::interpret::Scalar;
+use rustc_session::PointerAuthSchema;
 
 use super::BackendTypes;
-use crate::traits::PacMetadata;
 
 pub trait ConstCodegenMethods: BackendTypes {
     // Constant constructors
@@ -47,7 +47,7 @@ pub trait ConstCodegenMethods: BackendTypes {
         cv: Scalar,
         layout: abi::Scalar,
         llty: Self::Type,
-        pac: Option<PacMetadata>,
+        schema: Option<&PointerAuthSchema>,
     ) -> Self::Value;
 
     fn const_ptr_byte_offset(&self, val: Self::Value, offset: abi::Size) -> Self::Value;
diff --git a/compiler/rustc_codegen_ssa/src/traits/misc.rs b/compiler/rustc_codegen_ssa/src/traits/misc.rs
index ecef986b55855..add7128a2974b 100644
--- a/compiler/rustc_codegen_ssa/src/traits/misc.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/misc.rs
@@ -2,40 +2,11 @@ use std::cell::RefCell;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_middle::ty::{self, Instance, Ty};
-use rustc_session::Session;
+use rustc_session::{PointerAuthSchema, Session};
 use rustc_span::Symbol;
 
 use super::BackendTypes;
 
-/// Strategy for incorporating address-based diversity into PAC computation.
-#[derive(Default)]
-pub enum AddressDiversity {
-    /// No address diversity is applied.
-    #[default]
-    None,
-    /// Use the actual memory address for diversification.
-    Real,
-    /// Use a fixed synthetic value instead of the real address,
-    /// i.e. `1` is used for `.init_array` / `.fini_array`.
-    Synthetic(u64),
-}
-
-/// Metadata used for pointer authentication.
-pub struct PacMetadata {
-    /// The PAC key to use.
-    pub key: u32,
-    /// Discriminator value used to diversify the PAC.
-    pub disc: u64,
-    /// Controls how address diversity is applied when computing the PAC.
-    pub addr_diversity: AddressDiversity,
-}
-
-impl Default for PacMetadata {
-    fn default() -> Self {
-        PacMetadata { key: 0, disc: 0, addr_diversity: AddressDiversity::default() }
-    }
-}
-
 pub trait MiscCodegenMethods<'tcx>: BackendTypes {
     fn vtables(
         &self,
@@ -48,7 +19,11 @@ pub trait MiscCodegenMethods<'tcx>: BackendTypes {
     ) {
     }
     fn get_fn(&self, instance: Instance<'tcx>) -> Self::Function;
-    fn get_fn_addr(&self, instance: Instance<'tcx>, pac: Option<PacMetadata>) -> Self::Value;
+    fn get_fn_addr(
+        &self,
+        instance: Instance<'tcx>,
+        pointer_auth_schema: Option<&PointerAuthSchema>,
+    ) -> Self::Value;
     fn eh_personality(&self) -> Self::Function;
     fn sess(&self) -> &Session;
     fn set_frame_pointer_type(&self, llfn: Self::Function);
diff --git a/compiler/rustc_codegen_ssa/src/traits/mod.rs b/compiler/rustc_codegen_ssa/src/traits/mod.rs
index ed2dad5a510cd..f46d07ea5008e 100644
--- a/compiler/rustc_codegen_ssa/src/traits/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/mod.rs
@@ -42,7 +42,7 @@ pub use self::coverageinfo::CoverageInfoBuilderMethods;
 pub use self::debuginfo::{DebugInfoBuilderMethods, DebugInfoCodegenMethods};
 pub use self::declare::PreDefineCodegenMethods;
 pub use self::intrinsic::IntrinsicCallBuilderMethods;
-pub use self::misc::{AddressDiversity, MiscCodegenMethods, PacMetadata};
+pub use self::misc::MiscCodegenMethods;
 pub use self::statics::{StaticBuilderMethods, StaticCodegenMethods};
 pub use self::type_::{
     ArgAbiBuilderMethods, BaseTypeCodegenMethods, DerivedTypeCodegenMethods,
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index c7da2d9a1fc38..2912e5b1f2413 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -1602,6 +1602,46 @@ pub struct BranchProtection {
     pub gcs: bool,
 }
 
+#[derive(Clone, Copy, Hash, Debug, 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.
+    Aarch64JumpTableHardening,
+    AuthTraps,
+    Calls,
+    ElfGot,
+    FunctionPointerTypeDiscrimination,
+    IndirectGotos,
+    InitFini,
+    InitFiniAddressDiscrimination,
+    Intrinsics,
+    ReturnAddresses,
+    TypeInfoVTPtrDisc,
+    VTPtrAddrDisc,
+    VTPtrTypeDisc,
+}
+impl PointerAuthOption {
+    pub fn parse(s: &str) -> Option<Self> {
+        match s {
+            "aarch64-jump-table-hardening" => Some(Self::Aarch64JumpTableHardening),
+            "auth-traps" => Some(Self::AuthTraps),
+            "calls" => Some(Self::Calls),
+            "elf-got" => Some(Self::ElfGot),
+            "function-pointer-type-discrimination" => Some(Self::FunctionPointerTypeDiscrimination),
+            "indirect-gotos" => Some(Self::IndirectGotos),
+            "init-fini" => Some(Self::InitFini),
+            "init-fini-address-discrimination" => Some(Self::InitFiniAddressDiscrimination),
+            "intrinsics" => Some(Self::Intrinsics),
+            "return-addresses" => Some(Self::ReturnAddresses),
+            "typeinfo-vt-ptr-discrimination" => Some(Self::TypeInfoVTPtrDisc),
+            "vt-ptr-addr-discrimination" => Some(Self::VTPtrAddrDisc),
+            "vt-ptr-type-discrimination" => Some(Self::VTPtrTypeDisc),
+            _ => None,
+        }
+    }
+}
+
 pub fn build_configuration(sess: &Session, mut user_cfg: Cfg) -> Cfg {
     // First disallow some configuration given on the command line
     cfg::disallow_cfgs(sess, &user_cfg);
@@ -3098,8 +3138,8 @@ pub(crate) mod dep_tracking {
         CoverageOptions, CrateType, DebugInfo, DebugInfoCompression, ErrorOutputType, FmtDebug,
         FunctionReturn, InliningThreshold, InstrumentCoverage, InstrumentMcount, InstrumentXRay,
         LinkerPluginLto, LocationDetail, LtoCli, MirStripDebugInfo, NextSolverConfig, Offload,
-        OptLevel, OutFileName, OutputType, OutputTypes, PatchableFunctionEntry, Polonius,
-        ResolveDocLinks, SourceFileHashAlgorithm, SplitDwarfKind, SwitchWithOptPath,
+        OptLevel, OutFileName, OutputType, OutputTypes, PatchableFunctionEntry, PointerAuthOption,
+        Polonius, ResolveDocLinks, SourceFileHashAlgorithm, SplitDwarfKind, SwitchWithOptPath,
         SymbolManglingVersion, WasiExecModel,
     };
     use crate::lint;
@@ -3207,6 +3247,7 @@ pub(crate) mod dep_tracking {
         Align,
         CodegenRetagOptions,
         RustcVersion,
+        PointerAuthOption,
     );
 
     impl<T1, T2> DepTrackingHash for (T1, T2)
diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs
index 31627887b662b..d1989609cefe2 100644
--- a/compiler/rustc_session/src/errors.rs
+++ b/compiler/rustc_session/src/errors.rs
@@ -381,6 +381,20 @@ pub(crate) struct StackProtectorNotSupportedForTarget<'a> {
     pub(crate) target_triple: &'a TargetTuple,
 }
 
+#[derive(Diagnostic)]
+#[diag("function pointer type discrimination is not supported")]
+pub(crate) struct PointerAuthenticationTypeDiscriminationNotSupportedForTarget<'a> {
+    pub(crate) target_triple: &'a TargetTuple,
+}
+
+#[derive(Diagnostic)]
+#[diag(
+    "`-Z pointer-authentication` is not supported for target {$target_triple} and will be ignored"
+)]
+pub(crate) struct PointerAuthenticationNotSupportedForTarget<'a> {
+    pub(crate) target_triple: &'a TargetTuple,
+}
+
 #[derive(Diagnostic)]
 #[diag(
     "`-Z small-data-threshold` is not supported for target {$target_triple} and will be ignored"
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 7e878cc220a0f..94876490f0306 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -771,6 +771,7 @@ mod desc {
     pub(crate) const parse_list: &str = "a space-separated list of strings";
     pub(crate) const parse_list_with_polarity: &str =
         "a comma-separated list of strings, with elements beginning with + or -";
+    pub(crate) const parse_pointer_authentication_list_with_polarity: &str = "a comma-separated list of options, each of the form `+<name>` or `-<name>`, where `<name>` is one of: `aarch64-jump-table-hardening`, `auth-traps`, `calls`, `elf-got`, `function-pointer-type-discrimination`, `indirect-gotos`, `init-fini`, `init-fini-address-discrimination`, `intrinsics`, `return-addresses`, `typeinfo-vt-ptr-discrimination`, `vt-ptr-addr-discrimination` or `vt-ptr-type-discrimination`";
     pub(crate) const parse_autodiff: &str = "a comma separated list of settings: `Enable`, `PrintSteps`, `PrintTA`, `PrintTAFn`, `PrintAA`, `PrintPerf`, `PrintModBefore`, `PrintModAfter`, `PrintModFinal`, `PrintPasses`, `NoPostopt`, `LooseTypes`, `Inline`, `NoTT`";
     pub(crate) const parse_offload: &str =
         "a comma separated list of settings: `Host=<Absolute-Path>`, `Device`, `Test`";
@@ -1036,6 +1037,28 @@ pub mod parse {
         }
     }
 
+    pub(crate) fn parse_pointer_authentication_list_with_polarity(
+        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,
+        }
+    }
+
     pub(crate) fn parse_fmt_debug(opt: &mut FmtDebug, v: Option<&str>) -> bool {
         *opt = match v {
             Some("full") => FmtDebug::Full,
@@ -2617,6 +2640,22 @@ 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],
+        "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
+        `calls` - enable signing and authentication of all indirect calls
+        `elf-got` - enable authentication of pointers from GOT (ELF only)
+        `function-pointer-type-discrimination` - enable type discrimination on C function pointers
+        `indirect-gotos` - enable signing and authentication of indirect goto targets
+        `init-fini` - enable signing of function pointers in init/fini arrays
+        `init-fini-address-discrimination` - enable address discrimination in init/fini arrays
+        `intrinsics` - pointer authentication intrinsics
+        `return-addresses` - enable signing and authentication of return addresses
+        `typeinfo-vt-ptr-discrimination - incorporate type and address discrimination in authenticated vtable pointers for std::type_info
+        `vt-ptr-addr-discrimination - incorporate address discrimination in authenticated vtable pointers
+        `vt-ptr-type-discrimination - incorporate type discrimination in authenticated vtable pointers
+        Example: `-Zpointer-authentication=+calls,-init-fini`."),
     polonius: Polonius = (Polonius::default(), parse_polonius, [TRACKED],
         "enable polonius-based borrow-checker (default: no)"),
     pre_link_arg: (/* redirected to pre_link_args */) = ((), parse_string_push, [UNTRACKED],
@@ -2650,7 +2689,6 @@ options! {
         "use the given `.prof` file for sampled profile-guided optimization (also known as AutoFDO)"),
     profiler_runtime: String = (String::from("profiler_builtins"), parse_string, [TRACKED],
         "name of the profiler runtime crate to automatically inject (default: `profiler_builtins`)"),
-    ptrauth_elf_got: bool = (false, parse_bool, [TRACKED], "enable signing of ELF GOT entries"),
     query_dep_graph: bool = (false, parse_bool, [UNTRACKED],
         "enable queries of the dependency graph for regression testing (default: no)"),
     randomize_layout: bool = (false, parse_bool, [TRACKED],
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 986dababf770a..97b9abf399edc 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -39,7 +39,7 @@ pub use crate::code_stats::{DataTypeKind, FieldInfo, FieldKind, SizeKind, Varian
 use crate::config::{
     self, Cfg, CheckCfg, CoverageLevel, CoverageOptions, CrateType, DebugInfo, ErrorOutputType,
     FunctionReturn, Input, InstrumentCoverage, InstrumentMcount, OptLevel, OutFileName, OutputType,
-    SwitchWithOptPath,
+    PointerAuthOption, SwitchWithOptPath,
 };
 use crate::filesearch::FileSearch;
 use crate::lint::LintId;
@@ -85,6 +85,245 @@ pub trait DynLintStore: Any + DynSync + DynSend {
     fn lint_groups_iter(&self) -> Box<dyn Iterator<Item = LintGroup> + '_>;
 }
 
+/// Hardware pointer-signing keys in ARM8.3.
+/// These values are the same as used in ptrauth.h.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PointerAuthARM8_3Key {
+    ASIA = 0,
+    ASIB = 1,
+    ASDA = 2,
+    ASDB = 3,
+}
+
+/// Forms of extra discrimination.
+pub enum PointerAuthDiscrimination {
+    /// No additional discrimination.
+    None,
+    /// Include a hash of the entity's type.
+    Type,
+    /// Include a hash of the entity's identity.
+    Decl,
+    /// Discriminate using a constant value.
+    Constant,
+}
+
+/// Types of address discrimination.
+pub enum PointerAuthAddressDiscriminator {
+    /// Enable/disable hardware address discrimination.
+    HardwareAddress(bool),
+    /// Use a synthetic value. For instance init/fini entries can not the address of the arrays,
+    /// they must use a synthetic value of `1`.
+    Synthetic(u64),
+}
+
+pub struct PointerAuthSchema {
+    pub is_address_discriminated: PointerAuthAddressDiscriminator,
+    pub discrimination_kind: PointerAuthDiscrimination,
+    pub key: PointerAuthARM8_3Key,
+    pub constant_discriminator: u16,
+}
+impl PointerAuthSchema {
+    pub fn function_pointers_default(target: &Target) -> Self {
+        assert!(target.cfg_abi == CfgAbi::Pauthtest);
+        return Self {
+            is_address_discriminated: PointerAuthAddressDiscriminator::HardwareAddress(false),
+            discrimination_kind: PointerAuthDiscrimination::None,
+            key: PointerAuthARM8_3Key::ASIA,
+            constant_discriminator: 0,
+        };
+    }
+    pub fn init_fini_default(target: &Target) -> Self {
+        assert!(target.cfg_abi == CfgAbi::Pauthtest);
+        return Self {
+            is_address_discriminated: PointerAuthAddressDiscriminator::Synthetic(1),
+            discrimination_kind: PointerAuthDiscrimination::None,
+            key: PointerAuthARM8_3Key::ASIA,
+            // ptrauth_string_discriminator("init_fini")
+            constant_discriminator: 0xd9d4,
+        };
+    }
+}
+
+pub struct PointerAuthConfig {
+    /// Should return addresses be authenticated?
+    pub return_addresses: bool,
+    /// Do authentication failures cause a trap?
+    pub auth_traps: bool,
+    /// Do indirect goto label addresses need to be authenticated?
+    pub indirect_gotos: bool,
+    /// Should ELF GOT entries be signed?
+    pub elf_got: bool,
+    /// Use hardened lowering for jump-table dispatch?
+    pub aarch64_jump_table_hardening: bool,
+    /// The ABI for C function pointers.
+    pub function_pointers: Option<PointerAuthSchema>,
+    /// The ABI for function addresses in .init_array and .fini_array
+    pub init_fini: Option<PointerAuthSchema>,
+    /// Use of pointer authentication intrinsics.
+    pub intrinsics: bool,
+    /// The following are used only for compatibility with C++ and control over generated abi
+    /// version. They do not control Rust code generation.
+    pub typeinfo_vt_ptr_discrimination: bool,
+    pub vt_ptr_addr_discrimination: bool,
+    pub vt_ptr_type_discrimination: bool,
+}
+impl PointerAuthConfig {
+    fn default(target: &Target) -> Self {
+        assert!(target.cfg_abi == CfgAbi::Pauthtest);
+        return Self {
+            return_addresses: true,
+            auth_traps: true,
+            indirect_gotos: true,
+            elf_got: false,
+            aarch64_jump_table_hardening: true,
+            function_pointers: Some(PointerAuthSchema::function_pointers_default(target)),
+            init_fini: Some(PointerAuthSchema::init_fini_default(target)),
+            intrinsics: true,
+            typeinfo_vt_ptr_discrimination: true,
+            vt_ptr_addr_discrimination: true,
+            vt_ptr_type_discrimination: true,
+        };
+    }
+    pub fn calculate_pauth_abi_version(&self, target: &Target) -> u32 {
+        assert!(target.cfg_abi == CfgAbi::Pauthtest);
+        // Bit positions of version flags for AARCH64_PAUTH_PLATFORM_LLVM_LINUX.
+        // NOTE: The enum values must stay in sync with clang, see:
+        // <llvm_root>/llvm/include/llvm/BinaryFormat/ELF.h
+        //
+        // We do not expect to use C++ virtual dispatch, but enable these flags
+        // for compatibility with C++ code. Intrinsics are also always enabled.
+        //
+        // Link to PAuth core info documentation:
+        // <https://github.com/ARM-software/abi-aa/blob/2025Q4/pauthabielf64/pauthabielf64.rst#core-information>
+        const INTRINSICS: u32 = 0;
+        const CALLS: u32 = 1;
+        const RETURNS: u32 = 2;
+        const AUTHTRAPS: u32 = 3;
+        const VT_PTR_ADDR_DISCR: u32 = 4;
+        const VT_PTR_TYPE_DISCR: u32 = 5;
+        const INIT_FINI: u32 = 6;
+        const INIT_FINI_ADDR_DISC: u32 = 7;
+        const GOT: u32 = 8;
+        const GOTOS: u32 = 9;
+        const TYPEINFO_VT_PTR_DISCR: u32 = 10;
+        // FIXME(jchlanda) We don't yet support function pointer type discrimination.
+        // const FPTR_TYPE_DISCR: u32 = 11;
+
+        let pauth_abi_version: u32 = (u32::from(self.intrinsics) << INTRINSICS)
+            | (u32::from(self.function_pointers.is_some()) << CALLS)
+            | (u32::from(self.return_addresses) << RETURNS)
+            | (u32::from(self.auth_traps) << AUTHTRAPS)
+            | (u32::from(self.vt_ptr_addr_discrimination) << VT_PTR_ADDR_DISCR)
+            | (u32::from(self.vt_ptr_type_discrimination) << VT_PTR_TYPE_DISCR)
+            | (u32::from(self.init_fini.is_some()) << INIT_FINI)
+            | (u32::from(self.init_fini.as_ref().is_some_and(|schema| {
+                matches!(
+                    schema.is_address_discriminated,
+                    PointerAuthAddressDiscriminator::HardwareAddress(true)
+                        | PointerAuthAddressDiscriminator::Synthetic(_)
+                )
+            })) << INIT_FINI_ADDR_DISC)
+            | (u32::from(self.elf_got) << GOT)
+            | (u32::from(self.indirect_gotos) << GOTOS)
+            | (u32::from(self.typeinfo_vt_ptr_discrimination) << TYPEINFO_VT_PTR_DISCR);
+
+        pauth_abi_version
+    }
+    pub fn from_raw(raw: &[(PointerAuthOption, bool)], target: &Target) -> Option<Self> {
+        if target.cfg_abi != CfgAbi::Pauthtest {
+            return None;
+        }
+
+        let mut cfg = Self::default(target);
+        if raw.is_empty() {
+            return Some(cfg);
+        }
+
+        for (opt, enabled) in raw {
+            match opt {
+                PointerAuthOption::Calls => {
+                    if *enabled {
+                        cfg.function_pointers.get_or_insert_with(|| {
+                            PointerAuthSchema::function_pointers_default(target)
+                        });
+                    } else {
+                        cfg.function_pointers = None;
+                    }
+                }
+                PointerAuthOption::FunctionPointerTypeDiscrimination => {
+                    if *enabled {
+                        let schema = cfg.function_pointers.get_or_insert_with(|| {
+                            PointerAuthSchema::function_pointers_default(target)
+                        });
+                        schema.discrimination_kind = PointerAuthDiscrimination::Type;
+                    } else if let Some(schema) = &mut cfg.function_pointers {
+                        schema.discrimination_kind = PointerAuthDiscrimination::None;
+                    }
+                }
+                PointerAuthOption::ReturnAddresses => cfg.return_addresses = *enabled,
+                PointerAuthOption::AuthTraps => cfg.auth_traps = *enabled,
+                PointerAuthOption::IndirectGotos => cfg.indirect_gotos = *enabled,
+                PointerAuthOption::ElfGot => cfg.elf_got = *enabled,
+                PointerAuthOption::Aarch64JumpTableHardening => {
+                    cfg.aarch64_jump_table_hardening = *enabled
+                }
+                PointerAuthOption::InitFini => {
+                    if *enabled {
+                        cfg.init_fini
+                            .get_or_insert_with(|| PointerAuthSchema::init_fini_default(target));
+                    } else {
+                        cfg.init_fini = None;
+                    }
+                }
+                PointerAuthOption::InitFiniAddressDiscrimination => {
+                    if *enabled {
+                        let schema = cfg
+                            .init_fini
+                            .get_or_insert_with(|| PointerAuthSchema::init_fini_default(target));
+                        schema.is_address_discriminated =
+                            PointerAuthAddressDiscriminator::HardwareAddress(true);
+                    } else if let Some(schema) = &mut cfg.init_fini {
+                        schema.is_address_discriminated =
+                            PointerAuthAddressDiscriminator::Synthetic(1);
+                    }
+                }
+
+                PointerAuthOption::Intrinsics => cfg.intrinsics = *enabled,
+                PointerAuthOption::TypeInfoVTPtrDisc => {
+                    cfg.typeinfo_vt_ptr_discrimination = *enabled
+                }
+                PointerAuthOption::VTPtrAddrDisc => cfg.vt_ptr_addr_discrimination = *enabled,
+                PointerAuthOption::VTPtrTypeDisc => cfg.vt_ptr_type_discrimination = *enabled,
+            }
+        }
+
+        Some(cfg)
+    }
+    pub fn fn_attrs(&self) -> Vec<&'static str> {
+        // FIXME(jchlanda) This is not an exhaustive list of all `ptrauth`-related attributes, but only
+        // those currently supported. The list is expected to grow as additional functionality is
+        // implemented, particularly for C++ interoperability.
+        let mut attrs = vec![];
+        if self.aarch64_jump_table_hardening {
+            attrs.push("aarch64-jump-table-hardening");
+        }
+        if self.auth_traps {
+            attrs.push("ptrauth-auth-traps");
+        }
+        if self.function_pointers.is_some() {
+            attrs.push("ptrauth-calls");
+        }
+        if self.indirect_gotos {
+            attrs.push("ptrauth-indirect-gotos");
+        }
+        if self.return_addresses {
+            attrs.push("ptrauth-returns");
+        }
+
+        attrs
+    }
+}
+
 /// Represents the data associated with a compilation
 /// session for a single crate.
 pub struct Session {
@@ -185,6 +424,9 @@ pub struct Session {
     /// Whether the test harness removed a user-written `#[rustc_main]` attribute
     /// while generating the synthetic test entry point.
     pub removed_rustc_main_attr: AtomicBool,
+
+    /// Config specifying targets' pointer authentication preference.
+    pub pointer_auth_config: Option<PointerAuthConfig>,
 }
 
 #[derive(Clone, Copy)]
@@ -945,6 +1187,18 @@ impl Session {
     pub fn sanitizers(&self) -> SanitizerSet {
         return self.opts.unstable_opts.sanitizer | self.target.options.default_sanitizers;
     }
+
+    pub fn pointer_authentication(&self) -> bool {
+        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_init_fini(&self) -> bool {
+        self.pointer_auth_config.as_ref().and_then(|cfg| cfg.init_fini.as_ref()).is_some()
+    }
 }
 
 // JUSTIFICATION: part of session construction
@@ -1104,6 +1358,9 @@ pub fn build_session(
 
     let timings = TimingSectionHandler::new(sopts.json_timings);
 
+    let pointer_auth_config: Option<PointerAuthConfig> =
+        PointerAuthConfig::from_raw(&sopts.unstable_opts.pointer_authentication, &target);
+
     let sess = Session {
         target,
         host,
@@ -1138,6 +1395,7 @@ pub fn build_session(
         mir_opt_bisect_eval_count: AtomicUsize::new(0),
         used_features: Lock::default(),
         removed_rustc_main_attr: AtomicBool::new(false),
+        pointer_auth_config,
     };
 
     validate_commandline_args_with_session_available(&sess);
@@ -1170,6 +1428,25 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
         sess.dcx().emit_err(errors::LinkerPluginToWindowsNotSupported);
     }
 
+    if sess
+        .pointer_auth_config
+        .as_ref()
+        .and_then(|cfg| cfg.function_pointers.as_ref())
+        .is_some_and(|schema| matches!(schema.discrimination_kind, PointerAuthDiscrimination::Type))
+    {
+        sess.dcx().emit_err(errors::PointerAuthenticationTypeDiscriminationNotSupportedForTarget {
+            target_triple: &sess.opts.target_triple,
+        });
+    }
+
+    if sess.target.cfg_abi != CfgAbi::Pauthtest
+        && !sess.opts.unstable_opts.pointer_authentication.is_empty()
+    {
+        sess.dcx().emit_warn(errors::PointerAuthenticationNotSupportedForTarget {
+            target_triple: &sess.opts.target_triple,
+        });
+    }
+
     // Make sure that any given profiling data actually exists so LLVM can't
     // decide to silently skip PGO.
     if let Some(ref path) = sess.opts.cg.profile_use {
diff --git a/library/std/src/sys/personality/gcc.rs b/library/std/src/sys/personality/gcc.rs
index 019d5629d6d6e..549d3ec1313c6 100644
--- a/library/std/src/sys/personality/gcc.rs
+++ b/library/std/src/sys/personality/gcc.rs
@@ -89,6 +89,34 @@ const UNWIND_DATA_REG: (i32, i32) = (10, 11); // x10, x11
 #[cfg(any(target_arch = "loongarch32", target_arch = "loongarch64"))]
 const UNWIND_DATA_REG: (i32, i32) = (4, 5); // a0, a1
 
+unsafe fn sign_lpad(context: *mut uw::_Unwind_Context, lpad: *const u8) -> *const u8 {
+    cfg_select! {
+        all(target_abi = "pauthtest", target_arch = "aarch64") => {
+            // DWARF register number for SP on AArch64.
+            const SP_REG: i32 = 31;
+
+            unsafe {
+                let sp = uw::_Unwind_GetGR(context, SP_REG).addr() as u64;
+                let mut addr = lpad.addr();
+
+                // `pacib` corresponds to `ptrauth_key_process_dependent_code` in <ptrauth.h>.
+                core::arch::asm!(
+                    "pacib {addr}, {sp}",
+                    addr = inout(reg) addr,
+                    sp = in(reg) sp,
+                    options(nostack, preserves_flags)
+                );
+
+                lpad.with_addr(addr)
+            }
+        }
+        _ => {
+            let _ = context;
+            lpad
+        }
+    }
+}
+
 // The following code is based on GCC's C and C++ personality routines.  For reference, see:
 // https://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_personality.cc
 // https://github.com/gcc-mirror/gcc/blob/trunk/libgcc/unwind-c.c
@@ -239,7 +267,8 @@ cfg_select! {
                                 exception_object.cast(),
                             );
                             uw::_Unwind_SetGR(context, UNWIND_DATA_REG.1, core::ptr::null());
-                            uw::_Unwind_SetIP(context, lpad);
+                            let maybe_signed_lpad = sign_lpad(context, lpad);
+                            uw::_Unwind_SetIP(context, maybe_signed_lpad);
                             uw::_URC_INSTALL_CONTEXT
                         }
                         EHAction::Terminate => uw::_URC_FATAL_PHASE2_ERROR,
diff --git a/library/std/tests/pipe_subprocess.rs b/library/std/tests/pipe_subprocess.rs
index dad1ea6c57377..6cc9303f5eea1 100644
--- a/library/std/tests/pipe_subprocess.rs
+++ b/library/std/tests/pipe_subprocess.rs
@@ -13,10 +13,15 @@ fn main() {
 
         fn parent() {
             let me = env::current_exe().unwrap();
+            // If `runner` is set up for current target, we'll be executing `./runner ./test`, not
+            // just `./test`. For such a case, use the same arguments for child to avoid executing
+            // `runner` without actual executable.
+            let args = env::args();
 
             let (rx, tx) = pipe().unwrap();
             assert!(
                 process::Command::new(me)
+                    .args(args)
                     .env("I_AM_THE_CHILD", "1")
                     .stdout(tx)
                     .status()
diff --git a/library/std/tests/process_spawning.rs b/library/std/tests/process_spawning.rs
index 93f73ccad3ea4..b1973b54d7670 100644
--- a/library/std/tests/process_spawning.rs
+++ b/library/std/tests/process_spawning.rs
@@ -26,8 +26,16 @@ fn issue_15149() {
         env::join_paths(paths).unwrap()
     };
 
-    let child_output =
-        process::Command::new("mytest").env("PATH", &path).arg("child").output().unwrap();
+    // If `runner` is set up for current target, we'll be executing `./runner ./test`, not
+    // just `./test`. For such a case, use the same arguments for child to avoid executing
+    // `runner` without actual executable.
+    let args = env::args();
+    let child_output = process::Command::new("mytest")
+        .args(args)
+        .env("PATH", &path)
+        .arg("child")
+        .output()
+        .unwrap();
 
     assert!(
         child_output.status.success(),
diff --git a/library/unwind/src/lib.rs b/library/unwind/src/lib.rs
index 4e380d8894781..1bc8d1ab81fb5 100644
--- a/library/unwind/src/lib.rs
+++ b/library/unwind/src/lib.rs
@@ -56,7 +56,12 @@ cfg_select! {
     }
 }
 
-#[cfg(target_env = "musl")]
+// For pauthtest the only supported unwinding mechanism is provided by libunwind.
+#[cfg(target_abi = "pauthtest")]
+#[link(name = "unwind")]
+unsafe extern "C" {}
+
+#[cfg(all(target_env = "musl", not(target_abi = "pauthtest")))]
 cfg_select! {
     all(feature = "llvm-libunwind", feature = "system-llvm-libunwind") => {
         compile_error!("`llvm-libunwind` and `system-llvm-libunwind` cannot be enabled at the same time");
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
index 558bc409e08d2..89acecf4b65ec 100644
--- a/src/doc/rustc/src/platform-support/aarch64-unknown-linux-pauthtest.md
+++ b/src/doc/rustc/src/platform-support/aarch64-unknown-linux-pauthtest.md
@@ -356,6 +356,53 @@ linker = "<path_to>/aarch64-unknown-linux-pauthtest-clang"
 Without it Cargo falls back to the system C toolchain (cc) and the compilation
 fails.
 
+## Controlling pointer authentication features
+
+Pointer authentication behavior for this target can be configured using the
+`-Zpointer-authentication` compiler option. The option accepts a comma-separated
+list of values, each of the form `+<name>` - to enable, or `-<name>` - to
+disable a feature, where `<name>` is one of:
+* `aarch64-jump-table-hardening` - enable hardened lowering for jump-table
+  dispatch
+* `auth-traps` - trap immediately on pointer authentication failure
+* `calls` - enable signing and authentication of indirect calls
+* `elf-got` - enable authentication of pointers loaded from the ELF GOT
+* `function-pointer-type-discrimination` - enable type discrimination for C
+  function pointers
+* `indirect-gotos` - enable signing and authentication of indirect goto targets
+* `init-fini` - enable signing of function pointers stored in init/fini arrays
+* `init-fini-address-discrimination` - enable address discrimination for
+  init/fini array entries
+* `intrinsics` - enable pointer authentication intrinsics
+* `return-addresses` - enable signing and authentication of return addresses
+* `typeinfo-vt-ptr-discrimination` - enable type/address discrimination for
+  authenticated `std::type_info` virtual table pointers
+* `vt-ptr-addr-discrimination` - enable address discrimination for authenticated
+  virtual table pointers
+* `vt-ptr-type-discrimination` - enable type discrimination for authenticated
+  virtual table pointers
+For example:
+`-Zpointer-authentication=+calls,+return-addresses,-init-fini`.
+
+Not all options are currently meaningful for Rust code itself. In particular,
+the virtual table related ones: `typeinfo-vt-ptr-discrimination`,
+`vt-ptr-addr-discrimination`, `vt-ptr-type-discrimination` exist primarily for
+interoperability with C++ code and compatibility with the AArch64 Pointer
+Authentication ELF ABI. Rust does not implement C++ virtual dispatch semantics,
+authenticated C++ member function pointers, or authenticated virtual table
+pointers.
+
+Similarly, `function-pointer-type-discrimination` is recognized for ABI
+compatibility purposes, but full support is not yet implemented in Rust.
+
+Even when these features do not directly affect generated Rust code, they still
+contribute to the emitted PAuth ABI metadata through the LLVM module flags:
+`aarch64-elf-pauthabi-platform`, `aarch64-elf-pauthabi-version`. These flags are
+emitted to communicate pointer authentication ABI requirements to the linker and
+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.
+
 ## Cross-compilation toolchains and C code
 
 This target supports interoperability with C code. A
@@ -391,9 +438,12 @@ The following categories are supported (all present in tree):
 * End-to-end execution tests
   * Rust-driven quicksort (pauth-quicksort-rust-driver)
   * C-driven quicksort (pauth-quicksort-c-driver)
-* UI error/warning reporting (the target does not support static linking)
+* UI error/warning reporting
   * crt-static-pauthtest.rs
   * pauth-static-link-warning
+  * enable_pointer_authentication_validation.rs
+  * invalid_target_pointer_authentication.rs
+  * type_discrimination_not_supported_pointer_authentication.rs
 
 All tests from `assembly-llvm`, `codegen-llvm`, `codegen-units`, `coverage`,
 `crashes`, `incremental`, `library`, `mir-opt`, `run-make`, `ui` and
@@ -407,6 +457,7 @@ x.py test --target aarch64-unknown-linux-pauthtest --force-rerun assembly-llvm \
   codegen-llvm codegen-units coverage crashes incremental library mir-opt \
   run-make ui ui-fulldeps \
   tests/assembly-llvm/pauth-basic.rs \
+  tests/codegen-llvm/pauth/pauth-attr-cli-flags.rs \
   tests/codegen-llvm/pauth/pauth-attr-special-funcs.rs \
   tests/codegen-llvm/pauth/pauth-extern-c.rs \
   tests/codegen-llvm/pauth/pauth-extern-c-direct-indirect-call.rs \
@@ -415,7 +466,10 @@ x.py test --target aarch64-unknown-linux-pauthtest --force-rerun assembly-llvm \
   tests/run-make/pauth-quicksort-rust-driver \
   tests/run-make/pauth-quicksort-c-driver \
   tests/run-make/pauth-static-link-warning \
-  tests/ui/statics/crt-static-pauthtest.rs
+  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
 ```
 
 ## Limitations
diff --git a/tests/codegen-llvm/pauth/pauth-attr-cli-flags.rs b/tests/codegen-llvm/pauth/pauth-attr-cli-flags.rs
new file mode 100644
index 0000000000000..3fe8df0c1bdcc
--- /dev/null
+++ b/tests/codegen-llvm/pauth/pauth-attr-cli-flags.rs
@@ -0,0 +1,118 @@
+// ignore-tidy-linelength
+//@ 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
+
+//@[DEFAULT] needs-llvm-components: aarch64
+//@[DEFAULT] compile-flags: --target=aarch64-unknown-linux-pauthtest
+//@[ALL] needs-llvm-components: aarch64
+//@[ALL] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=+aarch64-jump-table-hardening,+auth-traps,+calls,+indirect-gotos,+return-addresses
+//@[DISABLE_JUMP] needs-llvm-components: aarch64
+//@[DISABLE_JUMP] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=-aarch64-jump-table-hardening
+//@[DISABLE_AUTH_TRAPS] needs-llvm-components: aarch64
+//@[DISABLE_AUTH_TRAPS] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=-auth-traps
+//@[DISABLE_CALLS] needs-llvm-components: aarch64
+//@[DISABLE_CALLS] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=-calls
+//@[DISABLE_INDIRCT_GOTOS] needs-llvm-components: aarch64
+//@[DISABLE_INDIRCT_GOTOS] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=-indirect-gotos
+//@[DISABLE_RETURNS] needs-llvm-components: aarch64
+//@[DISABLE_RETURNS] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=-return-addresses
+//@[DISABLE_INTRINSICS] needs-llvm-components: aarch64
+//@[DISABLE_INTRINSICS] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=-intrinsics
+//@[DISABLE_TYPEINFO] needs-llvm-components: aarch64
+//@[DISABLE_TYPEINFO] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=-typeinfo-vt-ptr-discrimination
+//@[DISABLE_VT_PTR_ADDR] needs-llvm-components: aarch64
+//@[DISABLE_VT_PTR_ADDR] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=-vt-ptr-addr-discrimination
+//@[DISABLE_VT_PTR_TYPE] needs-llvm-components: aarch64
+//@[DISABLE_VT_PTR_TYPE] compile-flags: --target=aarch64-unknown-linux-pauthtest -Zpointer-authentication=-vt-ptr-type-discrimination
+//@[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() {}
+// DEFAULT: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
+// DEFAULT-SAME: "ptrauth-auth-traps"
+// DEFAULT-SAME: "ptrauth-calls"
+// DEFAULT-SAME: "ptrauth-indirect-gotos"
+// DEFAULT-SAME: "ptrauth-returns"
+// DEFAULT: !{i32 1, !"aarch64-elf-pauthabi-platform", i32 268435458}
+// DEFAULT-NEXT: !{i32 1, !"aarch64-elf-pauthabi-version", i32 1791}
+
+// DISABLE_JUMP-NOT: aarch64-jump-table-hardening
+// DISABLE_JUMP: attributes [[ATTR_MAIN]] = { {{.*}}"ptrauth-auth-traps"
+// DISABLE_JUMP-SAME: "ptrauth-calls"
+// DISABLE_JUMP-SAME: "ptrauth-indirect-gotos"
+// DISABLE_JUMP-SAME: "ptrauth-returns"
+// DISABLE_JUMP: !{i32 1, !"aarch64-elf-pauthabi-platform", i32 268435458}
+// DISABLE_JUMP-NEXT: !{i32 1, !"aarch64-elf-pauthabi-version", i32 1791}
+
+// DISABLE_AUTH_TRAPS-NOT: ptrauth-auth-traps
+// DISABLE_AUTH_TRAPS: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
+// DISABLE_AUTH_TRAPS-SAME: "ptrauth-calls"
+// DISABLE_AUTH_TRAPS-SAME: "ptrauth-indirect-gotos"
+// DISABLE_AUTH_TRAPS-SAME: "ptrauth-returns"
+// DISABLE_AUTH_TRAPS: !{i32 1, !"aarch64-elf-pauthabi-platform", i32 268435458}
+// DISABLE_AUTH_TRAPS-NEXT !{i32 1, !"aarch64-elf-pauthabi-version", i32 1783}
+
+// DISABLE_CALLS-NOT: ptrauth-calls
+// DISABLE_CALLS: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
+// DISABLE_CALLS-SAME: "ptrauth-auth-traps"
+// DISABLE_CALLS-SAME: "ptrauth-indirect-gotos"
+// DISABLE_CALLS-SAME: "ptrauth-returns"
+// DISABLE_CALLS: !{i32 1, !"aarch64-elf-pauthabi-platform", i32 268435458}
+// DISABLE_CALLS-SAME-NEXT: !{i32 1, !"aarch64-elf-pauthabi-version", i32 1789}
+
+// DISABLE_INDIRCT_GOTOS-NOT: ptrauth-indirect-gotos
+// DISABLE_INDIRCT_GOTOS: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
+// DISABLE_INDIRCT_GOTOS-SAME: "ptrauth-auth-traps"
+// DISABLE_INDIRCT_GOTOS-SAME: "ptrauth-calls"
+// DISABLE_INDIRCT_GOTOS-SAME: "ptrauth-returns"
+// DISABLE_INDIRCT_GOTOS: !{i32 1, !"aarch64-elf-pauthabi-version", i32 1279}
+// DISABLE_INDIRCT_GOTOS-NEXT: !{i32 1, !"ptrauth-sign-personality", i32 1}
+
+// DISABLE_RETURNS-NOT: ptrauth-returns
+// DISABLE_RETURNS: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
+// DISABLE_RETURNS-SAME: "ptrauth-auth-traps"
+// DISABLE_RETURNS-SAME: "ptrauth-calls"
+// DISABLE_RETURNS-SAME: "ptrauth-indirect-gotos"
+// DISABLE_RETURNS: !{i32 1, !"aarch64-elf-pauthabi-platform", i32 268435458}
+// DISABLE_RETURNS-NEXT: !{i32 1, !"aarch64-elf-pauthabi-version", i32 1787}
+
+// DISABLE_INTRINSICS: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
+// DISABLE_INTRINSICS-SAME: "ptrauth-auth-traps"
+// DISABLE_INTRINSICS-SAME: "ptrauth-calls"
+// DISABLE_INTRINSICS-SAME: "ptrauth-indirect-gotos"
+// DISABLE_INTRINSICS-SAME: "ptrauth-returns"
+// DISABLE_INTRINSICS: !{i32 1, !"aarch64-elf-pauthabi-platform", i32 268435458}
+// DISABLE_INTRINSICS-NEXT: !{i32 1, !"aarch64-elf-pauthabi-version", i32 1790}
+
+// DISABLE_TYPEINFO: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
+// DISABLE_TYPEINFO-SAME: "ptrauth-auth-traps"
+// DISABLE_TYPEINFO-SAME: "ptrauth-calls"
+// DISABLE_TYPEINFO-SAME: "ptrauth-indirect-gotos"
+// DISABLE_TYPEINFO-SAME: "ptrauth-returns"
+// DISABLE_TYPEINFO: !{i32 1, !"aarch64-elf-pauthabi-platform", i32 268435458}
+// DISABLE_TYPEINFO-NEXT: !{i32 1, !"aarch64-elf-pauthabi-version", i32 767}
+
+// DISABLE_VT_PTR_ADDR: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
+// DISABLE_VT_PTR_ADDR-SAME: "ptrauth-auth-traps"
+// DISABLE_VT_PTR_ADDR-SAME: "ptrauth-calls"
+// DISABLE_VT_PTR_ADDR-SAME: "ptrauth-indirect-gotos"
+// DISABLE_VT_PTR_ADDR-SAME: "ptrauth-returns"
+// DISABLE_VT_PTR_ADDR: !{i32 1, !"aarch64-elf-pauthabi-platform", i32 268435458}
+// DISABLE_VT_PTR_ADDR-NEXT: !{i32 1, !"aarch64-elf-pauthabi-version", i32 1775}
+
+// DISABLE_VT_PTR_TYPE: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
+// DISABLE_VT_PTR_TYPE-SAME: "ptrauth-auth-traps"
+// DISABLE_VT_PTR_TYPE-SAME: "ptrauth-calls"
+// DISABLE_VT_PTR_TYPE-SAME: "ptrauth-indirect-gotos"
+// DISABLE_VT_PTR_TYPE-SAME: "ptrauth-returns"
+// DISABLE_VT_PTR_TYPE: !{i32 1, !"aarch64-elf-pauthabi-platform", i32 268435458}
+// DISABLE_VT_PTR_TYPE-NEXT: !{i32 1, !"aarch64-elf-pauthabi-version", i32 1759}
+
+// NONE-NOT: ptrauth-returns
+// NONE-NOT: aarch64-jump-table-hardening
+// NONE-NOT: ptrauth-auth-traps
+// NONE-NOT: ptrauth-calls
+// NONE-NOT: ptrauth-indirect-gotos
+// NONE-NOT: aarch64-elf-pauthabi-platform
+// NONE-NOT: aarch64-elf-pauthabi-version
diff --git a/tests/codegen-llvm/pauth/pauth-attr-special-funcs.rs b/tests/codegen-llvm/pauth/pauth-attr-special-funcs.rs
index 882cc4c6db971..2751494b9de7a 100644
--- a/tests/codegen-llvm/pauth/pauth-attr-special-funcs.rs
+++ b/tests/codegen-llvm/pauth/pauth-attr-special-funcs.rs
@@ -18,10 +18,10 @@ use std::panic;
 // CHECK-DAG: "ptrauth-returns"
 
 // CHECK: attributes [[ATTR_MAIN]] = { {{.*}}"aarch64-jump-table-hardening"
-// CHECK-DAG: "ptrauth-auth-traps"
-// CHECK-DAG: "ptrauth-calls"
-// CHECK-DAG: "ptrauth-indirect-gotos"
-// CHECK-DAG: "ptrauth-returns"
+// CHECK-SAME: "ptrauth-auth-traps"
+// CHECK-SAME: "ptrauth-calls"
+// CHECK-SAME: "ptrauth-indirect-gotos"
+// CHECK-SAME: "ptrauth-returns"
 fn main() {
     let _ = panic::catch_unwind(|| {
         panic!("BOOM");
diff --git a/tests/codegen-llvm/pauth/pauth-extern-c.rs b/tests/codegen-llvm/pauth/pauth-extern-c.rs
index ac12729f80699..5b0253a7bbe60 100644
--- a/tests/codegen-llvm/pauth/pauth-extern-c.rs
+++ b/tests/codegen-llvm/pauth/pauth-extern-c.rs
@@ -9,9 +9,9 @@
 //@ [O3_PAUTH] needs-llvm-components: aarch64
 //@ [O3_PAUTH] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=3
 //@ [O0_PAUTH-ELF-GOT] needs-llvm-components: aarch64
-//@ [O0_PAUTH-ELF-GOT] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=0 -Z ptrauth-elf-got
+//@ [O0_PAUTH-ELF-GOT] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=0 -Z pointer-authentication=+elf-got
 //@ [O3_PAUTH-ELF-GOT] needs-llvm-components: aarch64
-//@ [O3_PAUTH-ELF-GOT] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=3 -Z ptrauth-elf-got
+//@ [O3_PAUTH-ELF-GOT] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=3 -Z pointer-authentication=+elf-got
 //@ [O0_NO_PAUTH] needs-llvm-components: aarch64
 //@ [O0_NO_PAUTH] compile-flags: --target=aarch64-unknown-linux-gnu -C opt-level=0
 //@ [O3_NO_PAUTH] needs-llvm-components: aarch64
diff --git a/tests/codegen-llvm/pauth/pauth-init-fini.rs b/tests/codegen-llvm/pauth/pauth-init-fini.rs
index db327644d96cf..d457973b690f2 100644
--- a/tests/codegen-llvm/pauth/pauth-init-fini.rs
+++ b/tests/codegen-llvm/pauth/pauth-init-fini.rs
@@ -1,14 +1,23 @@
 //@ add-minicore
 // ignore-tidy-linelength
 //@ only-pauthtest
-//@ revisions: O0_PAUTH O3_PAUTH
+//@ revisions: O0_PAUTH O3_PAUTH O0_PAUTH-ADDR-DISC O3_PAUTH-ADDR-DISC O0_PAUTH-NO-INIT-FINI O3_PAUTH-NO-INIT-FINI
 
 //@ [O0_PAUTH] needs-llvm-components: aarch64
 //@ [O0_PAUTH] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=0
+//@ [O0_PAUTH-ADDR-DISC] needs-llvm-components: aarch64
+//@ [O0_PAUTH-ADDR-DISC] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=0 -Zpointer-authentication=+init-fini-address-discrimination
+//@ [O0_PAUTH-NO-INIT-FINI] needs-llvm-components: aarch64
+//@ [O0_PAUTH-NO-INIT-FINI] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=0 -Zpointer-authentication=-init-fini
 //@ [O3_PAUTH] needs-llvm-components: aarch64
 //@ [O3_PAUTH] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=3
+//@ [O3_PAUTH-ADDR-DISC] needs-llvm-components: aarch64
+//@ [O3_PAUTH-ADDR-DISC] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=3 -Zpointer-authentication=+init-fini-address-discrimination
+//@ [O3_PAUTH-NO-INIT-FINI] needs-llvm-components: aarch64
+//@ [O3_PAUTH-NO-INIT-FINI] compile-flags: --target=aarch64-unknown-linux-pauthtest -C opt-level=0 -Zpointer-authentication=-init-fini
 
-// Make sure that init/fini metadata uses correct discriminator: 0xd9d4/55764
+// Make sure that init/fini metadata uses correct discriminator: 0xd9d4/55764 - ptrauth_string_discriminator("init_fini").
+// And that address discriminator can be enabled.
 
 #![feature(no_core, lang_items)]
 #![no_std]
@@ -20,12 +29,20 @@ use minicore::*;
 
 // O0_PAUTH: @{{[0-9A-Za-z_]+}}GLOBAL_INIT = constant ptr ptrauth (ptr @{{[0-9A-Za-z_]+}}init_fn, i32 0, i64 55764, ptr inttoptr (i64 1 to ptr)), section ".init_array.90"
 // O3_PAUTH: @{{[0-9A-Za-z_]+}}GLOBAL_INIT = constant ptr ptrauth (ptr @{{[0-9A-Za-z_]+}}init_fn, i32 0, i64 55764, ptr inttoptr (i64 1 to ptr)), section ".init_array.90"
+// O0_PAUTH-ADDR-DISC: @{{[0-9A-Za-z_]+}}GLOBAL_INIT = constant ptr ptrauth (ptr @{{[0-9A-Za-z_]+}}init_fn, i32 0, i64 55764, ptr @_RNvCsf7kshQi9mOB_15pauth_init_fini7init_fn), section ".init_array.90"
+// O3_PAUTH-ADDR-DISC: @{{[0-9A-Za-z_]+}}GLOBAL_INIT = constant ptr ptrauth (ptr @{{[0-9A-Za-z_]+}}init_fn, i32 0, i64 55764, ptr @_RNvCsf7kshQi9mOB_15pauth_init_fini7init_fn), section ".init_array.90"
+// O0_PAUTH-NO-INIT-FINI-NOT: @{{[0-9A-Za-z_]+}}GLOBAL_INIT = constant ptr ptrauth
+// O0_PAUTH-NO-INIT-FINI-ADDR-DISC: @{{[0-9A-Za-z_]+}}GLOBAL_INIT = constant ptr ptrauth
 #[used]
 #[link_section = ".init_array.90"]
 static GLOBAL_INIT: extern "C" fn() = init_fn;
 
 // O0_PAUTH: @{{[0-9A-Za-z_]+}}GLOBAL_FINI = constant ptr ptrauth (ptr @{{[0-9A-Za-z_]+}}fini_fn, i32 0, i64 55764, ptr inttoptr (i64 1 to ptr)), section ".fini_array.90"
 // O3_PAUTH: @{{[0-9A-Za-z_]+}}GLOBAL_FINI = constant ptr ptrauth (ptr @{{[0-9A-Za-z_]+}}fini_fn, i32 0, i64 55764, ptr inttoptr (i64 1 to ptr)), section ".fini_array.90"
+// O0_PAUTH-ADDR-DISC: @{{[0-9A-Za-z_]+}}GLOBAL_FINI = constant ptr ptrauth (ptr @{{[0-9A-Za-z_]+}}fini_fn, i32 0, i64 55764, ptr @_RNvCsf7kshQi9mOB_15pauth_init_fini7fini_fn), section ".fini_array.90"
+// O3_PAUTH-ADDR-DISC: @{{[0-9A-Za-z_]+}}GLOBAL_FINI = constant ptr ptrauth (ptr @{{[0-9A-Za-z_]+}}fini_fn, i32 0, i64 55764, ptr @_RNvCsf7kshQi9mOB_15pauth_init_fini7fini_fn), section ".fini_array.90"
+// O0_PAUTH-NO-INIT-FINI-NOT: @{{[0-9A-Za-z_]+}}GLOBAL_FINI = constant ptr ptrauth
+// O3_PAUTH-NO-INIT-FINI-NOT: @{{[0-9A-Za-z_]+}}GLOBAL_FINI = constant ptr ptrauth
 #[used]
 #[link_section = ".fini_array.90"]
 static GLOBAL_FINI: extern "C" fn(i32) = fini_fn;
diff --git a/tests/ui/README.md b/tests/ui/README.md
index d342f393d0550..54627363718a8 100644
--- a/tests/ui/README.md
+++ b/tests/ui/README.md
@@ -1083,6 +1083,10 @@ See [Tracking issue for pin ergonomics #130494](https://github.com/rust-lang/rus
 
 See [`std::pin`](https://doc.rust-lang.org/std/pin/).
 
+## `tests/ui/pointer_authentication/`
+
+Tests for `-Zpointer-authentication` compiler flag.
+
 ## `tests/ui/precondition-checks/`
 
 Exercises on some unsafe precondition checks.
diff --git a/tests/ui/pointer_authentication/enable_pointer_authentication_validation.all_unknown.stderr b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.all_unknown.stderr
new file mode 100644
index 0000000000000..47e61f2b8be73
--- /dev/null
+++ b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.all_unknown.stderr
@@ -0,0 +1,2 @@
+error: incorrect value `+I,+do,-not,-exist` for unstable option `pointer-authentication` - a comma-separated list of options, each of the form `+<name>` or `-<name>`, where `<name>` is one of: `aarch64-jump-table-hardening`, `auth-traps`, `calls`, `elf-got`, `function-pointer-type-discrimination`, `indirect-gotos`, `init-fini`, `init-fini-address-discrimination`, `intrinsics`, `return-addresses`, `typeinfo-vt-ptr-discrimination`, `vt-ptr-addr-discrimination` or `vt-ptr-type-discrimination` was expected
+
diff --git a/tests/ui/pointer_authentication/enable_pointer_authentication_validation.empty.stderr b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.empty.stderr
new file mode 100644
index 0000000000000..9a4cd16c15a14
--- /dev/null
+++ b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.empty.stderr
@@ -0,0 +1,2 @@
+error: incorrect value `` for unstable option `pointer-authentication` - a comma-separated list of options, each of the form `+<name>` or `-<name>`, where `<name>` is one of: `aarch64-jump-table-hardening`, `auth-traps`, `calls`, `elf-got`, `function-pointer-type-discrimination`, `indirect-gotos`, `init-fini`, `init-fini-address-discrimination`, `intrinsics`, `return-addresses`, `typeinfo-vt-ptr-discrimination`, `vt-ptr-addr-discrimination` or `vt-ptr-type-discrimination` was expected
+
diff --git a/tests/ui/pointer_authentication/enable_pointer_authentication_validation.mixed.stderr b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.mixed.stderr
new file mode 100644
index 0000000000000..ea8b9250f31b9
--- /dev/null
+++ b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.mixed.stderr
@@ -0,0 +1,2 @@
+error: incorrect value `+elf-got,-imaginary` for unstable option `pointer-authentication` - a comma-separated list of options, each of the form `+<name>` or `-<name>`, where `<name>` is one of: `aarch64-jump-table-hardening`, `auth-traps`, `calls`, `elf-got`, `function-pointer-type-discrimination`, `indirect-gotos`, `init-fini`, `init-fini-address-discrimination`, `intrinsics`, `return-addresses`, `typeinfo-vt-ptr-discrimination`, `vt-ptr-addr-discrimination` or `vt-ptr-type-discrimination` was expected
+
diff --git a/tests/ui/pointer_authentication/enable_pointer_authentication_validation.rs b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.rs
new file mode 100644
index 0000000000000..d7306508f39d4
--- /dev/null
+++ b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.rs
@@ -0,0 +1,24 @@
+//@ ignore-backends: gcc
+//@ revisions: empty unprefixed all_unknown all_known mixed
+
+//@[empty] needs-llvm-components: aarch64
+//@[empty] compile-flags: --target aarch64-unknown-linux-pauthtest -Zpointer-authentication=
+//@[unprefixed] needs-llvm-components: aarch64
+//@[unprefixed] compile-flags: --target aarch64-unknown-linux-pauthtest -Zpointer-authentication=auth-traps
+//@[all_unknown] needs-llvm-components: aarch64
+//@[all_unknown] compile-flags: --target aarch64-unknown-linux-pauthtest -Zpointer-authentication=+I,+do,-not,-exist
+//@[all_known] check-pass
+//@[all_known] needs-llvm-components: aarch64
+//@[all_known] compile-flags: --target aarch64-unknown-linux-pauthtest -Zpointer-authentication=+elf-got,-init-fini
+//@[mixed] needs-llvm-components: aarch64
+//@[mixed] compile-flags: --target aarch64-unknown-linux-pauthtest -Zpointer-authentication=+elf-got,-imaginary
+
+#![feature(no_core)]
+#![no_std]
+#![no_main]
+#![no_core]
+
+//[empty]~? ERROR incorrect value `` for unstable option `pointer-authentication`
+//[unprefixed]~? ERROR incorrect value `auth-traps` for unstable option `pointer-authentication`
+//[all_unknown]~? ERROR incorrect value `+I,+do,-not,-exist` for unstable option `pointer-authentication`
+//[mixed]~? ERROR incorrect value `+elf-got,-imaginary` for unstable option `pointer-authentication`
diff --git a/tests/ui/pointer_authentication/enable_pointer_authentication_validation.unprefixed.stderr b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.unprefixed.stderr
new file mode 100644
index 0000000000000..c6ff1e36350ee
--- /dev/null
+++ b/tests/ui/pointer_authentication/enable_pointer_authentication_validation.unprefixed.stderr
@@ -0,0 +1,2 @@
+error: incorrect value `auth-traps` for unstable option `pointer-authentication` - a comma-separated list of options, each of the form `+<name>` or `-<name>`, where `<name>` is one of: `aarch64-jump-table-hardening`, `auth-traps`, `calls`, `elf-got`, `function-pointer-type-discrimination`, `indirect-gotos`, `init-fini`, `init-fini-address-discrimination`, `intrinsics`, `return-addresses`, `typeinfo-vt-ptr-discrimination`, `vt-ptr-addr-discrimination` or `vt-ptr-type-discrimination` was expected
+
diff --git a/tests/ui/pointer_authentication/invalid_target_pointer_authentication.rs b/tests/ui/pointer_authentication/invalid_target_pointer_authentication.rs
new file mode 100644
index 0000000000000..2d8b3b7a1915d
--- /dev/null
+++ b/tests/ui/pointer_authentication/invalid_target_pointer_authentication.rs
@@ -0,0 +1,11 @@
+//@ ignore-backends: gcc
+//@ check-pass
+//@ needs-llvm-components: aarch64
+
+//@ compile-flags: -Zpointer-authentication=-elf-got --crate-type=lib --target aarch64-unknown-linux-gnu
+
+#![feature(no_core)]
+#![no_std]
+#![no_main]
+#![no_core]
+//~? WARN `-Z pointer-authentication` is not supported for target aarch64-unknown-linux-gnu and will be ignored
diff --git a/tests/ui/pointer_authentication/invalid_target_pointer_authentication.stderr b/tests/ui/pointer_authentication/invalid_target_pointer_authentication.stderr
new file mode 100644
index 0000000000000..1b1a33fd16c2b
--- /dev/null
+++ b/tests/ui/pointer_authentication/invalid_target_pointer_authentication.stderr
@@ -0,0 +1,4 @@
+warning: `-Z pointer-authentication` is not supported for target aarch64-unknown-linux-gnu and will be ignored
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/pointer_authentication/type_discrimination_not_supported_pointer_authentication.rs b/tests/ui/pointer_authentication/type_discrimination_not_supported_pointer_authentication.rs
new file mode 100644
index 0000000000000..6838e749fd333
--- /dev/null
+++ b/tests/ui/pointer_authentication/type_discrimination_not_supported_pointer_authentication.rs
@@ -0,0 +1,12 @@
+//@ ignore-backends: gcc
+//@ check-fail
+//@ needs-llvm-components: aarch64
+
+//@ compile-flags: -Zpointer-authentication=+function-pointer-type-discrimination --crate-type=lib --target aarch64-unknown-linux-pauthtest
+
+#![feature(no_core)]
+#![no_std]
+#![no_main]
+#![no_core]
+
+//~? ERROR function pointer type discrimination is not supported
diff --git a/tests/ui/pointer_authentication/type_discrimination_not_supported_pointer_authentication.stderr b/tests/ui/pointer_authentication/type_discrimination_not_supported_pointer_authentication.stderr
new file mode 100644
index 0000000000000..c040b0cb61f66
--- /dev/null
+++ b/tests/ui/pointer_authentication/type_discrimination_not_supported_pointer_authentication.stderr
@@ -0,0 +1,4 @@
+error: function pointer type discrimination is not supported
+
+error: aborting due to 1 previous error
+