Use weak linkage for the alloc error handler too

Author: bjorn3

compiler/rustc_codegen_cranelift/src/allocator.rs

@@ -2,9 +2,7 @@
 // Adapted from rustc
 
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
-use rustc_ast::expand::allocator::{
-    ALLOC_ERROR_HANDLER, ALLOC_ERROR_HANDLER_DEFAULT, AllocatorKind, NO_ALLOC_SHIM_IS_UNSTABLE,
-};
+use rustc_ast::expand::allocator::NO_ALLOC_SHIM_IS_UNSTABLE;
 use rustc_codegen_ssa::base::needs_allocator_shim;
 use rustc_session::config::OomStrategy;
 use rustc_symbol_mangling::mangle_internal_symbol;
@@ -14,48 +12,15 @@ use crate::prelude::*;
 /// Returns whether an allocator shim was created
 pub(crate) fn codegen(tcx: TyCtxt<'_>, module: &mut dyn Module) -> bool {
     if needs_allocator_shim(tcx) {
-        codegen_inner(
-            tcx,
-            module,
-            tcx.alloc_error_handler_kind(()).unwrap(),
-            tcx.sess.opts.unstable_opts.oom,
-        );
+        codegen_inner(tcx, module, tcx.sess.opts.unstable_opts.oom);
         true
     } else {
         false
     }
 }
 
