Create personality stub function for no_std panic=abort crates

**This is a very WIP state. It has no tests, no platform gates, and
probably many bugs.**

Every crate that may unwind (being compiled with panic=unwind) needs a reference to a personality function in its object code.

The personality function is defined in `std`. For crates downstream of `std` (with `std` in the cstore), they will resolve to the personality lang item of std and reference that function from there (using its symbol_name `rust_eh_personality`).

For `#![no_std]` crates, they will also reference the `rust_eh_personality` symbol (directly, not via weak lang item machinery).

But when `std` is never linked into a crate graph containing panic=unwind crates (which happens on all panic=unwind default targets because of core), the symbol isn't present and we get a linker error.

This PR solves this problem by injecting a stub for
`rust_eh_personality` into the final link of binaries where the previous
conditions were fulfilled. This is implemented in a way that's very
similar to the allocator shim.

Because we don't want to insta-stabilize this functionality, the stub
doesn't just abort, it will first do a volatile read of the
`__rust_personality_stub_is_unstable` symbol (once again similar to the
allocator) to ensure that this functionality cannot be relied on without
providing this symbol.

Example code that now works on x86_64-unknown-linux-gnu:
```rust

fn panic_handler(_: &core::panic::PanicInfo<'_>) -> ! {
    loop {}
}

unsafe extern "C" {
    fn write(fd: i32, buf: *const u8, count: usize);
}

static __rust_personality_stub_is_unstable: u8 = 0;

fn main() -> i32 {
    // bring in some code that requires the personality function
    [1].sort_unstable();

    let msg = b"meow\n";
    unsafe {
        write(1, msg.as_ptr(), msg.len());
    }
    0
}
```

When compiled with `-Cpanic=abort`, this would previously result in a
linker error because the `rust_eh_personality` symbol was not found.
Now, it compiles and runs successfully.

Author: Noratrieb

compiler/rustc_codegen_llvm/src/context.rs

@@ -687,6 +687,7 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         get_fn(self, instance)
     }
 
+    /// Get a function pointer for the exception handling personality function.
     fn eh_personality(&self) -> &'ll Value {
         // The exception handling personality function.
         //

compiler/rustc_codegen_llvm/src/lib.rs

@@ -77,6 +77,7 @@ mod intrinsic;
 pub mod llvm;
 mod llvm_util;
 mod mono_item;
+mod personality_stub;
 mod type_;
 mod type_of;
 mod va_arg;
@@ -122,6 +123,15 @@ impl ExtraBackendMethods for LlvmCodegenBackend {
         }
         module_llvm
     }
