Add lint warn about clashing function names with fundamental functions

Cargo.lock

@@ -4042,6 +4042,7 @@ dependencies = [
  "rustc_parse_format",
  "rustc_session",
  "rustc_span",
+ "rustc_symbol_mangling",
  "rustc_target",
  "rustc_trait_selection",
  "smallvec",

compiler/rustc_lint/Cargo.toml

@@ -22,6 +22,7 @@ rustc_middle = { path = "../rustc_middle" }
 rustc_parse_format = { path = "../rustc_parse_format" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
+rustc_symbol_mangling = { path = "../rustc_symbol_mangling" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }

compiler/rustc_lint/messages.ftl

@@ -195,6 +195,11 @@ lint_cfg_attr_no_attributes =
 
 lint_check_name_unknown_tool = unknown lint tool: `{$tool_name}`
 
+lint_clashing_function_names_with_fundamental_functions = this function symbol name `{$symbol_name}` clashes with the fundamental functions expected with `core` and `std`
+ .match_exactly = extra care must be taken when exposing a function with those symbol names, they must match exactly (ABI, function arguments, function return type, behavior, ...)
+ .learn_more = see <https://doc.rust-lang.org/core/index.html#how-to-use-the-core-library> for the more details
+ .help = either allow this lint or remove any `#[unsafe(no_mangle)]` or `#[unsafe(export_name = "{$symbol_name}")]` if present
+
 lint_closure_returning_async_block = closure returning async block can be made into an async closure
  .label = this async block can be removed, and the closure can be turned into an async closure
  .suggestion = turn this into an async closure

compiler/rustc_lint/src/fundamental_functions.rs

@@ -0,0 +1,71 @@
+use rustc_hir as hir;
+use rustc_session::{declare_lint, declare_lint_pass};
+
+use crate::lints::ClashingFunctionNamesWithFundamentalFunctions;
+use crate::{LateContext, LateLintPass, LintContext};
+
+declare_lint! {
+ /// The `clashing_function_names_with_fundamental_functions` lint checks for function
+ /// name whose name clash with a fundamental functions expected by `core` and `std`.
+ ///
+ /// ### Example
+ ///
+ /// ```rust,compile_fail
+ /// #![deny(clashing_function_names_with_fundamental_functions)]
+ ///
+ /// #[unsafe(no_mangle)]
+ /// pub fn strlen() {} // clash with the libc `strlen` function
+ /// // care must be taken when implementing this function
+ /// ```
+ ///
+ /// {{produces}}
+ ///
+ /// ### Explanation
+ ///
+ /// Up-most care is required when overriding those fundamental functions assumed and
+ /// used by the standard library. They must follow the C specification, not use any
+ /// standard-library facility or undefined behavior may occur.
+ ///
+ /// The symbols currently checked are respectively:
+ /// - from `core`[^1]: `memcpy`, `memmove`, `memset`, `memcmp`, `bcmp`, `strlen`
+ /// - from `std`: `read`, `write`, `open`, `close`
+ ///
+ /// [^1]: https://doc.rust-lang.org/core/index.html#how-to-use-the-core-library
+ pub CLASHING_FUNCTION_NAMES_WITH_FUNDAMENTAL_FUNCTIONS,
+ Warn,
+ "using a function name that clashes with fundamental function names"
+}
+
+declare_lint_pass!(FundamentalFunctions => [CLASHING_FUNCTION_NAMES_WITH_FUNDAMENTAL_FUNCTIONS]);
+
+static CORE_FUNDAMENTAL_FUNCTION_NAMES: &[&str] =
+ &["memcpy", "memmove", "memset", "memcmp", "bcmp", "strlen"];
+
+static STD_FUNDAMENTAL_FUNCTION_NAMES: &[&str] = &["open", "read", "write", "close"];
+
+impl<'tcx> LateLintPass<'tcx> for FundamentalFunctions {
+ fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
+ let hir::ItemKind::Fn { sig: _, ident: _, generics: _, body: _, has_body: true } =
+ item.kind
+ else {
+ return;
+ };
+
+ let Some(symbol_name) = rustc_symbol_mangling::symbol_name_without_mangling(
+ cx.tcx,
+ rustc_middle::ty::InstanceKind::Item(item.owner_id.to_def_id()),
+ ) else {
+ return;
+ };
+
+ if CORE_FUNDAMENTAL_FUNCTION_NAMES.contains(&&*symbol_name)
+ || STD_FUNDAMENTAL_FUNCTION_NAMES.contains(&&*symbol_name)
+ {
+ cx.emit_span_lint(
+ CLASHING_FUNCTION_NAMES_WITH_FUNDAMENTAL_FUNCTIONS,
+ item.span,
+ ClashingFunctionNamesWithFundamentalFunctions { symbol_name },
+ );
+ }
+ }
+}

compiler/rustc_lint/src/lib.rs

@@ -48,6 +48,7 @@ mod errors;
 mod expect;
 mod for_loops_over_fallibles;
 mod foreign_modules;
+mod fundamental_functions;
 mod if_let_rescope;
 mod impl_trait_overcaptures;
 mod internal;
@@ -92,6 +93,7 @@ use deref_into_dyn_supertrait::*;
 use drop_forget_useless::*;
 use enum_intrinsics_non_enums::EnumIntrinsicsNonEnums;
 use for_loops_over_fallibles::*;
+use fundamental_functions::*;
 use if_let_rescope::IfLetRescope;
 use impl_trait_overcaptures::ImplTraitOvercaptures;
 use internal::*;
@@ -240,6 +242,7 @@ late_lint_methods!(
  AsyncClosureUsage: AsyncClosureUsage,
  AsyncFnInTrait: AsyncFnInTrait,
  NonLocalDefinitions: NonLocalDefinitions::default(),
+ FundamentalFunctions: FundamentalFunctions,
  ImplTraitOvercaptures: ImplTraitOvercaptures,
  IfLetRescope: IfLetRescope::default(),
  StaticMutRefs: StaticMutRefs,

compiler/rustc_lint/src/lints.rs

@@ -705,6 +705,16 @@ pub(crate) enum UseLetUnderscoreIgnoreSuggestion {
  },
 }
 
+// fundamental_functions.rs
+#[derive(LintDiagnostic)]
+#[diag(lint_clashing_function_names_with_fundamental_functions)]
+#[note(lint_match_exactly)]
+#[note(lint_learn_more)]
+#[help]
+pub(crate) struct ClashingFunctionNamesWithFundamentalFunctions {
+ pub symbol_name: String,
+}
+
 // drop_forget_useless.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_dropping_references)]

compiler/rustc_symbol_mangling/src/lib.rs

@@ -100,7 +100,7 @@ use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
 use rustc_middle::mir::mono::{InstantiationMode, MonoItem};
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, Instance, TyCtxt};
+use rustc_middle::ty::{self, Instance, InstanceKind, TyCtxt};
 use rustc_session::config::SymbolManglingVersion;
 use tracing::debug;
 
