Add weak-only lang items for core runtime symbols

Urgau · Urgau · commit 903b6adc86bc · 2026-06-04T20:08:47.000+02:00
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
@@ -448,6 +448,14 @@ language_item_table! {
 
     // Used to fallback `{float}` to `f32` when `f32: From<{float}>`
     From,                    sym::From,                from_trait,                 Target::Trait,          GenericRequirement::Exact(1);
+
+    // Runtime symbols
+    MemCpy,                  sym::memcpy_fn,           memcpy_fn,                  Target::Fn,             GenericRequirement::None;
+    MemMove,                 sym::memmove_fn,          memmove_fn,                 Target::Fn,             GenericRequirement::None;
+    MemSet,                  sym::memset_fn,           memset_fn,                  Target::Fn,             GenericRequirement::None;
+    MemCmp,                  sym::memcmp_fn,           memcmp_fn,                  Target::Fn,             GenericRequirement::None;
+    Bcmp,                    sym::bcmp_fn,             bcmp_fn,                    Target::Fn,             GenericRequirement::None;
+    StrLen,                  sym::strlen_fn,           strlen_fn,                  Target::Fn,             GenericRequirement::None;
 }
 
 /// The requirement imposed on the generics of a lang item
diff --git a/compiler/rustc_hir/src/weak_lang_items.rs b/compiler/rustc_hir/src/weak_lang_items.rs
@@ -23,8 +23,29 @@ macro_rules! weak_lang_items {
     }
 }
 
+macro_rules! weak_only_lang_items {
+    ($($item:ident,)*) => {
+        pub static WEAK_ONLY_LANG_ITEMS: &[LangItem] = &[$(LangItem::$item,)*];
+
+        impl LangItem {
+            pub fn is_weak_only(self) -> bool {
+                matches!(self, $(LangItem::$item)|*)
+            }
+        }
+    }
+}
+
 weak_lang_items! {
     PanicImpl,          rust_begin_unwind;
     EhPersonality,      rust_eh_personality;
     EhCatchTypeinfo,    rust_eh_catch_typeinfo;
 }
+
+weak_only_lang_items! {
+    MemCpy,
+    MemMove,
+    MemSet,
+    MemCmp,
+    Bcmp,
+    StrLen,
+}
diff --git a/compiler/rustc_passes/src/lang_items.rs b/compiler/rustc_passes/src/lang_items.rs
@@ -29,6 +29,11 @@ pub(crate) enum Duplicate {
     CrateDepends,
 }
 
+enum CollectWeak {
+    Allowed,
+    Ignore,
+}
+
 struct LanguageItemCollector<'ast, 'tcx> {
     items: LanguageItems,
     tcx: TyCtxt<'tcx>,
@@ -60,19 +65,24 @@ impl<'ast, 'tcx> LanguageItemCollector<'ast, 'tcx> {
         attrs: &'ast [ast::Attribute],
         item_span: Span,
         generics: Option<&'ast ast::Generics>,
+        collect_weak: CollectWeak,
     ) {
         if let Some((name, attr_span)) = extract_ast(attrs) {
             match LangItem::from_name(name) {
                 // Known lang item with attribute on correct target.
                 Some(lang_item) if actual_target == lang_item.target() => {
-                    self.collect_item_extended(
-                        lang_item,
-                        def_id,
-                        item_span,
-                        attr_span,
-                        generics,
-                        actual_target,
-                    );
+                    // Weak lang items are handled separately
+                    // Weak only lang items are always handled here
+                    if !lang_item.is_weak() || matches!(collect_weak, CollectWeak::Allowed) {
+                        self.collect_item_extended(
+                            lang_item,
+                            def_id,
+                            item_span,
+                            attr_span,
+                            generics,
+                            actual_target,
+                        );
+                    }
                 }
                 // Known lang item with attribute on incorrect target.
                 Some(lang_item) => {
@@ -299,20 +309,33 @@ impl<'ast, 'tcx> visit::Visitor<'ast> for LanguageItemCollector<'ast, 'tcx> {
             &i.attrs,
             i.span,
             i.opt_generics(),
+            CollectWeak::Allowed,
         );
 
         let parent_item = self.parent_item.replace(i);
         visit::walk_item(self, i);
         self.parent_item = parent_item;
     }
 
+    fn visit_foreign_item(&mut self, i: &'ast ast::ForeignItem) {
+        self.check_for_lang(
+            Target::Fn,
+            self.resolver.owners[&i.id].def_id,
+            &i.attrs,
+            i.span,
+            None,
+            CollectWeak::Ignore,
+        );
+    }
+
     fn visit_variant(&mut self, variant: &'ast ast::Variant) {
         self.check_for_lang(
             Target::Variant,
             self.resolver.owners[&self.parent_item.unwrap().id].node_id_to_def_id[&variant.id],
             &variant.attrs,
             variant.span,
             None,
+            CollectWeak::Allowed,
         );
     }
 
@@ -346,7 +369,14 @@ impl<'ast, 'tcx> visit::Visitor<'ast> for LanguageItemCollector<'ast, 'tcx> {
             }
         };
 
-        self.check_for_lang(target, self.resolver.owners[&i.id].def_id, &i.attrs, i.span, generics);
+        self.check_for_lang(
+            target,
+            self.resolver.owners[&i.id].def_id,
+            &i.attrs,
+            i.span,
+            generics,
+            CollectWeak::Allowed,
+        );
 
         visit::walk_assoc_item(self, i, ctxt);
     }
