Replace -Zon-broken-pipe=... with Externally Implementable Item #[std::io::on_broken_pipe]

Author: Enselic

compiler/rustc/src/main.rs

@@ -2,6 +2,14 @@
 #![feature(rustc_private)]
 // Several crates are depended upon but unused so that they are present in the sysroot
 #![expect(unused_crate_dependencies)]
+#![cfg_attr(not(bootstrap), feature(on_broken_pipe))]
+
+#[cfg_attr(not(bootstrap), std::io::on_broken_pipe)]
+#[cfg(not(bootstrap))]
+fn on_broken_pipe() -> std::io::OnBrokenPipe {
+    // FIXME(#131436): Ideally there would be no use of e.g. `println!()` in the compiler.
+    std::io::OnBrokenPipe::Kill
+}
 
 // A note about jemalloc: rustc uses jemalloc when built for CI and
 // distribution. The obvious way to do this is with the `#[global_allocator]`

compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs

@@ -98,12 +98,7 @@ enum Ordering {
 }
 
 #[lang = "start"]
-fn start<T: Termination + 'static>(
-    main: fn() -> T,
-    argc: isize,
-    argv: *const *const u8,
-    _sigpipe: u8,
-) -> isize {
+fn start<T: Termination + 'static>(main: fn() -> T, argc: isize, argv: *const *const u8) -> isize {
     if argc == 3 {
         unsafe {
             puts(*argv as *const i8);

compiler/rustc_codegen_cranelift/src/main_shim.rs

@@ -14,13 +14,8 @@ pub(crate) fn maybe_create_entry_wrapper(
     is_jit: bool,
     is_primary_cgu: bool,
 ) {
-    let (main_def_id, sigpipe) = match tcx.entry_fn(()) {
-        Some((def_id, entry_ty)) => (
-            def_id,
-            match entry_ty {
-                EntryFnType::Main { sigpipe } => sigpipe,
-            },
-        ),
+    let main_def_id = match tcx.entry_fn(()) {
+        Some((def_id, EntryFnType::Main)) => def_id,
         None => return,
     };
 
@@ -33,14 +28,13 @@ pub(crate) fn maybe_create_entry_wrapper(
         return;
     }
 
-    create_entry_fn(tcx, module, main_def_id, is_jit, sigpipe);
+    create_entry_fn(tcx, module, main_def_id, is_jit);
 
     fn create_entry_fn(
         tcx: TyCtxt<'_>,
         m: &mut dyn Module,
         rust_main_def_id: DefId,
         ignore_lang_start_wrapper: bool,
-        sigpipe: u8,
     ) {
         let main_ret_ty = tcx.fn_sig(rust_main_def_id).no_bound_vars().unwrap().output();
         // Given that `main()` has no arguments,
@@ -91,7 +85,6 @@ pub(crate) fn maybe_create_entry_wrapper(
             bcx.switch_to_block(block);
             let arg_argc = bcx.append_block_param(block, m.target_config().pointer_type());
             let arg_argv = bcx.append_block_param(block, m.target_config().pointer_type());
-            let arg_sigpipe = bcx.ins().iconst(types::I8, sigpipe as i64);
 
             let main_func_ref = m.declare_func_in_func(main_func_id, bcx.func);
 
@@ -149,8 +142,7 @@ pub(crate) fn maybe_create_entry_wrapper(
                 let main_val = bcx.ins().func_addr(m.target_config().pointer_type(), main_func_ref);
 
                 let func_ref = m.declare_func_in_func(start_func_id, bcx.func);
-                let call_inst =
-                    bcx.ins().call(func_ref, &[main_val, arg_argc, arg_argv, arg_sigpipe]);
+                let call_inst = bcx.ins().call(func_ref, &[main_val, arg_argc, arg_argv]);
                 bcx.inst_results(call_inst)[0]
             };
 

compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs

@@ -86,7 +86,6 @@ fn start<T: Termination + 'static>(
     main: fn() -> T,
     argc: isize,
     argv: *const *const u8,
-    _sigpipe: u8,
 ) -> isize {
     if argc == 3 {
         unsafe { puts(*argv); }

compiler/rustc_codegen_ssa/src/base.rs

@@ -535,7 +535,7 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         let ptr_ty = cx.type_ptr();
         let (arg_argc, arg_argv) = get_argc_argv(&mut bx);
 
-        let EntryFnType::Main { sigpipe } = entry_type;
+        let EntryFnType::Main = entry_type;
         let (start_fn, start_ty, args, instance) = {
             let start_def_id = cx.tcx().require_lang_item(LangItem::Start, DUMMY_SP);
             let start_instance = ty::Instance::expect_resolve(
@@ -547,16 +547,8 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
             );
             let start_fn = cx.get_fn_addr(start_instance);
 
-            let i8_ty = cx.type_i8();
-            let arg_sigpipe = bx.const_u8(sigpipe);
-
-            let start_ty = cx.type_func(&[cx.val_ty(rust_main), isize_ty, ptr_ty, i8_ty], isize_ty);
-            (
-                start_fn,
-                start_ty,
-                vec![rust_main, arg_argc, arg_argv, arg_sigpipe],
-                Some(start_instance),
-            )
+            let start_ty = cx.type_func(&[cx.val_ty(rust_main), isize_ty, ptr_ty], isize_ty);
+            (start_fn, start_ty, vec![rust_main, arg_argc, arg_argv], Some(start_instance))
         };
 
         let result = bx.call(start_ty, None, None, start_fn, &args, None, instance);

compiler/rustc_hir_analysis/src/check/entry.rs

@@ -18,7 +18,7 @@ use crate::errors;
 
 pub(crate) fn check_for_entry_fn(tcx: TyCtxt<'_>) {
     match tcx.entry_fn(()) {
-        Some((def_id, EntryFnType::Main { .. })) => check_main_fn_ty(tcx, def_id),
+        Some((def_id, EntryFnType::Main)) => check_main_fn_ty(tcx, def_id),
         _ => {}
     }
 }

compiler/rustc_hir_typeck/src/check.rs

@@ -217,7 +217,7 @@ fn check_panic_info_fn(tcx: TyCtxt<'_>, fn_id: LocalDefId, fn_sig: ty::FnSig<'_>
 }
 
 fn check_lang_start_fn<'tcx>(tcx: TyCtxt<'tcx>, fn_sig: ty::FnSig<'tcx>, def_id: LocalDefId) {
-    // build type `fn(main: fn() -> T, argc: isize, argv: *const *const u8, sigpipe: u8)`
+    // build type `fn(main: fn() -> T, argc: isize, argv: *const *const u8)`
 
     // make a Ty for the generic on the fn for diagnostics
     // FIXME: make the lang item generic checks check for the right generic *kind*
@@ -231,12 +231,7 @@ fn check_lang_start_fn<'tcx>(tcx: TyCtxt<'tcx>, fn_sig: ty::FnSig<'tcx>, def_id:
     );
 
     let expected_sig = ty::Binder::dummy(tcx.mk_fn_sig(
-        [
-            main_fn_ty,
-            tcx.types.isize,
-            Ty::new_imm_ptr(tcx, Ty::new_imm_ptr(tcx, tcx.types.u8)),
-            tcx.types.u8,
-        ],
+        [main_fn_ty, tcx.types.isize, Ty::new_imm_ptr(tcx, Ty::new_imm_ptr(tcx, tcx.types.u8))],
         tcx.types.isize,
         false,
         fn_sig.safety,

compiler/rustc_interface/src/tests.rs

@@ -27,8 +27,8 @@ use rustc_span::edition::{DEFAULT_EDITION, Edition};
 use rustc_span::source_map::{RealFileLoader, SourceMapInputs};
 use rustc_span::{FileName, SourceFileHashAlgorithm, sym};
 use rustc_target::spec::{
-    CodeModel, FramePointer, LinkerFlavorCli, MergeFunctions, OnBrokenPipe, PanicStrategy,
-    RelocModel, RelroLevel, SanitizerSet, SplitDebuginfo, StackProtector, TlsModel,
+    CodeModel, FramePointer, LinkerFlavorCli, MergeFunctions, PanicStrategy, RelocModel,
+    RelroLevel, SanitizerSet, SplitDebuginfo, StackProtector, TlsModel,
 };
 
 use crate::interface::{initialize_checked_jobserver, parse_cfg};
@@ -839,7 +839,6 @@ fn test_unstable_options_tracking_hash() {
     tracked!(no_trait_vptr, true);
     tracked!(no_unique_section_names, true);
     tracked!(offload, vec![Offload::Device]);
-    tracked!(on_broken_pipe, OnBrokenPipe::Kill);
     tracked!(osx_rpath_install_name, true);
     tracked!(packed_bundled_libs, true);
     tracked!(panic_abort_tests, true);

compiler/rustc_monomorphize/src/collector.rs

@@ -1684,7 +1684,7 @@ impl<'v> RootCollector<'_, 'v> {
     /// the return type of `main`. This is not needed when
     /// the user writes their own `start` manually.
     fn push_extra_entry_roots(&mut self) {
-        let Some((main_def_id, EntryFnType::Main { .. })) = self.entry_fn else {
+        let Some((main_def_id, EntryFnType::Main)) = self.entry_fn else {
             return;
         };
 

compiler/rustc_passes/src/entry.rs

@@ -5,7 +5,7 @@ use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{CRATE_HIR_ID, ItemId, Node, find_attr};
 use rustc_middle::query::Providers;
 use rustc_middle::ty::TyCtxt;
-use rustc_session::config::{CrateType, EntryFnType, sigpipe};
+use rustc_session::config::{CrateType, EntryFnType};
 use rustc_span::{RemapPathScopeComponents, Span};
 
 use crate::errors::{ExternMain, MultipleRustcMain, NoMainErr};
@@ -75,7 +75,7 @@ fn check_and_search_item(id: ItemId, ctxt: &mut EntryContext<'_>) {
 fn configure_main(tcx: TyCtxt<'_>, visitor: &EntryContext<'_>) -> Option<(DefId, EntryFnType)> {
     if let Some((local_def_id, _)) = visitor.rustc_main_fn {
         let def_id = local_def_id.to_def_id();
-        Some((def_id, EntryFnType::Main { sigpipe: sigpipe(tcx) }))
+        Some((def_id, EntryFnType::Main))
     } else {
         // The actual resolution of main happens in the resolver, this here
         if let Some(main_def) = tcx.resolutions(()).main_def
@@ -89,22 +89,13 @@ fn configure_main(tcx: TyCtxt<'_>, visitor: &EntryContext<'_>) -> Option<(DefId,
                 return None;
             }
 
-            return Some((def_id, EntryFnType::Main { sigpipe: sigpipe(tcx) }));
+            return Some((def_id, EntryFnType::Main));
         }
         no_main_err(tcx, visitor);
         None
     }
 }
 
-fn sigpipe(tcx: TyCtxt<'_>) -> u8 {
-    match tcx.sess.opts.unstable_opts.on_broken_pipe {
-        rustc_target::spec::OnBrokenPipe::Default => sigpipe::DEFAULT,
-        rustc_target::spec::OnBrokenPipe::Kill => sigpipe::SIG_DFL,
-        rustc_target::spec::OnBrokenPipe::Error => sigpipe::SIG_IGN,
-        rustc_target::spec::OnBrokenPipe::Inherit => sigpipe::INHERIT,
-    }
-}
-
 fn no_main_err(tcx: TyCtxt<'_>, visitor: &EntryContext<'_>) {
     let sp = tcx.def_span(CRATE_DEF_ID);