Mangle personality symbol

Noratrieb · Noratrieb · commit e9c966b9ece2 · 2026-01-31T16:42:23.000+01:00
Previously, std-internal symbols (like `__rust_alloc` or `rust_panic`)
were changed to now be mangled via a v0 scheme with the compiler version
hash (`_RNvCs4CIB29Id3dw_7___rustc10rust_panic`) to make it possible to
have multiple staticlibs (as long as they have different version hashes)
in the same program without symbol conflicts. But the personality
function remained unmangled, because LLVM hardcodes that name.

I made a change in LLVM that makes LLVM now check the suffix instead of
an exact match, so we can mangle the personality function with this
scheme.

This removes the last completely unmangled symbol from Rust staticlibs!
(though the mangling is still quite weak, so it's still not as nice as
it would ideally be).

Before, on a trivial staticlib:

```
readelf -s liblib.a | rg GLOBAL | rg -v " UND | HIDDEN " | rg -v ' _ZN'
     8: 0000000000000000     5 FUNC    GLOBAL DEFAULT     3 _RNvCseCSg29WUqSe_7___rustc12___rust_alloc
    10: 0000000000000000     5 FUNC    GLOBAL DEFAULT     5 _RNvCseCSg29WUqSe_7___rustc14___rust_dealloc
    12: 0000000000000000     5 FUNC    GLOBAL DEFAULT     7 _RNvCseCSg29WUqSe_7___rustc14___rust_realloc
    14: 0000000000000000     5 FUNC    GLOBAL DEFAULT     9 _RNvCseCSg29WUqSe_7___rustc19___rust_alloc_zeroed
    16: 0000000000000000     3 FUNC    GLOBAL DEFAULT    11 _RNvCseCSg29WUqSe_7___rustc42___rust_alloc_error_handler_should_panic_v2
    17: 0000000000000000     1 FUNC    GLOBAL DEFAULT    12 _RNvCseCSg29WUqSe_7___rustc35___rust_no_alloc_shim_is_unstable_v2
  3383: 0000000000000000   111 FUNC    GLOBAL DEFAULT     5 _RNvCseCSg29WUqSe_7___rustc10rust_panic
  3387: 0000000000000000    93 FUNC    GLOBAL DEFAULT     7 _RNvCseCSg29WUqSe_7___rustc11___rdl_alloc
  3390: 0000000000000000    10 FUNC    GLOBAL DEFAULT     9 _RNvCseCSg29WUqSe_7___rustc12___rust_abort
  3391: 0000000000000000     6 FUNC    GLOBAL DEFAULT    11 _RNvCseCSg29WUqSe_7___rustc13___rdl_dealloc
  3393: 0000000000000000   167 FUNC    GLOBAL DEFAULT    13 _RNvCseCSg29WUqSe_7___rustc13___rdl_realloc
  3396: 0000000000000000   203 FUNC    GLOBAL DEFAULT    15 _RNvCseCSg29WUqSe_7___rustc17___rust_drop_panic
  3399: 0000000000000000    29 FUNC    GLOBAL DEFAULT    18 _RNvCseCSg29WUqSe_7___rustc17rust_begin_unwind
  3401: 0000000000000000   140 FUNC    GLOBAL DEFAULT    20 _RNvCseCSg29WUqSe_7___rustc18___rdl_alloc_zeroed
  3404: 0000000000000000   203 FUNC    GLOBAL DEFAULT    22 _RNvCseCSg29WUqSe_7___rustc24___rust_foreign_exception
  3405: 0000000000000000    19 FUNC    GLOBAL DEFAULT    25 _RNvCseCSg29WUqSe_7___rustc26___rust_alloc_error_handler
  4410: 0000000000000000  1471 FUNC    GLOBAL DEFAULT   2752 rust_eh_personality
    25: 0000000000000000   161 FUNC    GLOBAL DEFAULT     5 _RNvCseCSg29WUqSe_7___rustc18___rust_start_panic
    32: 0000000000000000    82 FUNC    GLOBAL DEFAULT     8 _RNvCseCSg29WUqSe_7___rustc20___rust_panic_cleanup
   249: 0000000000000000   182 FUNC    GLOBAL DEFAULT     5 _RNvCseCSg29WUqSe_7___rustc25___rdl_alloc_error_handler
     3: 0000000000000000    57 FUNC    GLOBAL DEFAULT     3 _RNvCseCSg29WUqSe_7___rustc17___rust_probestack
```

