Auto merge of #142366 - bjorn3:aliases, r=<try>

rust-bors[bot] · web-flow · commit 338bf419f5f3 · 2025-06-11T13:12:08.000Z
[WIP] Use weak aliases for the allocator shim

try-job: x86_64-msvc-1
try-job: x86_64-msvc-2
diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
@@ -563,6 +563,7 @@ fn codegen_cgu_content(
                 );
                 codegened_functions.push(codegened_function);
             }
+            MonoItem::WeakAlias(_, _) => todo!(),
             MonoItem::Static(def_id) => {
                 let data_id = crate::constant::codegen_static(tcx, module, def_id);
                 if let Some(debug_context) = &mut cx.debug_context {
diff --git a/compiler/rustc_codegen_cranelift/src/driver/mod.rs b/compiler/rustc_codegen_cranelift/src/driver/mod.rs
@@ -49,7 +49,7 @@ fn predefine_mono_items<'tcx>(
                         )
                         .unwrap();
                 }
-                MonoItem::Static(_) | MonoItem::GlobalAsm(_) => {}
+                MonoItem::WeakAlias(_, _) | MonoItem::Static(_) | MonoItem::GlobalAsm(_) => {}
             }
         }
     });
diff --git a/compiler/rustc_codegen_llvm/src/allocator.rs b/compiler/rustc_codegen_llvm/src/allocator.rs
@@ -30,37 +30,6 @@ pub(crate) unsafe fn codegen(
     let i8 = cx.type_i8();
     let i8p = cx.type_ptr();
 
-    if kind == AllocatorKind::Default {
-        for method in ALLOCATOR_METHODS {
-            let mut args = Vec::with_capacity(method.inputs.len());
-            for input in method.inputs.iter() {
-                match input.ty {
-                    AllocatorTy::Layout => {
-                        args.push(usize); // size
-                        args.push(usize); // align
-                    }
-                    AllocatorTy::Ptr => args.push(i8p),
-                    AllocatorTy::Usize => args.push(usize),
-
-                    AllocatorTy::ResultPtr | AllocatorTy::Unit => panic!("invalid allocator arg"),
-                }
-            }
-            let output = match method.output {
-                AllocatorTy::ResultPtr => Some(i8p),
-                AllocatorTy::Unit => None,
-
-                AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {
-                    panic!("invalid allocator output")
-                }
-            };
-
-            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, &cx, &from_name, &to_name, &args, output, false);
-        }
-    }
-
     // rust alloc error handler
     create_wrapper_function(
         tcx,
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
@@ -118,8 +118,11 @@ pub(crate) fn compile_codegen_unit(
             if !cx.used_statics.is_empty() {
                 cx.create_used_variable_impl(c"llvm.used", &cx.used_statics);
             }
-            if !cx.compiler_used_statics.is_empty() {
-                cx.create_used_variable_impl(c"llvm.compiler.used", &cx.compiler_used_statics);
+            if !cx.compiler_used_statics.borrow().is_empty() {
+                cx.create_used_variable_impl(
+                    c"llvm.compiler.used",
+                    &*cx.compiler_used_statics.borrow(),
+                );
             }
 
             // Run replace-all-uses-with for statics that need it. This must
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1,12 +1,12 @@
 use std::borrow::{Borrow, Cow};
+use std::ffi::CString;
 use std::ops::Deref;
 use std::{iter, ptr};
 
 pub(crate) mod autodiff;
 
 use libc::{c_char, c_uint, size_t};
-use rustc_abi as abi;
-use rustc_abi::{Align, Size, WrappingRange};
+use rustc_abi::{self as abi, AddressSpace, Align, Size, WrappingRange};
 use rustc_codegen_ssa::MemFlags;
 use rustc_codegen_ssa::common::{IntPredicate, RealPredicate, SynchronizationScope, TypeKind};
 use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -549,8 +549,8 @@ impl<'ll> CodegenCx<'ll, '_> {
 
     /// Add a global value to a list to be stored in the `llvm.compiler.used` variable,
     /// an array of ptr.
-    pub(crate) fn add_compiler_used_global(&mut self, global: &'ll Value) {
-        self.compiler_used_statics.push(global);
+    pub(crate) fn add_compiler_used_global(&self, global: &'ll Value) {
+        self.compiler_used_statics.borrow_mut().push(global);
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
@@ -121,7 +121,7 @@ pub(crate) struct FullCx<'ll, 'tcx> {
 
     /// Statics that will be placed in the llvm.compiler.used variable
     /// See <https://llvm.org/docs/LangRef.html#the-llvm-compiler-used-global-variable> for details
-    pub compiler_used_statics: Vec<&'ll Value>,
+    pub compiler_used_statics: RefCell<Vec<&'ll Value>>,
 
     /// Mapping of non-scalar types to llvm types.
     pub type_lowering: RefCell<FxHashMap<(Ty<'tcx>, Option<VariantIdx>), &'ll Type>>,
@@ -614,7 +614,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
                 const_globals: Default::default(),
                 statics_to_rauw: RefCell::new(Vec::new()),
                 used_statics: Vec::new(),
-                compiler_used_statics: Vec::new(),
+                compiler_used_statics: RefCell::new(Vec::new()),
                 type_lowering: Default::default(),
                 scalar_lltypes: Default::default(),
                 coverage_cx,
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/unused.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen/unused.rs
@@ -110,7 +110,9 @@ fn prepare_usage_sets<'tcx>(tcx: TyCtxt<'tcx>) -> UsageSets<'tcx> {
         .flat_map(|cgu| cgu.items().keys())
         .filter_map(|item| match item {
             mir::mono::MonoItem::Fn(instance) => Some(instance),
-            mir::mono::MonoItem::Static(_) | mir::mono::MonoItem::GlobalAsm(_) => None,
+            mir::mono::MonoItem::WeakAlias(_, _)
+            | mir::mono::MonoItem::Static(_)
+            | mir::mono::MonoItem::GlobalAsm(_) => None,
         })
         // We only need one arbitrary instance per definition.
         .filter(move |instance| def_ids_seen.insert(instance.def_id()))
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2083,6 +2083,8 @@ unsafe extern "C" {
         ValueLen: size_t,
     );
 
+    pub(crate) fn LLVMRustAddLinkerOptions(M: &Module, Value: *const c_char, ValueLen: size_t);
+
     pub(crate) fn LLVMRustDIBuilderCreateCompileUnit<'a>(
         Builder: &DIBuilder<'a>,
         Lang: c_uint,
@@ -2662,4 +2664,12 @@ unsafe extern "C" {
 
     pub(crate) fn LLVMRustSetNoSanitizeAddress(Global: &Value);
     pub(crate) fn LLVMRustSetNoSanitizeHWAddress(Global: &Value);
+
+    pub(crate) fn LLVMAddAlias2<'ll>(
+        M: &'ll Module,
+        ValueTy: &Type,
+        AddressSpace: c_uint,
+        Aliasee: &Value,
+        Name: *const c_char,
+    ) -> &'ll Value;
 }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
@@ -6,7 +6,7 @@ use std::str::FromStr;
 use std::string::FromUtf8Error;
 
 use libc::c_uint;
-use rustc_abi::{Align, Size, WrappingRange};
+use rustc_abi::{AddressSpace, Align, Size, WrappingRange};
 use rustc_llvm::RustString;
 
 pub(crate) use self::CallConv::*;
@@ -327,6 +327,17 @@ pub(crate) fn get_value_name(value: &Value) -> &[u8] {
     }
 }
 
+/// Safe wrapper for `LLVMAddAlias2`
+pub(crate) fn add_alias<'ll>(
+    module: &'ll Module,
+    ty: &Type,
+    address_space: AddressSpace,
+    aliasee: &Value,
+    name: &CStr,
+) -> &'ll Value {
+    unsafe { LLVMAddAlias2(module, ty, address_space.0, aliasee, name.as_ptr()) }
+}
+
 /// Safe wrapper for `LLVMSetValueName2` from a byte slice
 pub(crate) fn set_value_name(value: &Value, name: &[u8]) {
     unsafe {
@@ -430,6 +441,12 @@ pub(crate) fn add_module_flag_str(
     }
 }
 
+pub(crate) fn add_module_linker_option(module: &Module, value: &str) {
+    unsafe {
+        LLVMRustAddLinkerOptions(module, value.as_c_char_ptr(), value.len());
+    }
+}
+
 pub(crate) fn set_dllimport_storage_class<'ll>(v: &'ll Value) {
     unsafe {
         LLVMSetDLLStorageClass(v, DLLStorageClass::DllImport);
diff --git a/compiler/rustc_codegen_llvm/src/mono_item.rs b/compiler/rustc_codegen_llvm/src/mono_item.rs
@@ -1,3 +1,6 @@
+use std::ffi::CString;
+
+use rustc_abi::AddressSpace;
 use rustc_codegen_ssa::traits::*;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
@@ -6,6 +9,7 @@ use rustc_middle::mir::mono::{Linkage, Visibility};
 use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv, LayoutOf};
 use rustc_middle::ty::{self, Instance, TypeVisitableExt};
 use rustc_session::config::CrateType;
+use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::spec::RelocModel;
 use tracing::debug;
 
@@ -77,8 +81,59 @@ impl<'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
 
         self.assume_dso_local(lldecl, false);
 
+        let symbol_name = self.tcx.symbol_name(instance);
+        if symbol_name.name.contains("__rdl_alloc") {
+            self.weak_alias(
+                lldecl,
+                symbol_name.name,
+                &mangle_internal_symbol(self.tcx, "__rust_alloc"),
+            );
+        }
+        if symbol_name.name.contains("__rdl_dealloc") {
+            self.weak_alias(
+                lldecl,
+                symbol_name.name,
+                &mangle_internal_symbol(self.tcx, "__rust_dealloc"),
+            );
+        }
+        if symbol_name.name.contains("__rdl_realloc") {
+            self.weak_alias(
+                lldecl,
+                symbol_name.name,
+                &mangle_internal_symbol(self.tcx, "__rust_realloc"),
+            );
+        }
+        if symbol_name.name.contains("__rdl_alloc_zeroed") {
+            self.weak_alias(
+                lldecl,
+                symbol_name.name,
+                &mangle_internal_symbol(self.tcx, "__rust_alloc_zeroed"),
+            );
+        }
+
         self.instances.borrow_mut().insert(instance, lldecl);
     }
+
+    fn weak_alias(&self, aliasee: Self::Function, aliasee_name: &str, name: &str) {
+        if self.tcx.sess.target.is_like_msvc {
+            llvm::add_module_linker_option(
+                self.llmod,
+                &format!("/alternatename:{name}={aliasee_name}"),
+            );
+        } else {
+            let ty = self.get_type_of_global(aliasee);
+            let alias = llvm::add_alias(
+                self.llmod,
+                ty,
+                AddressSpace::DATA,
+                aliasee,
+                &CString::new(name).unwrap(),
+            );
+
+            llvm::set_linkage(alias, llvm::Linkage::WeakAnyLinkage);
+            self.add_compiler_used_global(alias);
+        }
+    }
 }
 
 impl CodegenCx<'_, '_> {
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -7,6 +7,7 @@ use rustc_middle::mir::{Body, Local, UnwindTerminateReason, traversal};
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, HasTypingEnv, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeFoldable, TypeVisitableExt};
 use rustc_middle::{bug, mir, span_bug};
+use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::callconv::{FnAbi, PassMode};
 use tracing::{debug, instrument};
 
diff --git a/compiler/rustc_codegen_ssa/src/mono_item.rs b/compiler/rustc_codegen_ssa/src/mono_item.rs
@@ -40,6 +40,9 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
             MonoItem::GlobalAsm(item_id) => {
                 base::codegen_global_asm(cx, item_id);
             }
+            MonoItem::WeakAlias(def_id, target) => {
+                todo!()
+            }
             MonoItem::Fn(instance) => {
                 if cx
                     .tcx()
@@ -83,6 +86,7 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
                     cx.predefine_fn(instance, linkage, visibility, symbol_name);
                 };
             }
