[WIP] Weak aliases for the global allocator on ELF

bjorn3 · bjorn3 · commit df06e73babeb · 2025-06-16T08:49:12.000Z
diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
@@ -557,6 +557,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>>,
@@ -615,7 +615,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
@@ -2671,11 +2671,11 @@ unsafe extern "C" {
     pub(crate) fn LLVMRustSetNoSanitizeAddress(Global: &Value);
     pub(crate) fn LLVMRustSetNoSanitizeHWAddress(Global: &Value);
 
-    pub(crate) fn LLVMAddAlias2(
-        M: &Module,
+    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
@@ -351,17 +351,14 @@ impl Intrinsic {
 }
 
 /// Safe wrapper for `LLVMAddAlias2`
-pub(crate) fn add_alias(
-    module: &Module,
+pub(crate) fn add_alias<'ll>(
+    module: &'ll Module,
     ty: &Type,
     address_space: AddressSpace,
     aliasee: &Value,
-    name: &[u8],
-) {
-    unsafe {
-        let data = name.as_c_char_ptr();
-        LLVMAddAlias2(value, data, address_space, aliasee, name.len());
-    }
+    name: &CStr,
+) -> &'ll Value {
+    unsafe { LLVMAddAlias2(module, ty, address_space.0, aliasee, name.as_ptr()) }
 }
 
 /// Safe wrapper for `LLVMSetValueName2` from a byte slice
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,36 @@ 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, &mangle_internal_symbol(self.tcx, "__rust_alloc"));
+        }
+        if symbol_name.name.contains("__rdl_dealloc") {
+            self.weak_alias(lldecl, &mangle_internal_symbol(self.tcx, "__rust_dealloc"));
+        }
+        if symbol_name.name.contains("__rdl_realloc") {
+            self.weak_alias(lldecl, &mangle_internal_symbol(self.tcx, "__rust_realloc"));
+        }
+        if symbol_name.name.contains("__rdl_alloc_zeroed") {
+            self.weak_alias(lldecl, &mangle_internal_symbol(self.tcx, "__rust_alloc_zeroed"));
+        }
+
         self.instances.borrow_mut().insert(instance, lldecl);
     }
+
+    fn weak_alias(&self, aliasee: Self::Function, name: &str) {
+        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, name: &str);
 }
diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
@@ -53,6 +53,7 @@ pub enum InstantiationMode {
 pub enum MonoItem<'tcx> {
     Fn(Instance<'tcx>),
     Static(DefId),
+    WeakAlias(DefId, Instance<'tcx>),
     GlobalAsm(ItemId),
 }
 
@@ -94,7 +95,7 @@ impl<'tcx> MonoItem<'tcx> {
     pub fn is_user_defined(&self) -> bool {
         match *self {
             MonoItem::Fn(instance) => matches!(instance.def, InstanceKind::Item(..)),
-            MonoItem::Static(..) | MonoItem::GlobalAsm(..) => true,
+            MonoItem::WeakAlias(_, _) | MonoItem::Static(..) | MonoItem::GlobalAsm(..) => true,
         }
     }
 
@@ -105,21 +106,23 @@ impl<'tcx> MonoItem<'tcx> {
             MonoItem::Fn(instance) => tcx.size_estimate(instance),
             // Conservatively estimate the size of a static declaration or
             // assembly item to be 1.
-            MonoItem::Static(_) | MonoItem::GlobalAsm(_) => 1,
+            MonoItem::WeakAlias(_, _) | MonoItem::Static(_) | MonoItem::GlobalAsm(_) => 1,
         }
     }
 
     pub fn is_generic_fn(&self) -> bool {
         match self {
             MonoItem::Fn(instance) => instance.args.non_erasable_generics().next().is_some(),
-            MonoItem::Static(..) | MonoItem::GlobalAsm(..) => false,
+            MonoItem::WeakAlias(_, _) | MonoItem::Static(..) | MonoItem::GlobalAsm(..) => false,
         }
     }
 
     pub fn symbol_name(&self, tcx: TyCtxt<'tcx>) -> SymbolName<'tcx> {
         match *self {
             MonoItem::Fn(instance) => tcx.symbol_name(instance),
-            MonoItem::Static(def_id) => tcx.symbol_name(Instance::mono(tcx, def_id)),
+            MonoItem::Static(def_id) | MonoItem::WeakAlias(def_id, _) => {
+                tcx.symbol_name(Instance::mono(tcx, def_id))
+            }
             MonoItem::GlobalAsm(item_id) => {
                 SymbolName::new(tcx, &format!("global_asm_{:?}", item_id.owner_id))
             }
@@ -137,7 +140,7 @@ impl<'tcx> MonoItem<'tcx> {
         // Statics and global_asm! must be instantiated exactly once.
         let instance = match *self {
             MonoItem::Fn(instance) => instance,
-            MonoItem::Static(..) | MonoItem::GlobalAsm(..) => {
+            MonoItem::WeakAlias(_, _) | MonoItem::Static(..) | MonoItem::GlobalAsm(..) => {
                 return InstantiationMode::GloballyShared { may_conflict: false };
             }
         };
@@ -236,7 +239,7 @@ impl<'tcx> MonoItem<'tcx> {
     pub fn explicit_linkage(&self, tcx: TyCtxt<'tcx>) -> Option<Linkage> {
         let def_id = match *self {
             MonoItem::Fn(ref instance) => instance.def_id(),
-            MonoItem::Static(def_id) => def_id,
+            MonoItem::WeakAlias(def_id, _) | MonoItem::Static(def_id) => def_id,
             MonoItem::GlobalAsm(..) => return None,
         };
 
@@ -273,7 +276,9 @@ impl<'tcx> MonoItem<'tcx> {
         debug!("is_instantiable({:?})", self);
         let (def_id, args) = match *self {
             MonoItem::Fn(ref instance) => (instance.def_id(), instance.args),
-            MonoItem::Static(def_id) => (def_id, GenericArgs::empty()),
+            MonoItem::WeakAlias(def_id, _) | MonoItem::Static(def_id) => {
+                (def_id, GenericArgs::empty())
+            }
             // global asm never has predicates
             MonoItem::GlobalAsm(..) => return true,
         };
@@ -284,7 +289,7 @@ impl<'tcx> MonoItem<'tcx> {
     pub fn local_span(&self, tcx: TyCtxt<'tcx>) -> Option<Span> {
         match *self {
             MonoItem::Fn(Instance { def, .. }) => def.def_id().as_local(),
-            MonoItem::Static(def_id) => def_id.as_local(),
+            MonoItem::WeakAlias(def_id, _) | MonoItem::Static(def_id) => def_id.as_local(),
             MonoItem::GlobalAsm(item_id) => Some(item_id.owner_id.def_id),
         }
         .map(|def_id| tcx.def_span(def_id))
@@ -299,7 +304,7 @@ impl<'tcx> MonoItem<'tcx> {
     pub fn krate(&self) -> CrateNum {
         match self {
             MonoItem::Fn(instance) => instance.def_id().krate,
-            MonoItem::Static(def_id) => def_id.krate,
+            MonoItem::WeakAlias(def_id, _) | MonoItem::Static(def_id) => def_id.krate,
             MonoItem::GlobalAsm(..) => LOCAL_CRATE,
         }
     }
@@ -308,7 +313,7 @@ impl<'tcx> MonoItem<'tcx> {
     pub fn def_id(&self) -> DefId {
         match *self {
             MonoItem::Fn(Instance { def, .. }) => def.def_id(),
-            MonoItem::Static(def_id) => def_id,
+            MonoItem::WeakAlias(def_id, _) | MonoItem::Static(def_id) => def_id,
             MonoItem::GlobalAsm(item_id) => item_id.owner_id.to_def_id(),
         }
     }
@@ -321,6 +326,13 @@ impl<'tcx> fmt::Display for MonoItem<'tcx> {
             MonoItem::Static(def_id) => {
                 write!(f, "static {}", Instance::new_raw(def_id, GenericArgs::empty()))
             }
+            MonoItem::WeakAlias(def_id, target) => {
+                write!(
+                    f,
+                    "weak alias {} => {target}",
+                    Instance::new_raw(def_id, GenericArgs::empty())
+                )
+            }
             MonoItem::GlobalAsm(..) => write!(f, "global_asm"),
         }
     }
@@ -559,7 +571,9 @@ impl<'tcx> CodegenUnit<'tcx> {
                             | InstanceKind::AsyncDropGlueCtorShim(..) => None,
                         }
                     }
-                    MonoItem::Static(def_id) => def_id.as_local().map(Idx::index),
+                    MonoItem::WeakAlias(def_id, _) | MonoItem::Static(def_id) => {
+                        def_id.as_local().map(Idx::index)
+                    }
                     MonoItem::GlobalAsm(item_id) => Some(item_id.owner_id.def_id.index()),
                 },
                 item.symbol_name(tcx),
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
`@@ -557,6 +557,7 @@ fn codegen_cgu_content(`
`557`	`557`	`);`
`558`	`558`	`codegened_functions.push(codegened_function);`
`559`	`559`	`}`
	`560`	`+ MonoItem::WeakAlias(_, _) => todo!(),`
`560`	`561`	`MonoItem::Static(def_id) => {`
`561`	`562`	`let data_id = crate::constant::codegen_static(tcx, module, def_id);`
`562`	`563`	`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`