-fn codegen_inner(
-    tcx: TyCtxt<'_>,
-    module: &mut dyn Module,
-    alloc_error_handler_kind: AllocatorKind,
-    oom_strategy: OomStrategy,
-) {
-    let usize_ty = module.target_config().pointer_type();
-
-    if alloc_error_handler_kind == AllocatorKind::Default {
-        let sig = Signature {
-            call_conv: module.target_config().default_call_conv,
-            params: vec![AbiParam::new(usize_ty), AbiParam::new(usize_ty)],
-            returns: vec![],
-        };
-        crate::common::create_wrapper_function(
-            module,
-            sig,
-            &mangle_internal_symbol(tcx, ALLOC_ERROR_HANDLER),
-            &mangle_internal_symbol(tcx, ALLOC_ERROR_HANDLER_DEFAULT),
-        );
-    }
-
-    let data_id = module
-        .declare_data(
-            &mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
-            Linkage::Export,
-            false,
-            false,
-        )
-        .unwrap();
+fn codegen_inner(tcx: TyCtxt<'_>, module: &mut dyn Module, oom_strategy: OomStrategy) {
+    let data_id = module.declare_data(OomStrategy::SYMBOL, Linkage::Export, false, false).unwrap();
     let mut data = DataDescription::new();
     data.set_align(1);
     let val = oom_strategy.should_panic();

compiler/rustc_codegen_gcc/src/allocator.rs

@@ -1,10 +1,7 @@
 use gccjit::{Context, FunctionType, GlobalKind, ToRValue, Type};
 #[cfg(feature = "master")]
 use gccjit::{FnAttribute, VarAttribute};
-use rustc_ast::expand::allocator::{
-    ALLOC_ERROR_HANDLER, ALLOC_ERROR_HANDLER_DEFAULT, AllocatorKind, NO_ALLOC_SHIM_IS_UNSTABLE,
-};
-use rustc_middle::bug;
+use rustc_ast::expand::allocator::NO_ALLOC_SHIM_IS_UNSTABLE;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::OomStrategy;
 use rustc_symbol_mangling::mangle_internal_symbol;
@@ -13,33 +10,10 @@ use crate::GccContext;
 #[cfg(feature = "master")]
 use crate::base::symbol_visibility_to_gcc;
 
-pub(crate) unsafe fn codegen(
-    tcx: TyCtxt<'_>,
-    mods: &mut GccContext,
-    _module_name: &str,
-    alloc_error_handler_kind: AllocatorKind,
-) {
+pub(crate) unsafe fn codegen(tcx: TyCtxt<'_>, mods: &mut GccContext, _module_name: &str) {
     let context = &mods.context;
-    let usize = match tcx.sess.target.pointer_width {
-        16 => context.new_type::<u16>(),
-        32 => context.new_type::<u32>(),
-        64 => context.new_type::<u64>(),
-        tws => bug!("Unsupported target word size for int: {}", tws),
-    };
     let i8 = context.new_type::<i8>();
 
-    if alloc_error_handler_kind == AllocatorKind::Default {
-        // FIXME(bjorn3): Add noreturn attribute
-        create_wrapper_function(
-            tcx,
-            context,
-            &mangle_internal_symbol(tcx, ALLOC_ERROR_HANDLER),
-            Some(&mangle_internal_symbol(tcx, ALLOC_ERROR_HANDLER_DEFAULT)),
-            &[usize, usize],
-            None,
-        );
-    }
-
     let name = mangle_internal_symbol(tcx, OomStrategy::SYMBOL);
     let global = context.new_global(None, GlobalKind::Exported, i8, name);
     #[cfg(feature = "master")]

compiler/rustc_codegen_gcc/src/lib.rs

@@ -95,7 +95,6 @@ use back::lto::{ThinBuffer, ThinData};
 use gccjit::{CType, Context, OptimizationLevel};
 #[cfg(feature = "master")]
 use gccjit::{TargetInfo, Version};
-use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
 use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
 use rustc_codegen_ssa::back::write::{
@@ -277,12 +276,7 @@ fn new_context<'gcc, 'tcx>(tcx: TyCtxt<'tcx>) -> Context<'gcc> {
 }
 
 impl ExtraBackendMethods for GccCodegenBackend {
-    fn codegen_allocator(
-        &self,
-        tcx: TyCtxt<'_>,
-        module_name: &str,
-        alloc_error_handler_kind: AllocatorKind,
-    ) -> Self::Module {
+    fn codegen_allocator(&self, tcx: TyCtxt<'_>, module_name: &str) -> Self::Module {
         let mut mods = GccContext {
             context: Arc::new(SyncContext::new(new_context(tcx))),
             relocation_model: tcx.sess.relocation_model(),
@@ -291,7 +285,7 @@ impl ExtraBackendMethods for GccCodegenBackend {
         };
 
         unsafe {
-            allocator::codegen(tcx, &mut mods, module_name, alloc_error_handler_kind);
+            allocator::codegen(tcx, &mut mods, module_name);
         }
         mods
     }

compiler/rustc_codegen_llvm/src/allocator.rs

@@ -1,9 +1,6 @@
 use libc::c_uint;
-use rustc_ast::expand::allocator::{
-    ALLOC_ERROR_HANDLER, ALLOC_ERROR_HANDLER_DEFAULT, AllocatorKind, NO_ALLOC_SHIM_IS_UNSTABLE,
-};
+use rustc_ast::expand::allocator::NO_ALLOC_SHIM_IS_UNSTABLE;
 use rustc_codegen_ssa::traits::BaseTypeCodegenMethods as _;
-use rustc_middle::bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{DebugInfo, OomStrategy};
 use rustc_symbol_mangling::mangle_internal_symbol;
@@ -13,33 +10,9 @@ use crate::declare::declare_simple_fn;
 use crate::llvm::{self, False, True, Type};
 use crate::{SimpleCx, attributes, debuginfo};
 
-pub(crate) unsafe fn codegen(
-    tcx: TyCtxt<'_>,
-    cx: SimpleCx<'_>,
-    module_name: &str,
-    alloc_error_handler_kind: AllocatorKind,
-) {
-    let usize = match tcx.sess.target.pointer_width {
-        16 => cx.type_i16(),
-        32 => cx.type_i32(),
-        64 => cx.type_i64(),
-        tws => bug!("Unsupported target word size for int: {}", tws),
-    };
+pub(crate) unsafe fn codegen(tcx: TyCtxt<'_>, cx: SimpleCx<'_>, module_name: &str) {
     let i8 = cx.type_i8();
 
-    if alloc_error_handler_kind == AllocatorKind::Default {
-        // rust alloc error handler
-        create_wrapper_function(
-            tcx,
-            &cx,
-            &mangle_internal_symbol(tcx, ALLOC_ERROR_HANDLER),
-            Some(&mangle_internal_symbol(tcx, ALLOC_ERROR_HANDLER_DEFAULT)),
-            &[usize, usize], // size, align
-            None,
-            true,
-        );
-    }
-
     unsafe {
         // __rust_alloc_error_handler_should_panic
         let name = mangle_internal_symbol(tcx, OomStrategy::SYMBOL);

compiler/rustc_codegen_llvm/src/lib.rs

@@ -28,7 +28,6 @@ use back::write::{create_informational_target_machine, create_target_machine};
 use context::SimpleCx;
 use errors::{AutoDiffWithoutLTO, ParseTargetMachineConfig};
 use llvm_util::target_config;
-use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
 use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
 use rustc_codegen_ssa::back::write::{
@@ -104,17 +103,12 @@ impl Drop for TimeTraceProfiler {
 }
 
 impl ExtraBackendMethods for LlvmCodegenBackend {
-    fn codegen_allocator<'tcx>(
-        &self,
-        tcx: TyCtxt<'tcx>,
-        module_name: &str,
-        alloc_error_handler_kind: AllocatorKind,
-    ) -> ModuleLlvm {
+    fn codegen_allocator<'tcx>(&self, tcx: TyCtxt<'tcx>, module_name: &str) -> ModuleLlvm {
         let module_llvm = ModuleLlvm::new_metadata(tcx, module_name);
         let cx =
             SimpleCx::new(module_llvm.llmod(), &module_llvm.llcx, tcx.data_layout.pointer_size);
         unsafe {
-            allocator::codegen(tcx, cx, module_name, alloc_error_handler_kind);
+            allocator::codegen(tcx, cx, module_name);
         }
         module_llvm
     }

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -1,7 +1,7 @@
 use std::collections::hash_map::Entry::*;
 
 use rustc_abi::{CanonAbi, X86Call};
-use rustc_ast::expand::allocator::{ALLOC_ERROR_HANDLER, NO_ALLOC_SHIM_IS_UNSTABLE};
+use rustc_ast::expand::allocator::NO_ALLOC_SHIM_IS_UNSTABLE;
 use rustc_data_structures::unord::UnordMap;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LOCAL_CRATE, LocalDefId};
@@ -214,7 +214,6 @@ fn exported_symbols_provider_local<'tcx>(
     // Mark allocator shim symbols as exported only if they were generated.
     if needs_allocator_shim(tcx) {
         for symbol_name in [
-            mangle_internal_symbol(tcx, ALLOC_ERROR_HANDLER),
             mangle_internal_symbol(tcx, OomStrategy::SYMBOL),
             mangle_internal_symbol(tcx, NO_ALLOC_SHIM_IS_UNSTABLE),
         ] {

compiler/rustc_codegen_ssa/src/base.rs

@@ -708,15 +708,8 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
     if needs_allocator_shim(tcx) {
         let llmod_id =
             cgu_name_builder.build_cgu_name(LOCAL_CRATE, &["crate"], Some("allocator")).to_string();
-        let module_llvm = tcx.sess.time("write_allocator_module", || {
-            backend.codegen_allocator(
-                tcx,
-                &llmod_id,
-                // If allocator_kind is Some then alloc_error_handler_kind must
-                // also be Some.
-                tcx.alloc_error_handler_kind(()).unwrap(),
-            )
-        });
+        let module_llvm =
+            tcx.sess.time("write_allocator_module", || backend.codegen_allocator(tcx, &llmod_id));
 
         ongoing_codegen.wait_for_signal_to_codegen_item();
         ongoing_codegen.check_for_errors(tcx.sess);

compiler/rustc_codegen_ssa/src/traits/backend.rs

@@ -1,7 +1,6 @@
 use std::any::Any;
 use std::hash::Hash;
 
-use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_metadata::EncodedMetadata;
@@ -103,12 +102,7 @@ pub trait CodegenBackend {
 pub trait ExtraBackendMethods:
     CodegenBackend + WriteBackendMethods + Sized + Send + Sync + DynSend + DynSync
 {
-    fn codegen_allocator<'tcx>(
-        &self,
-        tcx: TyCtxt<'tcx>,
-        module_name: &str,
-        alloc_error_handler_kind: AllocatorKind,
-    ) -> Self::Module;
+    fn codegen_allocator<'tcx>(&self, tcx: TyCtxt<'tcx>, module_name: &str) -> Self::Module;
 
     /// This generates the codegen unit and returns it along with
     /// a `u64` giving an estimate of the unit's processing cost.

compiler/rustc_metadata/src/creader.rs

@@ -7,7 +7,7 @@ use std::str::FromStr;
 use std::time::Duration;
 use std::{cmp, env, iter};
 
-use rustc_ast::expand::allocator::{ALLOC_ERROR_HANDLER, AllocatorKind, global_fn_name};
+use rustc_ast::expand::allocator::{AllocatorKind, global_fn_name};
 use rustc_ast::{self as ast, *};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::owned_slice::OwnedSlice;
@@ -25,8 +25,8 @@ use rustc_middle::ty::data_structures::IndexSet;
 use rustc_middle::ty::{TyCtxt, TyCtxtFeed};
 use rustc_proc_macro::bridge::client::ProcMacro;
 use rustc_session::config::{
-    self, CrateType, ExtendedTargetModifierInfo, ExternLocation, OptionsTargetModifiers,
-    TargetModifier,
+    self, CrateType, ExtendedTargetModifierInfo, ExternLocation, OomStrategy,
+    OptionsTargetModifiers, TargetModifier,
 };
 use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate, ExternCrateSource};
 use rustc_session::lint::{self, BuiltinLintDiag};
@@ -322,10 +322,6 @@ impl CStore {
         self.allocator_kind
     }
 
-    pub(crate) fn alloc_error_handler_kind(&self) -> Option<AllocatorKind> {
-        self.alloc_error_handler_kind
-    }
-
     pub(crate) fn has_global_allocator(&self) -> bool {
         self.has_global_allocator
     }
@@ -1068,7 +1064,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 spans => !spans.is_empty(),
             };
         self.cstore.has_alloc_error_handler =
-            match &*fn_spans(krate, Symbol::intern(ALLOC_ERROR_HANDLER)) {
+            match &*fn_spans(krate, Symbol::intern(OomStrategy::SYMBOL)) {
                 [span1, span2, ..] => {
                     self.dcx().emit_err(errors::NoMultipleAllocErrorHandler {
                         span2: *span2,

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -432,7 +432,6 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
     provide_cstore_hooks(providers);
     providers.queries = rustc_middle::query::Providers {
         allocator_kind: |tcx, ()| CStore::from_tcx(tcx).allocator_kind(),
-        alloc_error_handler_kind: |tcx, ()| CStore::from_tcx(tcx).alloc_error_handler_kind(),
         is_private_dep: |_tcx, LocalCrate| false,
         native_library: |tcx, id| {
             tcx.native_libraries(id.krate)

compiler/rustc_middle/src/query/mod.rs

@@ -2257,10 +2257,6 @@ rustc_queries! {
         eval_always
         desc { "getting the allocator kind for the current crate" }
     }
-    query alloc_error_handler_kind(_: ()) -> Option<AllocatorKind> {
-        eval_always
-        desc { "alloc error handler kind for the current crate" }
-    }
 
     query upvars_mentioned(def_id: DefId) -> Option<&'tcx FxIndexMap<hir::HirId, hir::Upvar>> {
         desc { |tcx| "collecting upvars mentioned in `{}`", tcx.def_path_str(def_id) }

library/alloc/src/alloc.rs

@@ -359,8 +359,8 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
 #[cfg(not(no_global_oom_handling))]
 unsafe extern "Rust" {
     // This is the magic symbol to call the global alloc error handler. rustc generates
-    // it to call `__rg_oom` if there is a `#[alloc_error_handler]`, or to call the
-    // default implementations below (`__rdl_oom`) otherwise.
+    // it if there is a `#[alloc_error_handler]`, or to the weak implementations below
+    // is called otherwise.
     #[rustc_std_internal_symbol]
     fn __rust_alloc_error_handler(size: usize, align: usize) -> !;
 }
@@ -421,10 +421,9 @@ pub const fn handle_alloc_error(layout: Layout) -> ! {
 #[allow(unused_attributes)]
 #[unstable(feature = "alloc_internals", issue = "none")]
 pub mod __alloc_error_handler {
-    // called via generated `__rust_alloc_error_handler` if there is no
-    // `#[alloc_error_handler]`.
     #[rustc_std_internal_symbol]
-    pub unsafe fn __rdl_oom(size: usize, _align: usize) -> ! {
+    #[linkage = "weak"]
+    pub unsafe extern "Rust" fn __rust_alloc_error_handler(size: usize, _align: usize) -> ! {
         unsafe extern "Rust" {
             // This symbol is emitted by rustc next to __rust_alloc_error_handler.
             // Its value depends on the -Zoom={panic,abort} compiler option.

library/alloc/src/lib.rs

@@ -128,6 +128,7 @@
 #![feature(iter_next_chunk)]
 #![feature(layout_for_ptr)]
 #![feature(legacy_receiver_trait)]
+#![feature(linkage)]
 #![feature(local_waker)]
 #![feature(maybe_uninit_slice)]
 #![feature(maybe_uninit_uninit_array_transpose)]

library/std/src/alloc.rs

@@ -358,9 +358,10 @@ fn default_alloc_error_hook(layout: Layout) {
         // This is the default path taken on OOM, and the only path taken on stable with std.
         // Crucially, it does *not* call any user-defined code, and therefore users do not have to
         // worry about allocation failure causing reentrancy issues. That makes it different from
-        // the default `__rdl_oom` defined in alloc (i.e., the default alloc error handler that is
-        // called when there is no `#[alloc_error_handler]`), which triggers a regular panic and
-        // thus can invoke a user-defined panic hook, executing arbitrary user-defined code.
+        // the default `__rust_alloc_error_handler` defined in alloc (i.e., the default alloc error
+        // handler that is called when there is no `#[alloc_error_handler]`), which triggers a
+        // regular panic and thus can invoke a user-defined panic hook, executing arbitrary
+        // user-defined code.
         rtprintpanic!("memory allocation of {} bytes failed\n", layout.size());
     }
 }