+            MonoItem::WeakAlias(..) => {}
             MonoItem::GlobalAsm(..) => {}
         }
 
@@ -95,6 +99,7 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
                 format!("Fn({:?}, {})", instance.def, instance.args.as_ptr().addr())
             }
             MonoItem::Static(id) => format!("Static({id:?})"),
+            MonoItem::WeakAlias(def_id, target) => format!("WeakAlias({def_id:?}, {target:?})"),
             MonoItem::GlobalAsm(id) => format!("GlobalAsm({id:?})"),
         }
     }
diff --git a/compiler/rustc_codegen_ssa/src/traits/declare.rs b/compiler/rustc_codegen_ssa/src/traits/declare.rs
@@ -2,7 +2,9 @@ use rustc_hir::def_id::DefId;
 use rustc_middle::mir::mono::{Linkage, Visibility};
 use rustc_middle::ty::Instance;
 
-pub trait PreDefineCodegenMethods<'tcx> {
+use crate::traits::BackendTypes;
+
+pub trait PreDefineCodegenMethods<'tcx>: BackendTypes {
     fn predefine_static(
         &mut self,
         def_id: DefId,
@@ -17,4 +19,6 @@ pub trait PreDefineCodegenMethods<'tcx> {
         visibility: Visibility,
         symbol_name: &str,
     );