+    fn codegen_personality_stub<'tcx>(&self, tcx: TyCtxt<'tcx>, module_name: &str) -> Self::Module {
+        let mut module_llvm = ModuleLlvm::new_metadata(tcx, module_name);
+
+        unsafe {
+            personality_stub::codegen(tcx, &mut module_llvm, module_name);
+        }
+
+        module_llvm
+    }
     fn compile_codegen_unit(
         &self,
         tcx: TyCtxt<'_>,

compiler/rustc_codegen_llvm/src/personality_stub.rs

@@ -0,0 +1,102 @@
+use rustc_middle::ty::TyCtxt;
+use rustc_session::config::DebugInfo;
+
+use crate::common::AsCCharPtr;
+use crate::llvm::{self, Context, False, Module};
+use crate::{ModuleLlvm, attributes, debuginfo};
+
+const FEATURE_GATE_SYMBOL: &str = "__rust_personality_stub_is_unstable";
+
+pub(crate) unsafe fn codegen(tcx: TyCtxt<'_>, module_llvm: &mut ModuleLlvm, module_name: &str) {
+    let llcx = &*module_llvm.llcx;
+    let llmod = module_llvm.llmod();
+
+    // rust alloc error handler
+    create_stub_personality(tcx, llcx, llmod);
+
+    if tcx.sess.opts.debuginfo != DebugInfo::None {
+        let dbg_cx = debuginfo::CodegenUnitDebugContext::new(llmod);
+        debuginfo::metadata::build_compile_unit_di_node(tcx, module_name, &dbg_cx);
+        dbg_cx.finalize(tcx.sess);
+    }
+}
+
+fn create_stub_personality(tcx: TyCtxt<'_>, llcx: &Context, llmod: &Module) {
+    unsafe {
+        let llfn = declare_stub_personality(tcx, llcx, llmod);
+
+        let i8_ty = llvm::LLVMInt8TypeInContext(llcx);
+
+        let feature_gate = llvm::LLVMRustGetOrInsertGlobal(
+            llmod,
+            FEATURE_GATE_SYMBOL.as_c_char_ptr(),
+            FEATURE_GATE_SYMBOL.len(),
+            i8_ty,
+        );
+
+        let (trap_fn, trap_ty) = trap_intrinsic(llcx, llmod);
+
+        let llbb = llvm::LLVMAppendBasicBlockInContext(llcx, llfn, c"entry".as_ptr());
+        let llbuilder = llvm::LLVMCreateBuilderInContext(llcx);
+        llvm::LLVMPositionBuilderAtEnd(llbuilder, llbb);
+
+        let load = llvm::LLVMBuildLoad2(llbuilder, i8_ty, feature_gate, c"".as_ptr());
+        llvm::LLVMSetVolatile(load, llvm::True);
+
+        llvm::LLVMBuildCallWithOperandBundles(
+            llbuilder,
+            trap_ty,
+            trap_fn,
+            [].as_ptr(),
+            0,
+            [].as_ptr(),
+            0,
+            c"".as_ptr(),
+        );
+
+        llvm::LLVMBuildUnreachable(llbuilder);
+
+        llvm::LLVMDisposeBuilder(llbuilder);
+    }
+}
+
+fn declare_stub_personality<'ll>(
+    tcx: TyCtxt<'_>,
+    llcx: &'ll Context,
+    llmod: &'ll Module,
+) -> &'ll llvm::Value {
+    let name = "rust_eh_personality";
+    unsafe {
+        let no_return = llvm::AttributeKind::NoReturn.create_attr(llcx);
+
+        let ty = llvm::LLVMFunctionType(llvm::LLVMVoidTypeInContext(llcx), [].as_ptr(), 0, False);
+        let llfn = llvm::LLVMRustGetOrInsertFunction(llmod, name.as_c_char_ptr(), name.len(), ty);
+        attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &[no_return]);
+        llvm::set_visibility(llfn, llvm::Visibility::from_generic(tcx.sess.default_visibility()));
+
+        if tcx.sess.must_emit_unwind_tables() {
+            let uwtable =
+                attributes::uwtable_attr(llcx, tcx.sess.opts.unstable_opts.use_sync_unwind);
+            attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &[uwtable]);
+        }
+
+        llfn
+    }
+}
+
+fn trap_intrinsic<'ll>(
+    llcx: &'ll Context,
+    llmod: &'ll Module,
+) -> (&'ll llvm::Value, &'ll llvm::Type) {
+    let name = "llvm.trap";
+
+    unsafe {
+        let no_return = llvm::AttributeKind::NoReturn.create_attr(llcx);
+        let llty = llvm::LLVMFunctionType(llvm::LLVMVoidTypeInContext(llcx), [].as_ptr(), 0, False);
+        let llfn = llvm::LLVMRustGetOrInsertFunction(llmod, name.as_c_char_ptr(), name.len(), llty);
+        llvm::SetFunctionCallConv(llfn, llvm::CCallConv);
+        attributes::apply_to_llfn(llfn, llvm::AttributePlace::Function, &[no_return]);
+
+        (llfn, llty)
+    }
+}

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -208,6 +208,9 @@ pub fn link_binary(
         if let Some(ref allocator_module) = codegen_results.allocator_module {
             remove_temps_from_module(allocator_module);
         }
+        if let Some(ref personality_stub_module) = codegen_results.personality_stub_module {
+            remove_temps_from_module(personality_stub_module);
+        }
 
         // Remove the temporary files if output goes to stdout
         for temp in tempfiles_for_stdout_output {
@@ -333,6 +336,11 @@ fn link_rlib<'a>(
             if let Some(obj) = obj {
                 ab.add_file(obj);
             }
+            let obj =
+                codegen_results.personality_stub_module.as_ref().and_then(|m| m.object.as_ref());
+            if let Some(obj) = obj {
+                ab.add_file(obj);
+            }
         }
     }
 
@@ -2193,6 +2201,18 @@ fn add_local_crate_allocator_objects(cmd: &mut dyn Linker, codegen_results: &Cod
     }
 }
 
