From a077f35bb9334431ec1fee08ba29d19eed718aed Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sat, 2 Dec 2023 14:17:33 +0000
Subject: [PATCH 1/2] Remove implicit #[no_mangle] for
#[rustc_std_internal_symbol]
---
.../rustc_codegen_cranelift/src/allocator.rs | 30 ++++++++++++++-----
compiler/rustc_codegen_cranelift/src/lib.rs | 1 +
compiler/rustc_codegen_gcc/src/allocator.rs | 13 ++++----
compiler/rustc_codegen_gcc/src/lib.rs | 1 +
compiler/rustc_codegen_llvm/src/allocator.rs | 13 ++++----
compiler/rustc_codegen_llvm/src/context.rs | 3 +-
compiler/rustc_codegen_llvm/src/intrinsic.rs | 6 +++-
.../src/back/symbol_export.rs | 16 ++++++----
compiler/rustc_codegen_ssa/src/base.rs | 16 ++++++++--
.../rustc_codegen_ssa/src/codegen_attrs.rs | 20 +++++--------
compiler/rustc_symbol_mangling/src/v0.rs | 9 ++++++
tests/codegen/alloc-optimisation.rs | 2 +-
tests/codegen/box-uninit-bytes.rs | 2 +-
tests/codegen/dealloc-no-unwind.rs | 2 +-
tests/codegen/iter-repeat-n-trivial-drop.rs | 2 +-
tests/codegen/vec-calloc.rs | 2 +-
tests/codegen/vec-optimizes-away.rs | 2 +-
17 files changed, 93 insertions(+), 47 deletions(-)
diff --git a/compiler/rustc_codegen_cranelift/src/allocator.rs b/compiler/rustc_codegen_cranelift/src/allocator.rs
index b4a3825e9965f..f4b3a37d6c606 100644
--- a/compiler/rustc_codegen_cranelift/src/allocator.rs
+++ b/compiler/rustc_codegen_cranelift/src/allocator.rs
@@ -7,6 +7,7 @@ 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::*;
@@ -14,6 +15,7 @@ use crate::prelude::*;
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]));
diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs
index 192e6c91ea38b..29be55325ec52 100644
--- a/compiler/rustc_codegen_cranelift/src/lib.rs
+++ b/compiler/rustc_codegen_cranelift/src/lib.rs
@@ -27,6 +27,7 @@ extern crate rustc_metadata;
extern crate rustc_monomorphize;
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.
diff --git a/compiler/rustc_codegen_gcc/src/allocator.rs b/compiler/rustc_codegen_gcc/src/allocator.rs
index deeb55e9d128e..bba35dbf117aa 100644
--- a/compiler/rustc_codegen_gcc/src/allocator.rs
+++ b/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);
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 24856506c4644..cde69dff83120 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -40,6 +40,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;
diff --git a/compiler/rustc_codegen_llvm/src/allocator.rs b/compiler/rustc_codegen_llvm/src/allocator.rs
index ca37602973540..1ec7e6d4c3064 100644
--- a/compiler/rustc_codegen_llvm/src/allocator.rs
+++ b/compiler/rustc_codegen_llvm/src/allocator.rs
@@ -7,6 +7,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::debuginfo;
use crate::llvm::{self, Context, False, Module, True, Type};
@@ -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,15 +67,15 @@ 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,
);
// __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);
@@ -83,7 +84,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);
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 77beb9a6bb386..5dd4a8700da61 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -29,6 +29,7 @@ use rustc_session::config::{CrateType, DebugInfo, PAuthKey, PacRet};
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, HasDataLayout, TargetDataLayout, VariantIdx};
use rustc_target::spec::{HasTargetSpec, RelocModel, Target, TlsModel};
use smallvec::SmallVec;
@@ -1017,7 +1018,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));
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index e02c61cd29654..c58469ff2c932 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -19,6 +19,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;
@@ -737,7 +738,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);
diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
index 6abe4fa1c3809..15c048d5c3240 100644
--- a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
+++ b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
@@ -2,7 +2,7 @@ use crate::base::allocator_kind_for_codegen;
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};
@@ -17,6 +17,7 @@ use rustc_middle::ty::{self, SymbolName, TyCtxt};
use rustc_middle::ty::{GenericArgKind, GenericArgsRef};
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;
@@ -220,8 +221,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));
@@ -235,8 +239,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 {
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 137f14fe706cc..e3563386f3752 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -38,6 +38,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 std::cmp;
@@ -926,7 +927,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);
@@ -939,7 +945,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,
)
}));
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 56a893738df60..56386ada26d79 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -652,25 +652,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.
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 56087a8ad2205..deb086efa8975 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -76,6 +76,15 @@ pub(super) fn mangle<'tcx>(
}
pub fn mangle_internal_symbol<'tcx>(tcx: TyCtxt<'tcx>, item_name: &str) -> String {
+ if item_name == "rust_eh_personality" {
+ // rust_eh_personality must not be renamed as LLVM hard-codes the name
+ return "rust_eh_personality".to_owned();
+ } else if item_name == "__rust_no_alloc_shim_is_unstable" {
+ // Temporary back compat hack to give people the chance to migrate to
+ // include #[rustc_std_internal_symbol].
+ return "__rust_no_alloc_shim_is_unstable".to_owned();
+ }
+
let prefix = "_R";
let mut cx: SymbolMangler<'_> = SymbolMangler {
tcx,
diff --git a/tests/codegen/alloc-optimisation.rs b/tests/codegen/alloc-optimisation.rs
index 6f320e68fdb30..6bc72be996857 100644
--- a/tests/codegen/alloc-optimisation.rs
+++ b/tests/codegen/alloc-optimisation.rs
@@ -5,7 +5,7 @@
pub fn alloc_test(data: u32) {
// CHECK-LABEL: @alloc_test
// CHECK-NEXT: start:
- // CHECK-NEXT: {{.*}} load volatile i8, ptr @__rust_no_alloc_shim_is_unstable, align 1
+ // CHECK-NEXT: {{.*}} load volatile i8, ptr @{{.*}}__rust_no_alloc_shim_is_unstable, align 1
// CHECK-NEXT: ret void
let x = Box::new(data);
drop(x);
diff --git a/tests/codegen/box-uninit-bytes.rs b/tests/codegen/box-uninit-bytes.rs
index 63a6c7b841560..babaf8f7fdb27 100644
--- a/tests/codegen/box-uninit-bytes.rs
+++ b/tests/codegen/box-uninit-bytes.rs
@@ -41,6 +41,6 @@ pub fn box_lotsa_padding() -> Box<LotsaPadding> {
// Hide the `allocalign` attribute in the declaration of __rust_alloc
// from the CHECK-NOT above, and also verify the attributes got set reasonably.
-// CHECK: declare {{(dso_local )?}}noalias noundef ptr @__rust_alloc(i{{[0-9]+}} noundef, i{{[0-9]+}} allocalign noundef) unnamed_addr [[RUST_ALLOC_ATTRS:#[0-9]+]]
+// CHECK: declare {{(dso_local )?}}noalias noundef ptr @{{.*}}__rust_alloc(i{{[0-9]+}} noundef, i{{[0-9]+}} allocalign noundef) unnamed_addr [[RUST_ALLOC_ATTRS:#[0-9]+]]
// CHECK-DAG: attributes [[RUST_ALLOC_ATTRS]] = { {{.*}} allockind("alloc,uninitialized,aligned") allocsize(0) {{(uwtable )?}}"alloc-family"="__rust_alloc" {{.*}} }
diff --git a/tests/codegen/dealloc-no-unwind.rs b/tests/codegen/dealloc-no-unwind.rs
index ead26da610e25..c427dacc58445 100644
--- a/tests/codegen/dealloc-no-unwind.rs
+++ b/tests/codegen/dealloc-no-unwind.rs
@@ -18,7 +18,7 @@ impl Drop for A {
#[no_mangle]
pub fn a(a: Box<i32>) {
// CHECK-LABEL: define{{.*}}void @a
- // CHECK: call void @__rust_dealloc
+ // CHECK: call void @{{.*}}__rust_dealloc
// CHECK-NEXT: call void @foo
let _a = A;
drop(a);
diff --git a/tests/codegen/iter-repeat-n-trivial-drop.rs b/tests/codegen/iter-repeat-n-trivial-drop.rs
index 31020b77984ba..8e77bd41d5284 100644
--- a/tests/codegen/iter-repeat-n-trivial-drop.rs
+++ b/tests/codegen/iter-repeat-n-trivial-drop.rs
@@ -46,7 +46,7 @@ pub fn iter_repeat_n_next(it: &mut std::iter::RepeatN<NotCopy>) -> Option<NotCop
#[no_mangle]
// CHECK-LABEL: @vec_extend_via_iter_repeat_n
pub fn vec_extend_via_iter_repeat_n() -> Vec<u8> {
- // CHECK: %[[ADDR:.+]] = tail call {{(noalias )?}}noundef dereferenceable_or_null(1234) ptr @__rust_alloc(i64 noundef 1234, i64 noundef 1)
+ // CHECK: %[[ADDR:.+]] = tail call {{(noalias )?}}noundef dereferenceable_or_null(1234) ptr @{{.*}}__rust_alloc(i64 noundef 1234, i64 noundef 1)
// CHECK: tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 1 dereferenceable(1234) %[[ADDR]], i8 42, i64 1234,
let n = 1234_usize;
diff --git a/tests/codegen/vec-calloc.rs b/tests/codegen/vec-calloc.rs
index f88ed7ae8a555..f368913cf3eca 100644
--- a/tests/codegen/vec-calloc.rs
+++ b/tests/codegen/vec-calloc.rs
@@ -177,6 +177,6 @@ pub fn vec_option_i32(n: usize) -> Vec<Option<i32>> {
}
// Ensure that __rust_alloc_zeroed gets the right attributes for LLVM to optimize it away.
-// CHECK: declare noalias noundef ptr @__rust_alloc_zeroed(i64 noundef, i64 allocalign noundef) unnamed_addr [[RUST_ALLOC_ZEROED_ATTRS:#[0-9]+]]
+// CHECK: declare noalias noundef ptr @{{.*}}__rust_alloc_zeroed(i64 noundef, i64 allocalign noundef) unnamed_addr [[RUST_ALLOC_ZEROED_ATTRS:#[0-9]+]]
// CHECK-DAG: attributes [[RUST_ALLOC_ZEROED_ATTRS]] = { {{.*}} allockind("alloc,zeroed,aligned") allocsize(0) uwtable "alloc-family"="__rust_alloc" {{.*}} }
diff --git a/tests/codegen/vec-optimizes-away.rs b/tests/codegen/vec-optimizes-away.rs
index 77a94b0b4294a..7e5b62225172f 100644
--- a/tests/codegen/vec-optimizes-away.rs
+++ b/tests/codegen/vec-optimizes-away.rs
@@ -5,7 +5,7 @@
pub fn sum_me() -> i32 {
// CHECK-LABEL: @sum_me
// CHECK-NEXT: {{^.*:$}}
- // CHECK-NEXT: {{.*}} load volatile i8, ptr @__rust_no_alloc_shim_is_unstable, align 1
+ // CHECK-NEXT: {{.*}} load volatile i8, ptr @{{.*}}__rust_no_alloc_shim_is_unstable, align 1
// CHECK-NEXT: ret i32 6
vec![1, 2, 3].iter().sum::<i32>()
}
From 9c91546a14652f49c948849fe06c9ec072534232 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sun, 30 Jun 2024 20:27:00 +0000
Subject: [PATCH 2/2] Fix miri
---
src/tools/miri/src/lib.rs | 1 +
src/tools/miri/src/shims/foreign_items.rs | 43 ++++++++++++-------
.../pass/function_calls/exported_symbol.rs | 2 +
3 files changed, 31 insertions(+), 15 deletions(-)
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 8da00861f905b..55da2fd6a628a 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -67,6 +67,7 @@ extern crate rustc_index;
extern crate rustc_middle;
extern crate rustc_session;
extern crate rustc_span;
+extern crate rustc_symbol_mangling;
extern crate rustc_target;
// Linking `rustc_driver` pulls in the required object code as the rest of the rustc crates are
// shipped only as rmeta files.
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 9004f7efc8b5e..77ecae74715e6 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -7,6 +7,7 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
use rustc_middle::mir;
use rustc_middle::ty;
use rustc_span::Symbol;
+use rustc_symbol_mangling::mangle_internal_symbol;
use rustc_target::{
abi::{Align, Size},
spec::abi::Abi,
@@ -135,15 +136,29 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
// Find it if it was not cached.
let mut instance_and_crate: Option<(ty::Instance<'_>, CrateNum)> = None;
helpers::iter_exported_symbols(tcx, |cnum, def_id| {
+ if tcx.is_foreign_item(def_id) {
+ // Skip over imports of items
+ return Ok(());
+ }
+
let attrs = tcx.codegen_fn_attrs(def_id);
+ // FIXME use tcx.symbol_name(instance) instead
let symbol_name = if let Some(export_name) = attrs.export_name {
export_name
- } else if attrs.flags.contains(CodegenFnAttrFlags::NO_MANGLE) {
+ } else if attrs.flags.contains(CodegenFnAttrFlags::NO_MANGLE)
+ || attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL)
+ {
tcx.item_name(def_id)
} else {
// Skip over items without an explicitly defined symbol name.
return Ok(());
};
+ let symbol_name =
+ if attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL) {
+ Symbol::intern(&mangle_internal_symbol(tcx, symbol_name.as_str()))
+ } else {
+ symbol_name
+ };
if symbol_name == link_name {
if let Some((original_instance, original_cnum)) = instance_and_crate {
// Make sure we are consistent wrt what is 'first' and 'second'.
@@ -455,7 +470,9 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
}
// Rust allocation
- "__rust_alloc" | "miri_alloc" => {
+ name if name == mangle_internal_symbol(*this.tcx, "__rust_alloc")
+ || name == "miri_alloc" =>
+ {
let default = |this: &mut MiriInterpCx<'tcx>| {
// Only call `check_shim` when `#[global_allocator]` isn't used. When that
// macro is used, we act like no shim exists, so that the exported function can run.
@@ -466,9 +483,8 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
this.check_rustc_alloc_request(size, align)?;
let memory_kind = match link_name.as_str() {
- "__rust_alloc" => MiriMemoryKind::Rust,
"miri_alloc" => MiriMemoryKind::Miri,
- _ => unreachable!(),
+ _ => MiriMemoryKind::Rust,
};
let ptr = this.allocate_ptr(
@@ -481,15 +497,14 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
};
match link_name.as_str() {
- "__rust_alloc" => return this.emulate_allocator(default),
"miri_alloc" => {
default(this)?;
return Ok(EmulateItemResult::NeedsReturn);
}
- _ => unreachable!(),
+ _ => return this.emulate_allocator(default),
}
}
- "__rust_alloc_zeroed" => {
+ name if name == mangle_internal_symbol(*this.tcx, "__rust_alloc_zeroed") => {
return this.emulate_allocator(|this| {
// See the comment for `__rust_alloc` why `check_shim` is only called in the
// default case.
@@ -514,7 +529,9 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
this.write_pointer(ptr, dest)
});
}
- "__rust_dealloc" | "miri_dealloc" => {
+ name if name == mangle_internal_symbol(*this.tcx, "__rust_dealloc")
+ || name == "miri_dealloc" =>
+ {
let default = |this: &mut MiriInterpCx<'tcx>| {
// See the comment for `__rust_alloc` why `check_shim` is only called in the
// default case.
@@ -525,9 +542,8 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
let align = this.read_target_usize(align)?;
let memory_kind = match link_name.as_str() {
- "__rust_dealloc" => MiriMemoryKind::Rust,
"miri_dealloc" => MiriMemoryKind::Miri,
- _ => unreachable!(),
+ _ => MiriMemoryKind::Rust,
};
// No need to check old_size/align; we anyway check that they match the allocation.
@@ -539,17 +555,14 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
};
match link_name.as_str() {
- "__rust_dealloc" => {
- return this.emulate_allocator(default);
- }
"miri_dealloc" => {
default(this)?;
return Ok(EmulateItemResult::NeedsReturn);
}
- _ => unreachable!(),
+ _ => return this.emulate_allocator(default),
}
}
- "__rust_realloc" => {
+ name if name == mangle_internal_symbol(*this.tcx, "__rust_realloc") => {
return this.emulate_allocator(|this| {
// See the comment for `__rust_alloc` why `check_shim` is only called in the
// default case.
diff --git a/src/tools/miri/tests/pass/function_calls/exported_symbol.rs b/src/tools/miri/tests/pass/function_calls/exported_symbol.rs
index 27aee9c883588..d804f3642b1d2 100644
--- a/src/tools/miri/tests/pass/function_calls/exported_symbol.rs
+++ b/src/tools/miri/tests/pass/function_calls/exported_symbol.rs
@@ -40,6 +40,7 @@ fn main() {
extern "Rust" {
fn bar() -> i32;
+ #[rustc_std_internal_symbol]
fn baz() -> i32;
fn qux() -> i32;
}
@@ -63,6 +64,7 @@ fn main() {
extern "C" {
fn bar() -> i32;
+ #[rustc_std_internal_symbol]
fn baz() -> i32;
fn qux() -> i32;
}