+
+    fn weak_alias(&self, aliasee: Self::Function, aliasee_name: &str, name: &str);
 }
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -906,6 +906,15 @@ extern "C" void LLVMRustAddModuleFlagString(
       MDString::get(unwrap(M)->getContext(), StringRef(Value, ValueLen)));
 }
 
+extern "C" void LLVMRustAddLinkerOptions(LLVMModuleRef M, const char *Value,
+                                         size_t ValueLen) {
+
+  auto *Opts = unwrap(M)->getOrInsertNamedMetadata("llvm.linker.options");
+  Opts->addOperand(MDNode::get(
+      unwrap(M)->getContext(),
+      {MDString::get(unwrap(M)->getContext(), StringRef(Value, ValueLen))}));
+}
+
 extern "C" LLVMValueRef LLVMRustGetLastInstruction(LLVMBasicBlockRef BB) {
   auto Point = unwrap(BB)->rbegin();
   if (Point != unwrap(BB)->rend())
diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs

Original file line number	Diff line number	Diff line change
`@@ -563,6 +563,7 @@ fn codegen_cgu_content(`
`563`	`563`	`);`
`564`	`564`	`codegened_functions.push(codegened_function);`
`565`	`565`	`}`
	`566`	`+ MonoItem::WeakAlias(_, _) => todo!(),`
`566`	`567`	`MonoItem::Static(def_id) => {`
`567`	`568`	`let data_id = crate::constant::codegen_static(tcx, module, def_id);`
`568`	`569`	`if let Some(debug_context) = &mut cx.debug_context {`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ fn predefine_mono_items<'tcx>(`
`49`	`49`	`)`
`50`	`50`	`.unwrap();`
`51`	`51`	`}`
`52`		`- MonoItem::Static(_) \| MonoItem::GlobalAsm(_) => {}`
	`52`	`+ MonoItem::WeakAlias(_, _) \| MonoItem::Static(_) \| MonoItem::GlobalAsm(_) => {}`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`});`
Original file line number	Diff line number	Diff line change
`@@ -118,8 +118,11 @@ pub(crate) fn compile_codegen_unit(`
`118`	`118`	`if !cx.used_statics.is_empty() {`
`119`	`119`	`cx.create_used_variable_impl(c"llvm.used", &cx.used_statics);`
`120`	`120`	`}`
`121`		`- if !cx.compiler_used_statics.is_empty() {`
`122`		`- cx.create_used_variable_impl(c"llvm.compiler.used", &cx.compiler_used_statics);`
	`121`	`+ if !cx.compiler_used_statics.borrow().is_empty() {`
	`122`	`+ cx.create_used_variable_impl(`
	`123`	`+ c"llvm.compiler.used",`
	`124`	`+ &*cx.compiler_used_statics.borrow(),`
	`125`	`+ );`
`123`	`126`	`}`
`124`	`127`
`125`	`128`	`// Run replace-all-uses-with for statics that need it. This must`
Original file line number	Diff line number	Diff line change
`@@ -549,8 +549,8 @@ impl<'ll> CodegenCx<'ll, '_> {`
`549`	`549`
`550`	`550`	/// Add a global value to a list to be stored in the `llvm.compiler.used` variable,
`551`	`551`	`/// an array of ptr.`
`552`		`- pub(crate) fn add_compiler_used_global(&mut self, global: &'ll Value) {`
`553`		`- self.compiler_used_statics.push(global);`
	`552`	`+ pub(crate) fn add_compiler_used_global(&self, global: &'ll Value) {`
	`553`	`+ self.compiler_used_statics.borrow_mut().push(global);`
`554`	`554`	`}`
`555`	`555`	`}`
`556`	`556`