diff --git a/compiler/rustc_passes/src/weak_lang_items.rs b/compiler/rustc_passes/src/weak_lang_items.rs
@@ -48,11 +48,15 @@ struct WeakLangItemVisitor<'a, 'tcx> {
 impl<'ast> visit::Visitor<'ast> for WeakLangItemVisitor<'_, '_> {
     fn visit_foreign_item(&mut self, i: &'ast ast::ForeignItem) {
         if let Some((lang_item, _)) = extract_ast(&i.attrs) {
-            if let Some(item) = LangItem::from_name(lang_item)
-                && item.is_weak()
-            {
-                if self.items.get(item).is_none() {
-                    self.items.missing.push(item);
+            if let Some(item) = LangItem::from_name(lang_item) {
+                if item.is_weak() {
+                    if self.items.get(item).is_none() {
+                        self.items.missing.push(item);
+                    }
+                } else if item.is_weak_only() {
+                    // weak only lang items are handled directly in lang_items.rs
+                } else {
+                    self.tcx.dcx().emit_err(UnknownExternLangItem { span: i.span, lang_item });
                 }
             } else {
                 self.tcx.dcx().emit_err(UnknownExternLangItem { span: i.span, lang_item });
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -509,6 +509,7 @@ symbols! {
         backchain,
         backend_repr,
         bang,
+        bcmp_fn,
         begin_panic,
         bench,
         bevy_ecs,
@@ -1258,7 +1259,11 @@ symbols! {
         mem_variant_count,
         mem_zeroed,
         member_constraints,
+        memcmp_fn,
+        memcpy_fn,
+        memmove_fn,
         memory,
+        memset_fn,
         memtag,
         message,
         meta,
@@ -1997,6 +2002,7 @@ symbols! {
         strict_provenance_lints,
         string_deref_patterns,
         stringify,
+        strlen_fn,
         struct_field_attributes,
         struct_inherit,
         struct_variant,
diff --git a/library/core/src/ffi/mod.rs b/library/core/src/ffi/mod.rs
@@ -85,3 +85,30 @@ impl fmt::Debug for c_void {
 )]
 #[link(name = "/defaultlib:libcmt", modifiers = "+verbatim", cfg(target_feature = "crt-static"))]
 unsafe extern "C" {}
+
+// Used by rustc for checking the definitions of other function with the same symbol names
+//
+// See the `invalid_runtime_symbols_definitions` lint.
+mod runtime_symbols {
+    use crate::ffi::{c_char, c_int, c_void};
+
+    unsafe extern "C" {
+        #[lang = "memcpy_fn"]
+        fn memcpy(dest: *mut c_void, src: *const c_void, n: usize) -> *mut c_void;
+
+        #[lang = "memmove_fn"]
+        fn memmove(dest: *mut c_void, src: *const c_void, n: usize) -> *mut c_void;
+
+        #[lang = "memset_fn"]
+        fn memset(s: *mut c_void, c: c_int, n: usize) -> *mut c_void;
+
+        #[lang = "memcmp_fn"]
+        fn memcmp(s1: *const c_void, s2: *const c_void, n: usize) -> c_int;
+
+        #[lang = "bcmp_fn"]
+        fn bcmp(s1: *const c_void, s2: *const c_void, n: usize) -> c_int;
+
+        #[lang = "strlen_fn"]
+        fn strlen(s: *const c_char) -> usize;
+    }
+}
diff --git a/tests/ui/error-codes/E0264.rs b/tests/ui/error-codes/E0264.rs
@@ -1,7 +1,7 @@
 #![feature(lang_items)]
 
 extern "C" {
-    #[lang = "copy"]
+    #[lang = "copy"] //~ ERROR E0718
     fn copy(); //~ ERROR E0264
 }
 
diff --git a/tests/ui/error-codes/E0264.stderr b/tests/ui/error-codes/E0264.stderr
@@ -1,9 +1,16 @@
+error[E0718]: `copy` lang item must be applied to a trait
+  --> $DIR/E0264.rs:4:5
+   |
+LL |     #[lang = "copy"]
+   |     ^^^^^^^^^^^^^^^^ attribute should be applied to a trait, not a function
+
 error[E0264]: unknown external lang item: `copy`
   --> $DIR/E0264.rs:5:5
    |
 LL |     fn copy();
    |     ^^^^^^^^^^
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0264`.
+Some errors have detailed explanations: E0264, E0718.
+For more information about an error, try `rustc --explain E0264`.

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`#![feature(lang_items)]`
`2`	`2`
`3`	`3`	`extern "C" {`
`4`		`- #[lang = "copy"]`
	`4`	`+ #[lang = "copy"] //~ ERROR E0718`
`5`	`5`	`fn copy(); //~ ERROR E0264`
`6`	`6`	`}`
`7`	`7`