@@ -158,29 +158,22 @@ pub fn typeid_for_trait_ref<'tcx>(
  v0::mangle_typeid_for_trait_ref(tcx, trait_ref)
 }
 
-/// Computes the symbol name for the given instance. This function will call
-/// `compute_instantiating_crate` if it needs to factor the instantiating crate
-/// into the symbol name.
-fn compute_symbol_name<'tcx>(
+pub fn symbol_name_without_mangling<'tcx>(
  tcx: TyCtxt<'tcx>,
- instance: Instance<'tcx>,
- compute_instantiating_crate: impl FnOnce() -> CrateNum,
-) -> String {
- let def_id = instance.def_id();
- let args = instance.args;
-
- debug!("symbol_name(def_id={:?}, args={:?})", def_id, args);
+ instance_kind: InstanceKind<'tcx>,
+) -> Option<String> {
+ let def_id = instance_kind.def_id();
 
  if let Some(def_id) = def_id.as_local() {
  if tcx.proc_macro_decls_static(()) == Some(def_id) {
  let stable_crate_id = tcx.stable_crate_id(LOCAL_CRATE);
- return tcx.sess.generate_proc_macro_decls_symbol(stable_crate_id);
+ return Some(tcx.sess.generate_proc_macro_decls_symbol(stable_crate_id));
  }
  }
 
  // FIXME(eddyb) Precompute a custom symbol name based on attributes.
  let attrs = if tcx.def_kind(def_id).has_codegen_attrs() {
- &tcx.codegen_instance_attrs(instance.def)
+ &tcx.codegen_instance_attrs(instance_kind)
  } else {
  CodegenFnAttrs::EMPTY
  };
@@ -206,7 +199,7 @@ fn compute_symbol_name<'tcx>(
  // legacy symbol mangling scheme.
  let name = if let Some(name) = attrs.symbol_name { name } else { tcx.item_name(def_id) };
 
- return v0::mangle_internal_symbol(tcx, name.as_str());
+ return Some(v0::mangle_internal_symbol(tcx, name.as_str()));
  }
 
  let wasm_import_module_exception_force_mangling = {
@@ -234,15 +227,35 @@ fn compute_symbol_name<'tcx>(
  if !wasm_import_module_exception_force_mangling {
  if let Some(name) = attrs.symbol_name {
  // Use provided name
- return name.to_string();
+ return Some(name.to_string());
  }
 
  if attrs.flags.contains(CodegenFnAttrFlags::NO_MANGLE) {
  // Don't mangle
- return tcx.item_name(def_id).to_string();
+ return Some(tcx.item_name(def_id).to_string());
  }
  }
 
+ None
+}
+
+/// Computes the symbol name for the given instance. This function will call
+/// `compute_instantiating_crate` if it needs to factor the instantiating crate
+/// into the symbol name.
+fn compute_symbol_name<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ instance: Instance<'tcx>,
+ compute_instantiating_crate: impl FnOnce() -> CrateNum,
+) -> String {
+ let def_id = instance.def_id();
+ let args = instance.args;
+
+ debug!("symbol_name(def_id={:?}, args={:?})", def_id, args);
+
+ if let Some(symbol) = symbol_name_without_mangling(tcx, instance.def) {
+ return symbol;
+ }
+
  // If we're dealing with an instance of a function that's inlined from
  // another crate but we're marking it as globally shared to our
  // compilation (aka we're not making an internal copy in each of our

tests/ui/lint/clashing-fn-names-with-fundamental-functions.rs

@@ -0,0 +1,59 @@
+//@ check-pass
+//@ edition: 2021
+
+use std::ffi::c_void;
+
+// From core
+
+#[no_mangle]
+pub extern "C" fn memcpy(
+ dest: *mut c_void,
+ src: *const c_void,
+ n: i64,
+) -> *mut c_void { std::ptr::null_mut() }
+//~^^^^^ WARN `memcpy` clashes
+
+#[no_mangle]
+pub fn memmove() {}
+//~^ WARN `memmove` clashes
+
+#[no_mangle]
+pub fn memset() {}
+//~^ WARN `memset` clashes
+
+#[no_mangle]
+pub fn memcmp() {}
+//~^ WARN `memcmp` clashes
+
+#[export_name = "bcmp"]
+pub fn bcmp_() {}
+//~^ WARN `bcmp` clashes
+
+#[no_mangle]
+pub fn strlen() {}
+//~^ WARN `strlen` clashes
+
+// From std
+
+#[no_mangle]
+pub fn open() {}
+//~^ WARN `open` clashes
+
+#[export_name = "read"]
+pub async fn read1() {}
+//~^ WARN `read` clashes
+
+#[export_name = "write"]
+pub fn write1() {}
+//~^ WARN `write` clashes
+
+#[export_name = "close"]
+pub fn close_() {}
+//~^ WARN `close` clashes
+
+extern "C" {
+ // No warning, not a body.
+ pub fn close(a: i32) -> i32;
+}
+
+fn main() {}