error or warn when using no_mangle on language items

Author: alexandruradovici

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -87,6 +87,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
     let mut link_ordinal_span = None;
     let mut no_sanitize_span = None;
     let mut mixed_export_name_no_mangle_lint_state = MixedExportNameAndNoMangleState::default();
+    let mut no_mangle_span = None;
 
     for attr in attrs.iter() {
         // In some cases, attribute are only valid on functions, but it's the `check_attr`
@@ -139,6 +140,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
             }
             sym::naked => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED,
             sym::no_mangle => {
+                no_mangle_span = Some(attr.span());
                 if tcx.opt_item_name(did.to_def_id()).is_some() {
                     codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
                     mixed_export_name_no_mangle_lint_state.track_no_mangle(
@@ -608,11 +610,55 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
     // strippable by the linker.
     //
     // Additionally weak lang items have predetermined symbol names.
-    if let Some((name, _)) = lang_items::extract(attrs)
+    if let Some((name, span)) = lang_items::extract(attrs)
         && let Some(lang_item) = LangItem::from_name(name)
     {
+        let has_no_mangle = codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NO_MANGLE);
         if WEAK_LANG_ITEMS.contains(&lang_item) {
             codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL;
+            if has_no_mangle {
+                // This should never use the default as `no_mangle` is present in the attributes list
+                let no_mangle_span = no_mangle_span.unwrap_or_default();
+                let label_attr = format!("this defines it as the `{}` item", lang_item.name());
+                let label = format!("is the {} item", lang_item.name());
+                let mut err = tcx.dcx()
+                    .struct_span_err(no_mangle_span, "`#[no_mangle]` cannot be used on weak language items")
+                    .with_note("The linker requires specific names for internal language items,")
+                    .with_note("like panic handlers, eh personality functions or eh catch typeinfo variables.")
+                    .with_span_label(tcx.def_span(did), label)
+                    .with_span_label(span, label_attr);
+                if let Some(link_name) = lang_item.link_name() {
+                    let renamed =
+                        format!("In this case it is automatically renamed to `{}`", link_name);
+                    err = err.with_note(renamed);
+                }
+                err.emit();
+            }
+        } else {
+            if has_no_mangle {
+                // This should never use the default as `no_mangle` is present in the attributes list
+                let no_mangle_span = no_mangle_span.unwrap_or_default();
+                let label_attr = format!("this defines it as the `{}` item", lang_item.name());
+                let label = format!("is the {} item", lang_item.name());
+                let mut warn = tcx
+                    .dcx()
+                    .struct_span_warn(
+                        no_mangle_span,
+                        "`#[no_mangle]` should not be used on std internal language items",
+                    )
+                    .with_note("The linker requires specific names for internal language items,")
+                    .with_note("as they might require a specific link name in the future.")
+                    .with_span_label(tcx.def_span(did), label)
+                    .with_span_label(span, label_attr);
+                if let Some(link_name) = lang_item.link_name() {
+                    let renamed = format!(
+                        "In this case this should be automatically renamed to `{}`",
+                        link_name
+                    );
+                    warn = warn.with_note(renamed);
+                }
+                warn.emit();
+            }
         }
         if let Some(link_name) = lang_item.link_name() {
             codegen_fn_attrs.export_name = Some(link_name);

tests/ui/codegen/no_mangle_on_std_internal_lang_items.rs

@@ -0,0 +1,15 @@
+// Issue a warning when the user #[no_mangle] on weak language items
+//@ check-pass
+//@ edition:2024
+
+#![crate_type="lib"]
+#![no_std]
+#![no_main]
+#![feature(lang_items)]
+
+#[lang = "start"]
+#[unsafe(no_mangle)] //~WARN `#[no_mangle]` should not be used on std internal language items
+fn my_custom_start<T>(main: fn() -> T, _argc: isize, _argv: *const *const u8, _arg: u8) -> isize { //~ WARN functions generic over types or consts must be mangled
+    main();
+    0
+}

tests/ui/codegen/no_mangle_on_std_internal_lang_items.stderr

@@ -0,0 +1,28 @@
+warning: `#[no_mangle]` should not be used on std internal language items
+  --> $DIR/no_mangle_on_std_internal_lang_items.rs:11:1
+   |
+LL | #[lang = "start"]
+   | ----------------- this defines it as the `start` item
+LL | #[unsafe(no_mangle)]
+   | ^^^^^^^^^^^^^^^^^^^^
+LL | fn my_custom_start<T>(main: fn() -> T, _argc: isize, _argv: *const *const u8, _arg: u8) -> isize {
+   | ------------------------------------------------------------------------------------------------ is the start item
+   |
+   = note: The linker requires specific names for internal language items,
+   = note: as they might require a specific link name in the future.
+
+warning: functions generic over types or consts must be mangled
+  --> $DIR/no_mangle_on_std_internal_lang_items.rs:12:1
+   |
+LL |   #[unsafe(no_mangle)]
+   |   -------------------- help: remove this attribute
+LL | / fn my_custom_start<T>(main: fn() -> T, _argc: isize, _argv: *const *const u8, _arg: u8) -> isize {
+LL | |     main();
+LL | |     0
+LL | | }
+   | |_^
+   |
+   = note: `#[warn(no_mangle_generic_items)]` on by default
+
+warning: 2 warnings emitted
+

tests/ui/codegen/no_mangle_on_weak_lang_items.rs

@@ -0,0 +1,14 @@
+// Issue an error when the user #[no_mangle] on weak language items
+//@ edition:2024
+
+#![crate_type="lib"]
+#![no_std]
+#![no_main]
+
+use core::panic::PanicInfo;
+
+#[unsafe(no_mangle)] //~ ERROR `#[no_mangle]` cannot be used on weak language items
+#[panic_handler]
+pub unsafe fn panic_fmt(pi: &PanicInfo) -> ! {
+    loop {}
+}

tests/ui/codegen/no_mangle_on_weak_lang_items.stderr

@@ -0,0 +1,16 @@
+error: `#[no_mangle]` cannot be used on weak language items
+  --> $DIR/no_mangle_on_weak_lang_items.rs:10:1
+   |
+LL | #[unsafe(no_mangle)]
+   | ^^^^^^^^^^^^^^^^^^^^
+LL | #[panic_handler]
+   | ---------------- this defines it as the `panic_impl` item
+LL | pub unsafe fn panic_fmt(pi: &PanicInfo) -> ! {
+   | -------------------------------------------- is the panic_impl item
+   |
+   = note: The linker requires specific names for internal language items,
+   = note: like panic handlers, eh personality functions or eh catch typeinfo variables.
+   = note: In this case it is automatically renamed to `rust_begin_unwind`
+
+error: aborting due to 1 previous error
+