+/// Add object files for the personality stub linked once if necessary for the whole crate tree.
+fn add_local_crate_personality_stub_objects(
+    cmd: &mut dyn Linker,
+    codegen_results: &CodegenResults,
+) {
+    if let Some(obj) =
+        codegen_results.personality_stub_module.as_ref().and_then(|m| m.object.as_ref())
+    {
+        cmd.add_object(obj);
+    }
+}
+
 /// Add object files containing metadata for the current crate.
 fn add_local_crate_metadata_objects(
     cmd: &mut dyn Linker,
@@ -2376,6 +2396,7 @@ fn linker_with_args(
     add_local_crate_regular_objects(cmd, codegen_results);
     add_local_crate_metadata_objects(cmd, crate_type, codegen_results);
     add_local_crate_allocator_objects(cmd, codegen_results);
+    add_local_crate_personality_stub_objects(cmd, codegen_results);
 
     // Avoid linking to dynamic libraries unless they satisfy some undefined symbols
     // at the point at which they are specified on the command line.

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -141,6 +141,7 @@ impl ModuleConfig {
             || match kind {
                 ModuleKind::Regular => sess.opts.output_types.contains_key(&OutputType::Object),
                 ModuleKind::Allocator => false,
+                ModuleKind::PersonalityStub => false,
                 ModuleKind::Metadata => sess.opts.output_types.contains_key(&OutputType::Metadata),
             };
 
@@ -342,6 +343,7 @@ pub struct CodegenContext<B: WriteBackendMethods> {
     pub regular_module_config: Arc<ModuleConfig>,
     pub metadata_module_config: Arc<ModuleConfig>,
     pub allocator_module_config: Arc<ModuleConfig>,
+    pub personality_stub_module_config: Arc<ModuleConfig>,
     pub tm_factory: TargetMachineFactoryFn<B>,
     pub msvc_imps_needed: bool,
     pub is_pe_coff: bool,
@@ -386,6 +388,7 @@ impl<B: WriteBackendMethods> CodegenContext<B> {
             ModuleKind::Regular => &self.regular_module_config,
             ModuleKind::Metadata => &self.metadata_module_config,
             ModuleKind::Allocator => &self.allocator_module_config,
+            ModuleKind::PersonalityStub => &self.personality_stub_module_config,
         }
     }
 }
@@ -440,6 +443,7 @@ fn generate_lto_work<B: ExtraBackendMethods>(
 struct CompiledModules {
     modules: Vec<CompiledModule>,
     allocator_module: Option<CompiledModule>,
+    personality_stub_module: Option<CompiledModule>,
 }
 
 fn need_bitcode_in_object(tcx: TyCtxt<'_>) -> bool {
@@ -477,6 +481,7 @@ pub(crate) fn start_async_codegen<B: ExtraBackendMethods>(
     let regular_config = ModuleConfig::new(ModuleKind::Regular, tcx, no_builtins);
     let metadata_config = ModuleConfig::new(ModuleKind::Metadata, tcx, no_builtins);
     let allocator_config = ModuleConfig::new(ModuleKind::Allocator, tcx, no_builtins);
+    let personality_stub_config = ModuleConfig::new(ModuleKind::PersonalityStub, tcx, no_builtins);
 
     let (shared_emitter, shared_emitter_main) = SharedEmitter::new();
     let (codegen_worker_send, codegen_worker_receive) = channel();
@@ -491,6 +496,7 @@ pub(crate) fn start_async_codegen<B: ExtraBackendMethods>(
         Arc::new(regular_config),
         Arc::new(metadata_config),
         Arc::new(allocator_config),
+        Arc::new(personality_stub_config),
         coordinator_send.clone(),
     );
 
@@ -704,6 +710,11 @@ fn produce_final_output_artifacts(
                     ensure_removed(sess.dcx(), path);
                 }
             }
+            if let Some(ref personality_stub_module) = compiled_modules.personality_stub_module {
+                if let Some(ref path) = personality_stub_module.bytecode {
+                    ensure_removed(sess.dcx(), path);
+                }
+            }
         }
     }
 
@@ -1109,6 +1120,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
     regular_config: Arc<ModuleConfig>,
     metadata_config: Arc<ModuleConfig>,
     allocator_config: Arc<ModuleConfig>,
+    personality_stub_config: Arc<ModuleConfig>,
     tx_to_llvm_workers: Sender<Box<dyn Any + Send>>,
 ) -> thread::JoinHandle<Result<CompiledModules, ()>> {
     let coordinator_send = tx_to_llvm_workers;
@@ -1202,6 +1214,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
         regular_module_config: regular_config,
         metadata_module_config: metadata_config,
         allocator_module_config: allocator_config,
+        personality_stub_module_config: personality_stub_config,
         tm_factory: backend.target_machine_factory(tcx.sess, ol, backend_features),
         msvc_imps_needed: msvc_imps_needed(tcx),
         is_pe_coff: tcx.sess.target.is_like_windows,
@@ -1367,6 +1380,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
         let mut autodiff_items = Vec::new();
         let mut compiled_modules = vec![];
         let mut compiled_allocator_module = None;
+        let mut compiled_personality_stub_module = None;
         let mut needs_link = Vec::new();
         let mut needs_fat_lto = Vec::new();
         let mut needs_thin_lto = Vec::new();
@@ -1655,6 +1669,10 @@ fn start_executing_work<B: ExtraBackendMethods>(
                                     assert!(compiled_allocator_module.is_none());
                                     compiled_allocator_module = Some(compiled_module);
                                 }
+                                ModuleKind::PersonalityStub => {
+                                    assert!(compiled_personality_stub_module.is_none());
+                                    compiled_personality_stub_module = Some(compiled_module);
+                                }
                                 ModuleKind::Metadata => bug!("Should be handled separately"),
                             }
                         }
