Add declaration-only lang items for core runtime symbols

Author: Urgau

compiler/rustc_hir/src/lang_items.rs

@@ -447,6 +447,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

compiler/rustc_hir/src/weak_lang_items.rs

@@ -23,8 +23,29 @@ macro_rules! weak_lang_items {
     }
 }
 
+macro_rules! decl_lang_items {
+    ($($item:ident,)*) => {
+        pub static DECL_LANG_ITEMS: &[LangItem] = &[$(LangItem::$item,)*];
+
+        impl LangItem {
+            pub fn is_decl(self) -> bool {
+                matches!(self, $(LangItem::$item)|*)
+            }
+        }
+    }
+}
+
 weak_lang_items! {
     PanicImpl,          rust_begin_unwind;
     EhPersonality,      rust_eh_personality;
     EhCatchTypeinfo,    rust_eh_catch_typeinfo;
 }
+
+decl_lang_items! {
+    MemCpy,
+    MemMove,
+    MemSet,
+    MemCmp,
+    Bcmp,
+    StrLen,
+}

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,23 @@ 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
+                    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 +308,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.node_id_to_def_id[&i.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.node_id_to_def_id[&variant.id],
             &variant.attrs,
             variant.span,
             None,
+            CollectWeak::Allowed,
         );
     }
 
@@ -352,6 +374,7 @@ impl<'ast, 'tcx> visit::Visitor<'ast> for LanguageItemCollector<'ast, 'tcx> {
             &i.attrs,
             i.span,
             generics,
+            CollectWeak::Allowed,
         );
 
         visit::walk_assoc_item(self, i, ctxt);

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_decl() {
+                    // delc 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 });

compiler/rustc_span/src/symbol.rs

@@ -508,6 +508,7 @@ symbols! {
         backchain,
         backend_repr,
         bang,
+        bcmp_fn,
         begin_panic,
         bench,
         bevy_ecs,
@@ -1248,7 +1249,11 @@ symbols! {
         mem_variant_count,
         mem_zeroed,
         member_constraints,
+        memcmp_fn,
+        memcpy_fn,
+        memmove_fn,
         memory,
+        memset_fn,
         memtag,
         message,
         meta,
@@ -1983,6 +1988,7 @@ symbols! {
         strict_provenance_lints,
         string_deref_patterns,
         stringify,
+        strlen_fn,
         struct_field_attributes,
         struct_inherit,
         struct_variant,

library/core/src/ffi/mod.rs

@@ -91,3 +91,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;
+    }
+}