Auto merge of rust-lang#127173 - bjorn3:mangle_rustc_std_internal_sym…

…bol, r=<try>

Mangle rustc_std_internal_symbols functions

This reduces the risk of issues when using a staticlib or rust dylib compiled with a different rustc version in a rust program. Currently this will either (in the case of staticlib) cause a linker error due to duplicate symbol definitions, or (in the case of rust dylibs) cause rustc_std_internal_symbols functions to be silently overridden. As rust gets more commonly used inside the implementation of libraries consumed with a C interface (like Spidermonkey, Ruby YJIT (curently has to do partial linking of all rust code to hide all symbols not part of the C api), the Rusticl OpenCL implementation in mesa) this is becoming much more of an issue. With this PR the only symbols remaining with an unmangled name are rust_eh_personality (LLVM doesn't allow renaming it) and `__rust_no_alloc_shim_is_unstable`.

Helps mitigate rust-lang#104707

compiler/rustc_codegen_cranelift/src/allocator.rs

@@ -7,13 +7,15 @@ use rustc_ast::expand::allocator::{
 };
 use rustc_codegen_ssa::base::allocator_kind_for_codegen;
 use rustc_session::config::OomStrategy;
+use rustc_symbol_mangling::mangle_internal_symbol;
 
 use crate::prelude::*;
 
 /// Returns whether an allocator shim was created
 pub(crate) fn codegen(tcx: TyCtxt<'_>, module: &mut dyn Module) -> bool {
  let Some(kind) = allocator_kind_for_codegen(tcx) else { return false };
  codegen_inner(
+ tcx,
  module,
  kind,
  tcx.alloc_error_handler_kind(()).unwrap(),
@@ -23,6 +25,7 @@ pub(crate) fn codegen(tcx: TyCtxt<'_>, module: &mut dyn Module) -> bool {
 }
 
 fn codegen_inner(
+ tcx: TyCtxt<'_>,
  module: &mut dyn Module,
  kind: AllocatorKind,
  alloc_error_handler_kind: AllocatorKind,
@@ -62,8 +65,8 @@ fn codegen_inner(
  crate::common::create_wrapper_function(
  module,
  sig,
- &global_fn_name(method.name),
- &default_fn_name(method.name),
+ &mangle_internal_symbol(tcx, &global_fn_name(method.name)),
+ &mangle_internal_symbol(tcx, &default_fn_name(method.name)),
  );
  }
  }
@@ -76,19 +79,32 @@ fn codegen_inner(
  crate::common::create_wrapper_function(
  module,
  sig,
- "__rust_alloc_error_handler",
- &alloc_error_handler_name(alloc_error_handler_kind),
+ &mangle_internal_symbol(tcx, "__rust_alloc_error_handler"),
+ &mangle_internal_symbol(tcx, &alloc_error_handler_name(alloc_error_handler_kind)),
  );
 
- let data_id = module.declare_data(OomStrategy::SYMBOL, Linkage::Export, false, false).unwrap();
+ let data_id = module
+ .declare_data(
+ &mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
+ Linkage::Export,
+ false,
+ false,
+ )
+ .unwrap();
  let mut data = DataDescription::new();
  data.set_align(1);
  let val = oom_strategy.should_panic();
  data.define(Box::new([val]));
  module.define_data(data_id, &data).unwrap();
 
- let data_id =
- module.declare_data(NO_ALLOC_SHIM_IS_UNSTABLE, Linkage::Export, false, false).unwrap();
+ let data_id = module
+ .declare_data(
+ &mangle_internal_symbol(tcx, NO_ALLOC_SHIM_IS_UNSTABLE),
+ Linkage::Export,
+ false,
+ false,
+ )
+ .unwrap();
  let mut data = DataDescription::new();
  data.set_align(1);
  data.define(Box::new([0]));

compiler/rustc_codegen_cranelift/src/lib.rs

@@ -27,6 +27,7 @@ extern crate rustc_index;
 extern crate rustc_metadata;
 extern crate rustc_session;
 extern crate rustc_span;
+extern crate rustc_symbol_mangling;
 extern crate rustc_target;
 
 // This prevents duplicating functions and statics that are already part of the host rustc process.

compiler/rustc_codegen_gcc/src/allocator.rs

@@ -8,6 +8,7 @@ use rustc_ast::expand::allocator::{
 use rustc_middle::bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::OomStrategy;
+use rustc_symbol_mangling::mangle_internal_symbol;
 
 use crate::GccContext;
 
@@ -51,8 +52,8 @@ pub(crate) unsafe fn codegen(
  panic!("invalid allocator output")
  }
  };
- let from_name = global_fn_name(method.name);
- let to_name = default_fn_name(method.name);
+ let from_name = mangle_internal_symbol(tcx, &global_fn_name(method.name));
+ let to_name = mangle_internal_symbol(tcx, &default_fn_name(method.name));
 
  create_wrapper_function(tcx, context, &from_name, &to_name, &types, output);
  }
@@ -62,19 +63,19 @@ pub(crate) unsafe fn codegen(
  create_wrapper_function(
  tcx,
  context,
- "__rust_alloc_error_handler",
- alloc_error_handler_name(alloc_error_handler_kind),
+ &mangle_internal_symbol(tcx, "__rust_alloc_error_handler"),
+ &mangle_internal_symbol(tcx, &alloc_error_handler_name(alloc_error_handler_kind)),
  &[usize, usize],
  None,
  );
 
- let name = OomStrategy::SYMBOL.to_string();
+ let name = mangle_internal_symbol(tcx, OomStrategy::SYMBOL);
  let global = context.new_global(None, GlobalKind::Exported, i8, name);
  let value = tcx.sess.opts.unstable_opts.oom.should_panic();
  let value = context.new_rvalue_from_int(i8, value as i32);
  global.global_set_initializer_rvalue(value);
 
- let name = NO_ALLOC_SHIM_IS_UNSTABLE.to_string();
+ let name = mangle_internal_symbol(tcx, NO_ALLOC_SHIM_IS_UNSTABLE);
  let global = context.new_global(None, GlobalKind::Exported, i8, name);
  let value = context.new_rvalue_from_int(i8, 0);
  global.global_set_initializer_rvalue(value);

compiler/rustc_codegen_gcc/src/lib.rs

@@ -41,6 +41,7 @@ extern crate rustc_metadata;
 extern crate rustc_middle;
 extern crate rustc_session;
 extern crate rustc_span;
+extern crate rustc_symbol_mangling;
 extern crate rustc_target;
 #[macro_use]
 extern crate tracing;

compiler/rustc_codegen_llvm/src/allocator.rs

@@ -6,6 +6,7 @@ use rustc_ast::expand::allocator::{
 use rustc_middle::bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{DebugInfo, OomStrategy};
+use rustc_symbol_mangling::mangle_internal_symbol;
 
 use crate::llvm::{self, Context, False, Module, True, Type};
 use crate::{attributes, debuginfo, ModuleLlvm};
@@ -54,8 +55,8 @@ pub(crate) unsafe fn codegen(
  }
  };
 
- let from_name = global_fn_name(method.name);
- let to_name = default_fn_name(method.name);
+ let from_name = mangle_internal_symbol(tcx, &global_fn_name(method.name));
+ let to_name = mangle_internal_symbol(tcx, &default_fn_name(method.name));
 
  create_wrapper_function(tcx, llcx, llmod, &from_name, &to_name, &args, output, false);
  }
@@ -66,16 +67,16 @@ pub(crate) unsafe fn codegen(
  tcx,
  llcx,
  llmod,
- "__rust_alloc_error_handler",
- alloc_error_handler_name(alloc_error_handler_kind),
+ &mangle_internal_symbol(tcx, "__rust_alloc_error_handler"),
+ &mangle_internal_symbol(tcx, alloc_error_handler_name(alloc_error_handler_kind)),
  &[usize, usize], // size, align
  None,
  true,
  );
 
  unsafe {
  // __rust_alloc_error_handler_should_panic
- let name = OomStrategy::SYMBOL;
+ let name = mangle_internal_symbol(tcx, OomStrategy::SYMBOL);
  let ll_g = llvm::LLVMRustGetOrInsertGlobal(llmod, name.as_ptr().cast(), name.len(), i8);
  if tcx.sess.default_hidden_visibility() {
  llvm::LLVMRustSetVisibility(ll_g, llvm::Visibility::Hidden);
@@ -84,7 +85,7 @@ pub(crate) unsafe fn codegen(
  let llval = llvm::LLVMConstInt(i8, val as u64, False);
  llvm::LLVMSetInitializer(ll_g, llval);
 
- let name = NO_ALLOC_SHIM_IS_UNSTABLE;
+ let name = mangle_internal_symbol(tcx, NO_ALLOC_SHIM_IS_UNSTABLE);
  let ll_g = llvm::LLVMRustGetOrInsertGlobal(llmod, name.as_ptr().cast(), name.len(), i8);
  if tcx.sess.default_hidden_visibility() {
  llvm::LLVMRustSetVisibility(ll_g, llvm::Visibility::Hidden);

compiler/rustc_codegen_llvm/src/context.rs

@@ -24,6 +24,7 @@ use rustc_session::config::{
 use rustc_session::Session;
 use rustc_span::source_map::Spanned;
 use rustc_span::{Span, DUMMY_SP};
+use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::abi::call::FnAbi;
 use rustc_target::abi::{HasDataLayout, TargetDataLayout, VariantIdx};
 use rustc_target::spec::{HasTargetSpec, RelocModel, Target, TlsModel};
@@ -1053,7 +1054,7 @@ impl<'ll> CodegenCx<'ll, '_> {
  Some(def_id) => self.get_static(def_id),
  _ => {
  let ty = self.type_struct(&[self.type_ptr(), self.type_ptr()], false);
- self.declare_global("rust_eh_catch_typeinfo", ty)
+ self.declare_global(&mangle_internal_symbol(self.tcx, "rust_eh_catch_typeinfo"), ty)
  }
  };
  self.eh_catch_typeinfo.set(Some(eh_catch_typeinfo));

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -12,6 +12,7 @@ use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, LayoutOf};
 use rustc_middle::ty::{self, GenericArgsRef, Ty};
 use rustc_middle::{bug, span_bug};
 use rustc_span::{sym, Span, Symbol};
+use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::abi::{self, Align, Float, HasDataLayout, Primitive, Size};
 use rustc_target::spec::{HasTargetSpec, PanicStrategy};
 use tracing::debug;
@@ -766,7 +767,10 @@ fn codegen_msvc_try<'ll>(
  let type_name = bx.const_bytes(b"rust_panic\0");
  let type_info =
  bx.const_struct(&[type_info_vtable, bx.const_null(bx.type_ptr()), type_name], false);
- let tydesc = bx.declare_global("__rust_panic_type_info", bx.val_ty(type_info));
+ let tydesc = bx.declare_global(
+ &mangle_internal_symbol(bx.tcx, "__rust_panic_type_info"),
+ bx.val_ty(type_info),
+ );
  unsafe {
  llvm::LLVMRustSetLinkage(tydesc, llvm::Linkage::LinkOnceODRLinkage);
  llvm::SetUniqueComdat(bx.llmod, tydesc);

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -1,6 +1,6 @@
 use std::collections::hash_map::Entry::*;
 
-use rustc_ast::expand::allocator::{ALLOCATOR_METHODS, NO_ALLOC_SHIM_IS_UNSTABLE};
+use rustc_ast::expand::allocator::{global_fn_name, ALLOCATOR_METHODS, NO_ALLOC_SHIM_IS_UNSTABLE};
 use rustc_data_structures::unord::UnordMap;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, LOCAL_CRATE};
@@ -13,6 +13,7 @@ use rustc_middle::query::LocalCrate;
 use rustc_middle::ty::{self, GenericArgKind, GenericArgsRef, Instance, SymbolName, TyCtxt};
 use rustc_middle::util::Providers;
 use rustc_session::config::{CrateType, OomStrategy};
+use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::{SanitizerSet, TlsModel};
 use tracing::debug;
 
@@ -218,8 +219,11 @@ fn exported_symbols_provider_local(
  if allocator_kind_for_codegen(tcx).is_some() {
  for symbol_name in ALLOCATOR_METHODS
  .iter()
- .map(|method| format!("__rust_{}", method.name))
- .chain(["__rust_alloc_error_handler".to_string(), OomStrategy::SYMBOL.to_string()])
+ .map(|method| mangle_internal_symbol(tcx, global_fn_name(method.name).as_str()))
+ .chain([
+ mangle_internal_symbol(tcx, "__rust_alloc_error_handler"),
+ mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
+ ])
  {
  let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(tcx, &symbol_name));
 
@@ -233,8 +237,10 @@ fn exported_symbols_provider_local(
  ));
  }
 
- let exported_symbol =
- ExportedSymbol::NoDefId(SymbolName::new(tcx, NO_ALLOC_SHIM_IS_UNSTABLE));
+ let exported_symbol = ExportedSymbol::NoDefId(SymbolName::new(
+ tcx,
+ &mangle_internal_symbol(tcx, NO_ALLOC_SHIM_IS_UNSTABLE),
+ ));
  symbols.push((
  exported_symbol,
  SymbolExportInfo {

compiler/rustc_codegen_ssa/src/base.rs

@@ -26,6 +26,7 @@ use rustc_session::config::{self, CrateType, EntryFnType, OptLevel, OutputType};
 use rustc_session::Session;
 use rustc_span::symbol::sym;
 use rustc_span::{Symbol, DUMMY_SP};
+use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::abi::FIRST_VARIANT;
 use tracing::{debug, info};
 
@@ -951,7 +952,12 @@ impl CrateInfo {
  .for_each(|(_, linked_symbols)| {
  let mut symbols = missing_weak_lang_items
  .iter()
- .map(|item| (format!("{prefix}{item}"), SymbolExportKind::Text))
+ .map(|item| {
+ (
+ format!("{prefix}{}", mangle_internal_symbol(tcx, item.as_str())),
+ SymbolExportKind::Text,
+ )
+ })
  .collect::<Vec<_>>();
  symbols.sort_unstable_by(|a, b| a.0.cmp(&b.0));
  linked_symbols.extend(symbols);
@@ -964,7 +970,13 @@ impl CrateInfo {
  // errors.
  linked_symbols.extend(ALLOCATOR_METHODS.iter().map(|method| {
  (
- format!("{prefix}{}", global_fn_name(method.name).as_str()),
+ format!(
+ "{prefix}{}",
+ mangle_internal_symbol(
+ tcx,
+ global_fn_name(method.name).as_str()
+ )
+ ),
  SymbolExportKind::Text,
  )
  }));

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -655,25 +655,19 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
  // strippable by the linker.
  //
  // Additionally weak lang items have predetermined symbol names.
- if WEAK_LANG_ITEMS.iter().any(|&l| tcx.lang_items().get(l) == Some(did.to_def_id())) {
- codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL;
- }
  if let Some((name, _)) = lang_items::extract(attrs)
  && let Some(lang_item) = LangItem::from_name(name)
- && let Some(link_name) = lang_item.link_name()
  {
- codegen_fn_attrs.export_name = Some(link_name);
- codegen_fn_attrs.link_name = Some(link_name);
+ if WEAK_LANG_ITEMS.iter().any(|&l| l == lang_item) {
+ codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL;
+ }
+ if let Some(link_name) = lang_item.link_name() {
+ codegen_fn_attrs.export_name = Some(link_name);
+ codegen_fn_attrs.link_name = Some(link_name);
+ }
  }
  check_link_name_xor_ordinal(tcx, &codegen_fn_attrs, link_ordinal_span);
 
- // Internal symbols to the standard library all have no_mangle semantics in
- // that they have defined symbol names present in the function name. This
- // also applies to weak symbols where they all have known symbol names.
- if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL) {
- codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
- }
-
  // Any linkage to LLVM intrinsics for now forcibly marks them all as never
  // unwinds since LLVM sometimes can't handle codegen which `invoke`s
  // intrinsic functions.

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -168,6 +168,7 @@ impl CodegenFnAttrs {
  /// * `#[linkage]` is present
  pub fn contains_extern_indicator(&self) -> bool {
  self.flags.contains(CodegenFnAttrFlags::NO_MANGLE)
+ || self.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL)
  || self.export_name.is_some()
  || match self.linkage {
  // These are private, so make sure we don't try to consider

compiler/rustc_passes/src/check_attr.rs

@@ -2055,7 +2055,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
 
  fn check_rustc_std_internal_symbol(&self, attr: &Attribute, span: Span, target: Target) {
  match target {
- Target::Fn | Target::Static => {}
+ Target::Fn | Target::Static | Target::ForeignFn | Target::ForeignStatic => {}
  _ => {
  self.tcx
  .dcx()

compiler/rustc_passes/src/reachable.rs

@@ -184,9 +184,7 @@ impl<'tcx> ReachableContext<'tcx> {
  CodegenFnAttrs::EMPTY
  };
  let is_extern = codegen_attrs.contains_extern_indicator();
- let std_internal =
- codegen_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL);
- if is_extern || std_internal {
+ if is_extern {
  self.reachable_symbols.insert(search_item);
  }
  } else {
@@ -426,7 +424,6 @@ fn has_custom_linkage(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
  }
  let codegen_attrs = tcx.codegen_fn_attrs(def_id);
  codegen_attrs.contains_extern_indicator()
- || codegen_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL)
  // FIXME(nbdd0121): `#[used]` are marked as reachable here so it's picked up by
  // `linked_symbols` in cg_ssa. They won't be exported in binary or cdylib due to their
  // `SymbolExportLevel::Rust` export level but may end up being exported in dylibs.