rust-lang · Amanieu · Mar 22, 2023 · Mar 22, 2023 · Apr 21, 2023 · Jun 6, 2023
diff --git a/compiler/rustc_ast/src/expand/allocator.rs b/compiler/rustc_ast/src/expand/allocator.rs
@@ -14,13 14,6 @@ pub fn default_fn_name(base: Symbol) -> String {
  format!("__rdl_{base}")
 }
 
-pub fn alloc_error_handler_name(alloc_error_handler_kind: AllocatorKind) -> &'static str {
- match alloc_error_handler_kind {
- AllocatorKind::Global => "__rg_oom",
- AllocatorKind::Default => "__rdl_oom",
- }
-}
-
 pub const NO_ALLOC_SHIM_IS_UNSTABLE: &str = "__rust_no_alloc_shim_is_unstable";
 
 pub enum AllocatorTy {

diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
@@ -1,4 1,3 @@
-builtin_macros_alloc_error_must_be_fn = alloc_error_handler must be a function
 builtin_macros_alloc_must_statics = allocators must be statics
 
 builtin_macros_asm_clobber_abi = clobber_abi

diff --git a/compiler/rustc_builtin_macros/src/alloc_error_handler.rs b/compiler/rustc_builtin_macros/src/alloc_error_handler.rs
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
@@ -20,13 20,6 @@ pub(crate) struct OneCfgPattern {
  pub(crate) span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(builtin_macros_alloc_error_must_be_fn)]
-pub(crate) struct AllocErrorMustBeFn {
- #[primary_span]
- pub(crate) span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(builtin_macros_assert_requires_boolean)]
 pub(crate) struct AssertRequiresBoolean {

diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs
@@ -26,7 26,6 @@ use rustc_expand::proc_macro::BangProcMacro;
 use rustc_fluent_macro::fluent_messages;
 use rustc_span::symbol::sym;
 
-mod alloc_error_handler;
 mod assert;
 mod cfg;
 mod cfg_accessible;
@@ -101,7 100,6 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
  }
 
  register_attr! {
- alloc_error_handler: alloc_error_handler::expand,
  bench: test::expand_bench,
  cfg_accessible: cfg_accessible::Expander,
  cfg_eval: cfg_eval::expand,

diff --git a/compiler/rustc_codegen_cranelift/example/alloc_example.rs b/compiler/rustc_codegen_cranelift/example/alloc_example.rs
@@ -1,4 1,4 @@
-#![feature(start, core_intrinsics, alloc_error_handler, lang_items)]
 #![feature(start, core_intrinsics, lang_items)]
 #![no_std]
 
 extern crate alloc;
@@ -22,11 22,6 @@ fn panic_handler(_: &core::panic::PanicInfo<'_>) -> ! {
  core::intrinsics::abort();
 }
 
-#[alloc_error_handler]
-fn alloc_error_handler(_: alloc::alloc::Layout) -> ! {
- core::intrinsics::abort();
-}
-
 #[lang = "eh_personality"]
 fn eh_personality() -> ! {
  loop {}

diff --git a/compiler/rustc_codegen_cranelift/src/allocator.rs b/compiler/rustc_codegen_cranelift/src/allocator.rs
@@ -4,8 4,8 @@
 use crate::prelude::*;
 
 use rustc_ast::expand::allocator::{
- alloc_error_handler_name, default_fn_name, global_fn_name, AllocatorKind, AllocatorTy,
- ALLOCATOR_METHODS, NO_ALLOC_SHIM_IS_UNSTABLE,
  default_fn_name, global_fn_name, AllocatorKind, AllocatorTy, ALLOCATOR_METHODS,
  NO_ALLOC_SHIM_IS_UNSTABLE,
 };
 use rustc_codegen_ssa::base::allocator_kind_for_codegen;
 use rustc_session::config::OomStrategy;
@@ -17,21 17,14 @@ pub(crate) fn codegen(
  unwind_context: &mut UnwindContext,
 ) -> bool {
  let Some(kind) = allocator_kind_for_codegen(tcx) else { return false };
- codegen_inner(
- module,
- unwind_context,
- kind,
- tcx.alloc_error_handler_kind(()).unwrap(),
- tcx.sess.opts.unstable_opts.oom,
- );
  codegen_inner(module, unwind_context, kind, tcx.sess.opts.unstable_opts.oom);
  true
 }
 
 fn codegen_inner(
  module: &mut impl Module,
  unwind_context: &mut UnwindContext,
  kind: AllocatorKind,
- alloc_error_handler_kind: AllocatorKind,
  oom_strategy: OomStrategy,
 ) {
  let usize_ty = module.target_config().pointer_type();
@@ -75,19 68,6 @@ fn codegen_inner(
  }
  }
 
- 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,
- unwind_context,
- sig,
- "__rust_alloc_error_handler",
- &alloc_error_handler_name(alloc_error_handler_kind),
- );
-
  let data_id = module.declare_data(OomStrategy::SYMBOL, Linkage::Export, false, false).unwrap();
  let mut data = DataDescription::new();
  data.set_align(1);

diff --git a/compiler/rustc_codegen_gcc/example/alloc_example.rs b/compiler/rustc_codegen_gcc/example/alloc_example.rs
@@ -1,4 1,4 @@
-#![feature(start, core_intrinsics, alloc_error_handler, lang_items)]
 #![feature(start, core_intrinsics, lang_items)]
 #![no_std]
 
 extern crate alloc;
@@ -21,11 21,6 @@ fn panic_handler(_: &core::panic::PanicInfo) -> ! {
  core::intrinsics::abort();
 }
 
-#[alloc_error_handler]
-fn alloc_error_handler(_: alloc::alloc::Layout) -> ! {
- core::intrinsics::abort();
-}
-
 #[lang = "eh_personality"]
 fn eh_personality() -> ! {
  loop {}

diff --git a/compiler/rustc_codegen_gcc/src/allocator.rs b/compiler/rustc_codegen_gcc/src/allocator.rs
@@ -1,25 1,29 @@
-#[cfg(feature="master")]
 #[cfg(feature = "master")]
 use gccjit::FnAttribute;
 use gccjit::{FunctionType, GlobalKind, ToRValue};
 use rustc_ast::expand::allocator::{
- alloc_error_handler_name, default_fn_name, global_fn_name, AllocatorKind, AllocatorTy,
- ALLOCATOR_METHODS, NO_ALLOC_SHIM_IS_UNSTABLE,
  default_fn_name, global_fn_name, AllocatorKind, AllocatorTy, ALLOCATOR_METHODS,
  NO_ALLOC_SHIM_IS_UNSTABLE,
 };
 use rustc_middle::bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::OomStrategy;
 
 use crate::GccContext;
 
-pub(crate) unsafe fn codegen(tcx: TyCtxt<'_>, mods: &mut GccContext, _module_name: &str, kind: AllocatorKind, alloc_error_handler_kind: AllocatorKind) {
 pub(crate) unsafe fn codegen(
  tcx: TyCtxt<'_>,
  mods: &mut GccContext,
  _module_name: &str,
  kind: AllocatorKind,
 ) {
  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 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>();
  let i8p = i8.make_pointer();
  let void = context.new_type::<()>();
@@ -49,25 53,43 @@ pub(crate) unsafe fn codegen(tcx: TyCtxt<'_>, mods: &mut GccContext, _module_nam
  };
  let name = global_fn_name(method.name);
 
- let args: Vec<_> = types.iter().enumerate()
  let args: Vec<_> = types
  .iter()
  .enumerate()
  .map(|(index, typ)| context.new_parameter(None, *typ, &format!("param{}", index)))
  .collect();
- let func = context.new_function(None, FunctionType::Exported, output.unwrap_or(void), &args, name, false);
  let func = context.new_function(
  None,
  FunctionType::Exported,
  output.unwrap_or(void),
  &args,
  name,
  false,
  );
 
  if tcx.sess.target.options.default_hidden_visibility {
- #[cfg(feature="master")]
  #[cfg(feature = "master")]
  func.add_attribute(FnAttribute::Visibility(gccjit::Visibility::Hidden));
  }
  if tcx.sess.must_emit_unwind_tables() {
  // TODO(antoyo): emit unwind tables.
  }
 
  let callee = default_fn_name(method.name);
- let args: Vec<_> = types.iter().enumerate()
  let args: Vec<_> = types
  .iter()
  .enumerate()
  .map(|(index, typ)| context.new_parameter(None, *typ, &format!("param{}", index)))
  .collect();
- let callee = context.new_function(None, FunctionType::Extern, output.unwrap_or(void), &args, callee, false);
- #[cfg(feature="master")]
  let callee = context.new_function(
  None,
  FunctionType::Extern,
  output.unwrap_or(void),
  &args,
  callee,
  false,
  );
  #[cfg(feature = "master")]
  callee.add_attribute(FnAttribute::Visibility(gccjit::Visibility::Hidden));
 
  let block = func.new_block("entry");
@@ -81,8 103,7 @@ pub(crate) unsafe fn codegen(tcx: TyCtxt<'_>, mods: &mut GccContext, _module_nam
  //llvm::LLVMSetTailCall(ret, True);
  if output.is_some() {
  block.end_with_return(None, ret);
- }
- else {
  } else {
  block.end_with_void_return(None);
  }
 
@@ -91,37 112,6 @@ pub(crate) unsafe fn codegen(tcx: TyCtxt<'_>, mods: &mut GccContext, _module_nam
  }
  }
 
- let types = [usize, usize];
- let name = "__rust_alloc_error_handler".to_string();
- let args: Vec<_> = types.iter().enumerate()
- .map(|(index, typ)| context.new_parameter(None, *typ, &format!("param{}", index)))
- .collect();
- let func = context.new_function(None, FunctionType::Exported, void, &args, name, false);
-
- if tcx.sess.target.default_hidden_visibility {
- #[cfg(feature="master")]
- func.add_attribute(FnAttribute::Visibility(gccjit::Visibility::Hidden));
- }
-
- let callee = alloc_error_handler_name(alloc_error_handler_kind);
- let args: Vec<_> = types.iter().enumerate()
- .map(|(index, typ)| context.new_parameter(None, *typ, &format!("param{}", index)))
- .collect();
- let callee = context.new_function(None, FunctionType::Extern, void, &args, callee, false);
- #[cfg(feature="master")]
- callee.add_attribute(FnAttribute::Visibility(gccjit::Visibility::Hidden));
-
- let block = func.new_block("entry");
-
- let args = args
- .iter()
- .enumerate()
- .map(|(i, _)| func.get_param(i as i32).to_rvalue())
- .collect::<Vec<_>>();
- let _ret = context.new_call(None, callee, &args);
- //llvm::LLVMSetTailCall(ret, True);
- block.end_with_void_return(None);
-
  let name = OomStrategy::SYMBOL.to_string();
  let global = context.new_global(None, GlobalKind::Exported, i8, name);
  let value = tcx.sess.opts.unstable_opts.oom.should_panic();

diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -165,11 165,11 @@ impl CodegenBackend for GccCodegenBackend {
 }
 
 impl ExtraBackendMethods for GccCodegenBackend {
- fn codegen_allocator<'tcx>(&self, tcx: TyCtxt<'tcx>, module_name: &str, kind: AllocatorKind, alloc_error_handler_kind: AllocatorKind) -> Self::Module {
  fn codegen_allocator<'tcx>(&self, tcx: TyCtxt<'tcx>, module_name: &str, kind: AllocatorKind) -> Self::Module {
  let mut mods = GccContext {
  context: Context::default(),
  };
- unsafe { allocator::codegen(tcx, &mut mods, module_name, kind, alloc_error_handler_kind); }
  unsafe { allocator::codegen(tcx, &mut mods, module_name, kind); }
  mods
  }