@@ -1721,6 +1739,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
         Ok(CompiledModules {
             modules: compiled_modules,
             allocator_module: compiled_allocator_module,
+            personality_stub_module: compiled_personality_stub_module,
         })
     })
     .expect("failed to spawn coordinator thread");
@@ -2084,6 +2103,7 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {
 
                 modules: compiled_modules.modules,
                 allocator_module: compiled_modules.allocator_module,
+                personality_stub_module: compiled_modules.personality_stub_module,
                 metadata_module: self.metadata_module,
             },
             work_products,

compiler/rustc_codegen_ssa/src/base.rs

@@ -28,6 +28,7 @@ use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_session::Session;
 use rustc_session::config::{self, CrateType, EntryFnType, OutputType};
 use rustc_span::{DUMMY_SP, Symbol, sym};
+use rustc_target::spec::PanicStrategy;
 use rustc_trait_selection::infer::{BoundRegionConversionTime, TyCtxtInferExt};
 use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt};
 use tracing::{debug, info};
@@ -592,6 +593,18 @@ pub fn allocator_kind_for_codegen(tcx: TyCtxt<'_>) -> Option<AllocatorKind> {
     if any_dynamic_crate { None } else { tcx.allocator_kind(()) }
 }
 
+/// Decide whether to inject an aborting stub personality function into this crate.
+pub fn needs_stub_personality_function(tcx: TyCtxt<'_>) -> bool {
+    let missing_personality = tcx.lang_items().eh_personality().is_none();
+    let is_abort = tcx.sess.panic_strategy() == PanicStrategy::Abort;
+    let is_not_panic_abort = tcx
+        .crates(())
+        .iter()
+        .any(|cnum| tcx.required_panic_strategy(*cnum) != Some(PanicStrategy::Abort));
+    let any_non_rlib = tcx.crate_types().iter().any(|ctype| *ctype != CrateType::Rlib);
+    missing_personality && is_abort && is_not_panic_abort && any_non_rlib
+}
+
 pub fn codegen_crate<B: ExtraBackendMethods>(
     backend: B,
     tcx: TyCtxt<'_>,
@@ -692,6 +705,27 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
         );
     }
 
+    if needs_stub_personality_function(tcx) {
+        let llmod_id = cgu_name_builder
+            .build_cgu_name(LOCAL_CRATE, &["crate"], Some("personality_stub"))
+            .to_string();
+        let module_llvm = tcx.sess.time("write_personality_stub_module", || {
+            backend.codegen_personality_stub(tcx, &llmod_id)
+        });
+
+        ongoing_codegen.wait_for_signal_to_codegen_item();
+        ongoing_codegen.check_for_errors(tcx.sess);
+
+        // These modules are generally cheap and won't throw off scheduling.
+        let cost = 0;
+        submit_codegened_module_to_llvm(
+            &backend,
+            &ongoing_codegen.coordinator.sender,
+            ModuleCodegen { name: llmod_id, module_llvm, kind: ModuleKind::PersonalityStub },
+            cost,
+        );
+    }
+
     if !autodiff_fncs.is_empty() {
         ongoing_codegen.submit_autodiff_items(autodiff_fncs);
     }

compiler/rustc_codegen_ssa/src/lib.rs

@@ -145,6 +145,7 @@ pub enum ModuleKind {
     Regular,
     Metadata,
     Allocator,
+    PersonalityStub,
 }
 
 bitflags::bitflags! {
@@ -213,6 +214,7 @@ pub struct CrateInfo {
 pub struct CodegenResults {
     pub modules: Vec<CompiledModule>,
     pub allocator_module: Option<CompiledModule>,
+    pub personality_stub_module: Option<CompiledModule>,
     pub metadata_module: Option<CompiledModule>,
     pub metadata: rustc_metadata::EncodedMetadata,
     pub crate_info: CrateInfo,

compiler/rustc_codegen_ssa/src/traits/backend.rs

@@ -108,6 +108,8 @@ pub trait ExtraBackendMethods:
         alloc_error_handler_kind: AllocatorKind,
     ) -> Self::Module;
 
+    fn codegen_personality_stub<'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.
     fn compile_codegen_unit(