After:

```
     8: 0000000000000000     5 FUNC    GLOBAL DEFAULT     3 _RNvCs4CIB29Id3dw_7___rustc12___rust_alloc
    10: 0000000000000000     5 FUNC    GLOBAL DEFAULT     5 _RNvCs4CIB29Id3dw_7___rustc14___rust_dealloc
    12: 0000000000000000     5 FUNC    GLOBAL DEFAULT     7 _RNvCs4CIB29Id3dw_7___rustc14___rust_realloc
    14: 0000000000000000     5 FUNC    GLOBAL DEFAULT     9 _RNvCs4CIB29Id3dw_7___rustc19___rust_alloc_zeroed
    16: 0000000000000000     3 FUNC    GLOBAL DEFAULT    11 _RNvCs4CIB29Id3dw_7___rustc42___rust_alloc_error_handler_should_panic_v2
    17: 0000000000000000     1 FUNC    GLOBAL DEFAULT    12 _RNvCs4CIB29Id3dw_7___rustc35___rust_no_alloc_shim_is_unstable_v2
   422: 0000000000000000    19 FUNC    GLOBAL DEFAULT     5 _RNvCs4CIB29Id3dw_7___rustc26___rust_alloc_error_handler
   429: 0000000000000000   308 FUNC    GLOBAL DEFAULT     5 _RNvCs4CIB29Id3dw_7___rustc19rust_eh_personality
   349: 0000000000000000    10 FUNC    GLOBAL DEFAULT     5 _RNvCs4CIB29Id3dw_7___rustc12___rust_abort
   164: 0000000000000000    93 FUNC    GLOBAL DEFAULT     5 _RNvCs4CIB29Id3dw_7___rustc11___rdl_alloc
   167: 0000000000000000    11 FUNC    GLOBAL DEFAULT     7 _RNvCs4CIB29Id3dw_7___rustc13___rdl_dealloc
   169: 0000000000000000   167 FUNC    GLOBAL DEFAULT     9 _RNvCs4CIB29Id3dw_7___rustc13___rdl_realloc
   172: 0000000000000000   140 FUNC    GLOBAL DEFAULT    11 _RNvCs4CIB29Id3dw_7___rustc18___rdl_alloc_zeroed
   688: 0000000000000000   106 FUNC    GLOBAL DEFAULT     5 _RNvCs4CIB29Id3dw_7___rustc10rust_panic
   693: 0000000000000000   207 FUNC    GLOBAL DEFAULT     7 _RNvCs4CIB29Id3dw_7___rustc17___rust_drop_panic
   696: 0000000000000000    29 FUNC    GLOBAL DEFAULT    10 _RNvCs4CIB29Id3dw_7___rustc17rust_begin_unwind
   698: 0000000000000000   207 FUNC    GLOBAL DEFAULT    12 _RNvCs4CIB29Id3dw_7___rustc24___rust_foreign_exception
    26: 0000000000000000   161 FUNC    GLOBAL DEFAULT     5 _RNvCs4CIB29Id3dw_7___rustc18___rust_start_panic
    33: 0000000000000000    82 FUNC    GLOBAL DEFAULT     8 _RNvCs4CIB29Id3dw_7___rustc20___rust_panic_cleanup
    88: 0000000000000000   182 FUNC    GLOBAL DEFAULT     5 _RNvCs4CIB29Id3dw_7___rustc25___rdl_alloc_error_handler
     3: 0000000000000000    57 FUNC    GLOBAL DEFAULT     3 _RNvCs4CIB29Id3dw_7___rustc17___rust_probestack
```
diff --git a/compiler/rustc_codegen_cranelift/src/debuginfo/emit.rs b/compiler/rustc_codegen_cranelift/src/debuginfo/emit.rs
@@ -93,8 +93,11 @@ impl WriterRelocate {
                         // HACK rust_eh_personality is likely not defined in the same crate,
                         // so get_finalized_function won't work. Use the rust_eh_personality
                         // of cg_clif itself, which is likely ABI compatible.
-                        if jit_module.declarations().get_function_decl(func_id).name.as_deref()
-                            == Some("rust_eh_personality")
+                        if jit_module
+                            .declarations()
+                            .get_function_decl(func_id)
+                            .name
+                            .is_some_and(|name| name.ends_with("rust_eh_personality"))
                         {
                             unsafe extern "C" {
                                 fn rust_eh_personality() -> !;
diff --git a/compiler/rustc_codegen_cranelift/src/debuginfo/unwind.rs b/compiler/rustc_codegen_cranelift/src/debuginfo/unwind.rs
@@ -25,7 +25,7 @@ pub(crate) struct UnwindContext {
 }
 
 impl UnwindContext {
-    pub(crate) fn new(module: &mut dyn Module, pic_eh_frame: bool) -> Self {
+    pub(crate) fn new(module: &mut dyn Module, tcx: TyCtxt<'_>, pic_eh_frame: bool) -> Self {
         let endian = match module.isa().endianness() {
             Endianness::Little => RunTimeEndian::Little,
             Endianness::Big => RunTimeEndian::Big,
@@ -70,7 +70,7 @@ impl UnwindContext {
                 // FIXME use eh_personality lang item instead
                 let personality = module
                     .declare_function(
-                        "rust_eh_personality",
+                        &rustc_symbol_mangling::mangle_internal_symbol(tcx, "rust_eh_personality"),
                         Linkage::Import,
                         &Signature {
                             params: vec![
diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
@@ -322,8 +322,8 @@ fn produce_final_output_artifacts(
     // These are used in linking steps and will be cleaned up afterward.
 }
 
-fn make_module(sess: &Session, name: String) -> UnwindModule<ObjectModule> {
-    let isa = crate::build_isa(sess, false);
+fn make_module(tcx: TyCtxt<'_>, name: String) -> UnwindModule<ObjectModule> {
+    let isa = crate::build_isa(tcx.sess, false);
 
     let mut builder =
         ObjectBuilder::new(isa, name + ".o", cranelift_module::default_libcall_names()).unwrap();
@@ -333,12 +333,13 @@ fn make_module(sess: &Session, name: String) -> UnwindModule<ObjectModule> {
     // explicitly disable it on MinGW as rustc already disables it by default on MinGW and as such
     // isn't tested. If rustc enables it in the future on MinGW, we can re-enable it too once it has
     // been on MinGW.
-    let default_function_sections = sess.target.function_sections && !sess.target.is_like_windows;
+    let default_function_sections =
+        tcx.sess.target.function_sections && !tcx.sess.target.is_like_windows;
     builder.per_function_section(
-        sess.opts.unstable_opts.function_sections.unwrap_or(default_function_sections),
+        tcx.sess.opts.unstable_opts.function_sections.unwrap_or(default_function_sections),
     );
 
-    UnwindModule::new(ObjectModule::new(builder), true)
+    UnwindModule::new(ObjectModule::new(builder), tcx, true)
 }
 
 fn emit_cgu(
@@ -579,7 +580,7 @@ fn module_codegen(
         ConcurrencyLimiterToken,
     ),
 ) -> OngoingModuleCodegen {
-    let mut module = make_module(tcx.sess, cgu_name.as_str().to_string());
+    let mut module = make_module(tcx, cgu_name.as_str().to_string());
 
     let (mut debug_context, codegened_functions, mut global_asm) =
         codegen_cgu_content(tcx, &mut module, cgu_name);
@@ -643,7 +644,7 @@ fn module_codegen(
 }
 
 fn emit_allocator_module(tcx: TyCtxt<'_>) -> Option<CompiledModule> {
-    let mut allocator_module = make_module(tcx.sess, "allocator_shim".to_string());
+    let mut allocator_module = make_module(tcx, "allocator_shim".to_string());
     let created_alloc_shim = crate::allocator::codegen(tcx, &mut allocator_module);
 
     if created_alloc_shim {
diff --git a/compiler/rustc_codegen_cranelift/src/unwind_module.rs b/compiler/rustc_codegen_cranelift/src/unwind_module.rs
@@ -7,6 +7,7 @@ use cranelift_module::{
     ModuleReloc, ModuleResult,
 };
 use cranelift_object::{ObjectModule, ObjectProduct};
+use rustc_middle::ty::TyCtxt;
 
 use crate::UnwindContext;
 
@@ -17,8 +18,8 @@ pub(crate) struct UnwindModule<T> {
 }
 
 impl<T: Module> UnwindModule<T> {
-    pub(crate) fn new(mut module: T, pic_eh_frame: bool) -> Self {
-        let unwind_context = UnwindContext::new(&mut module, pic_eh_frame);
+    pub(crate) fn new(mut module: T, tcx: TyCtxt<'_>, pic_eh_frame: bool) -> Self {
+        let unwind_context = UnwindContext::new(&mut module, tcx, pic_eh_frame);
         UnwindModule { module, unwind_context }
     }
 }
diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs
@@ -457,10 +457,13 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                 self.declare_fn(symbol_name, fn_abi)
             }
             _ => {
+                let rust_name;
                 let name = if wants_msvc_seh(self.sess()) {
                     "__CxxFrameHandler3"
                 } else {
-                    "rust_eh_personality"
+                    rust_name =
+                        rustc_symbol_mangling::mangle_internal_symbol(tcx, "rust_eh_personality");
+                    &rust_name
                 };
                 self.declare_func(name, self.type_i32(), &[], true)
             }
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -258,6 +258,7 @@ impl CodegenBackend for GccCodegenBackend {
             LTO_SUPPORTED.store(lto_supported, Ordering::SeqCst);
             self.lto_supported.store(lto_supported, Ordering::SeqCst);
 
+            // FIXME: This needs to mangle the personality, but that requires a tcx.
             gccjit::set_global_personality_function_name(b"rust_eh_personality\0");
         }
 
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -78,7 +78,7 @@ fn prepare_lto(
     symbols_below_threshold.push(c"__llvm_profile_counter_bias".to_owned());
 
     // LTO seems to discard this otherwise under certain circumstances.
-    symbols_below_threshold.push(c"rust_eh_personality".to_owned());
+    symbols_below_threshold.push(CString::new(cgcx.rust_eh_personality_symbol.clone()).unwrap());
 
     // If we're performing LTO for the entire crate graph, then for each of our
     // upstream dependencies, find the corresponding rlib and load the bitcode
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
@@ -901,7 +901,17 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 DUMMY_SP,
             )),
             _ => {
-                let name = name.unwrap_or("rust_eh_personality");
+                let mangled_symbol;
+                let name = match name {
+                    Some(name) => name,
+                    None => {
+                        mangled_symbol = rustc_symbol_mangling::mangle_internal_symbol(
+                            tcx,
+                            "rust_eh_personality",
+                        );
+                        mangled_symbol.as_str()
+                    }
+                };
                 if let Some(llfn) = self.get_declared_value(name) {
                     llfn
                 } else {
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -346,6 +346,11 @@ impl CodegenBackend for LlvmCodegenBackend {
         llvm::LLVMRustLLVMHasZstdCompression()
     }
 
+    fn can_mangle_eh_personality(&self) -> bool {
+        // https://github.com/llvm/llvm-project/pull/166095
+        llvm_util::get_version() > (22, 0, 0)
+    }
+
     fn target_config(&self, sess: &Session) -> TargetConfig {
         target_config(sess)
     }
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -348,6 +348,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
     pub split_debuginfo: rustc_target::spec::SplitDebuginfo,
     pub split_dwarf_kind: rustc_session::config::SplitDwarfKind,
     pub pointer_size: Size,
+    pub rust_eh_personality_symbol: String,
 
     /// LLVM optimizations for which we want to print remarks.
     pub remark: Passes,
@@ -1328,6 +1329,10 @@ fn start_executing_work<B: ExtraBackendMethods>(
         target_is_like_darwin: tcx.sess.target.is_like_darwin,
         target_is_like_aix: tcx.sess.target.is_like_aix,
         target_is_like_gpu: tcx.sess.target.is_like_gpu,
+        rust_eh_personality_symbol: rustc_symbol_mangling::mangle_internal_symbol(
+            tcx,
+            "rust_eh_personality",
+        ),
         split_debuginfo: tcx.sess.split_debuginfo(),
         split_dwarf_kind: tcx.sess.opts.unstable_opts.split_dwarf_kind,
         parallel: backend.supports_parallel() && !sess.opts.unstable_opts.no_parallel_backend,
diff --git a/compiler/rustc_codegen_ssa/src/traits/backend.rs b/compiler/rustc_codegen_ssa/src/traits/backend.rs
@@ -86,6 +86,12 @@ pub trait CodegenBackend {
         false
     }
 
+    /// Whether the `rust_eh_personality` symbol can be mangled (this is false if the codegen
+    /// backend hardcodes the name for certain checks).
+    fn can_mangle_eh_personality(&self) -> bool {
+        true
+    }
+
     /// The metadata loader used to load rlib and dylib metadata.
     ///
     /// Alternative codegen backends may want to use different rlib or dylib formats than the
diff --git a/compiler/rustc_interface/src/interface.rs b/compiler/rustc_interface/src/interface.rs
@@ -482,6 +482,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
                 util::rustc_version_str().unwrap_or("unknown"),
                 config.ice_file,
                 config.using_internal_features,
+                codegen_backend.can_mangle_eh_personality(),
             );
 
             codegen_backend.init(&sess);
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
@@ -79,6 +79,7 @@ where
             "",
             None,
             &USING_INTERNAL_FEATURES,
+            true,
         );
         let cfg = parse_cfg(sess.dcx(), matches.opt_strs("cfg"));
         let cfg = build_configuration(&sess, cfg);
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
@@ -126,6 +126,10 @@ pub struct Session {
     /// drown everything else in noise.
     miri_unleashed_features: Lock<Vec<(Span, Option<Symbol>)>>,
 
+    /// Whether the codegen backend supports mangling of the personality.
+    /// See [`CodegenBackend::can_mangle_eh_personality`].
+    pub codegen_backend_supports_eh_personality_mangling: bool,
+
     /// Architecture to use for interpreting asm!.
     pub asm_arch: Option<InlineAsmArch>,
 
@@ -970,6 +974,7 @@ pub fn build_session(
     cfg_version: &'static str,
     ice_file: Option<PathBuf>,
     using_internal_features: &'static AtomicBool,
+    codegen_backend_supports_eh_personality_mangling: bool,
 ) -> Session {
     // FIXME: This is not general enough to make the warning lint completely override
     // normal diagnostic warnings, since the warning lint can also be denied and changed
@@ -1084,6 +1089,7 @@ pub fn build_session(
         driver_lint_caps,
         ctfe_backtrace,
         miri_unleashed_features: Lock::new(Default::default()),
+        codegen_backend_supports_eh_personality_mangling,
         asm_arch,
         target_features: Default::default(),
         unstable_target_features: Default::default(),
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -83,8 +83,9 @@ pub(super) fn mangle<'tcx>(
 
 pub fn mangle_internal_symbol<'tcx>(tcx: TyCtxt<'tcx>, item_name: &str) -> String {
     match item_name {
-        // rust_eh_personality must not be renamed as LLVM hard-codes the name
-        "rust_eh_personality" => return item_name.to_owned(),
+        "rust_eh_personality" if !tcx.sess.codegen_backend_supports_eh_personality_mangling => {
+            return item_name.to_owned();
+        }
         // Apple availability symbols need to not be mangled to be usable by
         // C/Objective-C code.
         "__isPlatformVersionAtLeast" | "__isOSVersionAtLeast" => return item_name.to_owned(),
diff --git a/src/tools/compiletest/src/runtest/run_make.rs b/src/tools/compiletest/src/runtest/run_make.rs
@@ -222,6 +222,10 @@ impl TestCx<'_> {
             cmd.env("LLVM_BIN_DIR", llvm_bin_dir);
         }
 
+        if let Some(ref llvm_version) = self.config.llvm_version {
+            cmd.env("LLVM_VERSION", llvm_version.to_string());
+        }
+
         if let Some(ref remote_test_client) = self.config.remote_test_client {
             cmd.env("REMOTE_TEST_CLIENT", remote_test_client);
         }
diff --git a/src/tools/run-make-support/src/external_deps/llvm.rs b/src/tools/run-make-support/src/external_deps/llvm.rs
@@ -3,6 +3,19 @@ use std::path::{Path, PathBuf};
 use crate::command::Command;
 use crate::env::env_var;
 
+pub fn llvm_version() -> (u32, u32, u32) {
+    let version_string = env_var("LLVM_VERSION");
+    let mut parts = version_string.split(".");
+    let mut part = || {
+        parts
+            .next()
+            .expect(&format!("invalid LLVM version: {version_string}"))
+            .parse::<u32>()
+            .expect(&format!("invalid LLVM version: {version_string}"))
+    };
+    (part(), part(), part())
+}
+
 /// Construct a new `llvm-readobj` invocation with the `GNU` output style.
 /// This assumes that `llvm-readobj` is available at `$LLVM_BIN_DIR/llvm-readobj`.
 #[track_caller]
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
@@ -68,7 +68,7 @@ pub use crate::external_deps::llvm::{
     self, LlvmAr, LlvmBcanalyzer, LlvmDis, LlvmDwarfdump, LlvmFilecheck, LlvmNm, LlvmObjcopy,
     LlvmObjdump, LlvmProfdata, LlvmReadobj, llvm_ar, llvm_as, llvm_bcanalyzer, llvm_dis,
     llvm_dwarfdump, llvm_filecheck, llvm_nm, llvm_objcopy, llvm_objdump, llvm_profdata,
-    llvm_readobj,
+    llvm_readobj, llvm_version,
 };
 pub use crate::external_deps::python::python_command;
 pub use crate::external_deps::rustc::{self, Rustc, bare_rustc, rustc, rustc_path};
diff --git a/tests/run-make/no-alloc-shim/foo.rs b/tests/run-make/no-alloc-shim/foo.rs
@@ -1,4 +1,4 @@
-#![feature(rustc_attrs)]
+#![feature(rustc_attrs, lang_items)]
 #![no_std]
 #![no_main]
 
@@ -11,7 +11,7 @@ fn panic_handler(_: &core::panic::PanicInfo) -> ! {
     loop {}
 }
 
-#[no_mangle]
+#[lang = "eh_personality"]
 extern "C" fn rust_eh_personality(
     _version: i32,
     _actions: i32,
diff --git a/tests/run-make/repr128-dwarf/rmake.rs b/tests/run-make/repr128-dwarf/rmake.rs
@@ -10,22 +10,12 @@ use std::rc::Rc;
 use gimli::read::DebuggingInformationEntry;
 use gimli::{AttributeValue, EndianRcSlice, Reader, RunTimeEndian};
 use object::{Object, ObjectSection};
-use run_make_support::{gimli, object, rfs, rustc};
+use run_make_support::{gimli, llvm_version, object, rfs, rustc};
 
 fn main() {
     // Before LLVM 20, 128-bit enums with variants didn't emit debuginfo correctly.
     // This check can be removed once Rust no longer supports LLVM 18 and 19.
-    let llvm_version = rustc()
-        .verbose()
-        .arg("--version")
-        .run()
-        .stdout_utf8()
-        .lines()
-        .filter_map(|line| line.strip_prefix("LLVM version: "))
-        .map(|version| version.split(".").next().unwrap().parse::<u32>().unwrap())
-        .next()
-        .unwrap();
-    let is_old_llvm = llvm_version < 20;
+    let is_old_llvm = llvm_version() < (20, 0, 0);
 
     let output = PathBuf::from("repr128");
     let mut rustc = rustc();
diff --git a/tests/run-make/symbols-all-mangled/rmake.rs b/tests/run-make/symbols-all-mangled/rmake.rs
@@ -4,7 +4,9 @@
 //@ ignore-cross-compile (host-only)
 
 use run_make_support::object::read::{Object, ObjectSymbol};
-use run_make_support::{bin_name, dynamic_lib_name, object, rfs, rustc, static_lib_name};
+use run_make_support::{
+    bin_name, dynamic_lib_name, llvm_version, object, rfs, rustc, static_lib_name,
+};
 
 fn main() {
     let staticlib_name = static_lib_name("a_lib");
@@ -35,8 +37,8 @@ fn symbols_check_archive(path: &str) {
             continue; // All compiler-builtins symbols must remain unmangled
         }
 
-        if name.contains("rust_eh_personality") {
-            continue; // Unfortunately LLVM doesn't allow us to mangle this symbol
+        if llvm_version() < (22, 0, 0) && name.contains("rust_eh_personality") {
+            continue; // LLVM before 22 doesn't allow us to mangle this symbol
         }
 
         if name.contains(".llvm.") {
@@ -45,6 +47,11 @@ fn symbols_check_archive(path: &str) {
             continue;
         }
 
+        if name.starts_with("DW.ref.") {
+            // Debuginfo-helper symbol used for the personality
+            continue;
+        }
+
         panic!("Unmangled symbol found in {path}: {name}");
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ use cranelift_module::{`
`7`	`7`	`ModuleReloc, ModuleResult,`
`8`	`8`	`};`
`9`	`9`	`use cranelift_object::{ObjectModule, ObjectProduct};`
	`10`	`+use rustc_middle::ty::TyCtxt;`
`10`	`11`
`11`	`12`	`use crate::UnwindContext;`
`12`	`13`
`@@ -17,8 +18,8 @@ pub(crate) struct UnwindModule<T> {`
`17`	`18`	`}`
`18`	`19`
`19`	`20`	`impl<T: Module> UnwindModule<T> {`
`20`		`- pub(crate) fn new(mut module: T, pic_eh_frame: bool) -> Self {`
`21`		`- let unwind_context = UnwindContext::new(&mut module, pic_eh_frame);`
	`21`	`+ pub(crate) fn new(mut module: T, tcx: TyCtxt<'_>, pic_eh_frame: bool) -> Self {`
	`22`	`+ let unwind_context = UnwindContext::new(&mut module, tcx, pic_eh_frame);`
`22`	`23`	`UnwindModule { module, unwind_context }`
`23`	`24`	`}`
`24`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -258,6 +258,7 @@ impl CodegenBackend for GccCodegenBackend {`
`258`	`258`	`LTO_SUPPORTED.store(lto_supported, Ordering::SeqCst);`
`259`	`259`	`self.lto_supported.store(lto_supported, Ordering::SeqCst);`
`260`	`260`
	`261`	`+ // FIXME: This needs to mangle the personality, but that requires a tcx.`
`261`	`262`	`gccjit::set_global_personality_function_name(b"rust_eh_personality\0");`
`262`	`263`	`}`
`263`	`264`
Original file line number	Diff line number	Diff line change
`@@ -346,6 +346,11 @@ impl CodegenBackend for LlvmCodegenBackend {`
`346`	`346`	`llvm::LLVMRustLLVMHasZstdCompression()`
`347`	`347`	`}`
`348`	`348`
	`349`	`+ fn can_mangle_eh_personality(&self) -> bool {`
	`350`	`+ // https://github.com/llvm/llvm-project/pull/166095`
	`351`	`+ llvm_util::get_version() > (22, 0, 0)`
	`352`	`+ }`
	`353`	`+`
`349`	`354`	`fn target_config(&self, sess: &Session) -> TargetConfig {`
`350`	`355`	`target_config(sess)`
`351`	`356`	`}`