Rollup of 14 pull requests

bootstrap.example.toml

@@ -956,6 +956,12 @@
 # want to enable this right now.
 #rust.wasm-proc-macros = false
 
+# Enables wasm targets to be built with `-Cpanic=unwind` by default instead of
+# the current `-Cpanic=abort`. This is currently used in testing the Rust
+# compiler itself and is only intended for local development/testing at this
+# time.
+#rust.wasm-panic-unwind-default = false
+
 # =============================================================================
 # Distribution options
 #

compiler/rustc_codegen_cranelift/src/debuginfo/unwind.rs

@@ -25,7 +25,7 @@ pub(crate) struct UnwindContext {
 }
 
 impl UnwindContext {
-    pub(crate) fn new(module: &mut dyn Module, pic_eh_frame: bool) -> Self {
+    pub(crate) fn new(module: &mut dyn Module, eh_personality: &str, pic_eh_frame: bool) -> Self {
         let endian = match module.isa().endianness() {
             Endianness::Little => RunTimeEndian::Little,
             Endianness::Big => RunTimeEndian::Big,
@@ -70,7 +70,7 @@ impl UnwindContext {
                 // FIXME use eh_personality lang item instead
                 let personality = module
                     .declare_function(
-                        "rust_eh_personality",
+                        eh_personality,
                         Linkage::Import,
                         &Signature {
                             params: vec![
@@ -89,7 +89,7 @@ impl UnwindContext {
                 // Use indirection here to support PIC the case where rust_eh_personality is defined in
                 // another DSO.
                 let personality_ref = module
-                    .declare_data("DW.ref.rust_eh_personality", Linkage::Local, false, false)
+                    .declare_data(&format!("DW.ref.{eh_personality}"), Linkage::Local, false, false)
                     .unwrap();
 
                 let mut personality_ref_data = DataDescription::new();

compiler/rustc_codegen_cranelift/src/driver/aot.rs

@@ -62,7 +62,11 @@ fn make_module(tcx: TyCtxt<'_>, cgu_name: &str) -> AotModule {
         tcx.sess.opts.unstable_opts.function_sections.unwrap_or(default_function_sections),
     );
 
-    let module = UnwindModule::new(ObjectModule::new(builder), true);
+    let module = UnwindModule::new(
+        ObjectModule::new(builder),
+        &rustc_symbol_mangling::eh_personality_symbol(tcx),
+        true,
+    );
 
     let producer = crate::debuginfo::producer(tcx.sess);
     let global_asm_config = GlobalAsmConfig::new(tcx.sess);

compiler/rustc_codegen_cranelift/src/driver/jit.rs

@@ -25,7 +25,11 @@ fn create_jit_module(
     let mut jit_builder = JITBuilder::with_isa(isa, cranelift_module::default_libcall_names());
     crate::compiler_builtins::register_functions_for_jit(&mut jit_builder);
     jit_builder.symbol_lookup_fn(dep_symbol_lookup_fn(tcx.sess, crate_info.clone()));
-    let mut jit_module = UnwindModule::new(JITModule::new(jit_builder), false);
+    let mut jit_module = UnwindModule::new(
+        JITModule::new(jit_builder),
+        &rustc_symbol_mangling::eh_personality_symbol(tcx),
+        false,
+    );
 
     let cx = DebugContext::new(tcx, jit_module.isa(), false, "dummy_cgu_name");
 

compiler/rustc_codegen_cranelift/src/unwind_module.rs

@@ -17,8 +17,8 @@ pub(crate) struct UnwindModule<T> {
 }
 
 impl<T: Module> UnwindModule<T> {
-    pub(crate) fn new(mut module: T, pic_eh_frame: bool) -> Self {
-        let unwind_context = UnwindContext::new(&mut module, pic_eh_frame);
+    pub(crate) fn new(mut module: T, eh_personality: &str, pic_eh_frame: bool) -> Self {
+        let unwind_context = UnwindContext::new(&mut module, eh_personality, pic_eh_frame);
         UnwindModule { module, unwind_context }
     }
 }

compiler/rustc_codegen_gcc/src/context.rs

@@ -517,10 +517,12 @@ impl<'gcc, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                 self.declare_fn(symbol_name, fn_abi)
             }
             _ => {
+                let rust_name;
                 let name = if wants_msvc_seh(&self.sess().target) {
                     "__CxxFrameHandler3"
                 } else {
-                    "rust_eh_personality"
+                    rust_name = rustc_symbol_mangling::eh_personality_symbol(tcx);
+                    &rust_name
                 };
                 self.declare_func(name, self.type_i32(), &[], true)
             }

compiler/rustc_codegen_gcc/src/declare.rs

@@ -203,7 +203,7 @@ fn declare_raw_fn<'gcc>(
         cx.functions.borrow_mut().insert(name.to_string(), func);
 
         #[cfg(feature = "master")]
-        if name == "rust_eh_personality" {
+        if name.ends_with("rust_eh_personality") {
             // NOTE: GCC will sometimes change the personality function set on a function from
             // rust_eh_personality to __gcc_personality_v0 as an optimization.
             // As such, we need to create a weak alias from __gcc_personality_v0 to

compiler/rustc_codegen_gcc/src/lib.rs

@@ -153,6 +153,14 @@ impl GccCodegenBackend {
     fn config(&self) -> &BackendConfig {
         self.config.as_ref().expect("target info not initialized")
     }
+
+    #[cfg(feature = "master")]
+    fn set_personality_function(&self, tcx: TyCtxt<'_>) {
+        let personality_symbol = rustc_symbol_mangling::eh_personality_symbol(tcx);
+        gccjit::set_global_personality_function_name(
+            &CString::new(personality_symbol).expect("symbol name shouldn't contain NUL"),
+        );
+    }
 }
 
 fn load_libgccjit_if_needed(libgccjit_target_lib_file: &Path) {
@@ -235,8 +243,6 @@ impl CodegenBackend for GccCodegenBackend {
                 target_info: Arc::new(IntoDynSyncSend(context.get_target_info())),
                 lto_supported: gccjit::is_lto_supported(),
             });
-
-            gccjit::set_global_personality_function_name(c"rust_eh_personality");
         }
 
         #[cfg(not(feature = "master"))]
@@ -272,6 +278,8 @@ impl CodegenBackend for GccCodegenBackend {
     }
 
     fn codegen_crate(&self, tcx: TyCtxt<'_>) -> Box<dyn Any> {
+        #[cfg(feature = "master")]
+        self.set_personality_function(tcx);
         Box::new(codegen_crate(self.clone(), tcx))
     }
 

compiler/rustc_codegen_llvm/src/back/llvm_backend.rs

@@ -3,8 +3,11 @@
 
 use std::any::Any;
 use std::ffi::CStr;
+use std::marker::PhantomData;
 use std::mem::ManuallyDrop;
 use std::path::PathBuf;
+use std::ptr;
+use std::sync::OnceLock;
 
 use rustc_ast::expand::allocator::AllocatorMethod;
 use rustc_codegen_ssa::back::lto::ThinModule;
@@ -59,11 +62,10 @@ impl ExtraBackendMethods for LlvmCodegenBackend {
         methods: &[AllocatorMethod],
     ) -> 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, methods);
-        }
+        module_llvm.with_module_refs(|ModuleRefs { llcx, llmod, .. }| {
+            let cx = SimpleCx::new(llmod, llcx, tcx.data_layout.pointer_size());
+            unsafe { allocator::codegen(tcx, cx, module_name, methods) };
+        });
         module_llvm
     }
     fn compile_codegen_unit(
@@ -141,7 +143,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
         module: &mut ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) {
-        back::write::optimize(cgcx, prof, shared_emitter, module, config)
+        back::write::optimize(cgcx, prof, shared_emitter, module, config);
     }
     fn optimize_and_codegen_thin(
         cgcx: &CodegenContext,
@@ -162,7 +164,9 @@ impl WriteBackendMethods for LlvmCodegenBackend {
         back::write::codegen(cgcx, prof, shared_emitter, module, config)
     }
     fn serialize_module(module: Self::Module, is_thin: bool) -> Self::ModuleBuffer {
-        back::lto::ModuleBuffer::new(module.llmod(), is_thin)
+        module.with_module_refs(|ModuleRefs { llmod, .. }| {
+            back::lto::ModuleBuffer::new(llmod, is_thin)
+        })
     }
 }
 
@@ -421,40 +425,56 @@ impl CodegenBackend for LlvmCodegenBackend {
 }
 
 pub struct ModuleLlvm {
-    pub(crate) llcx: &'static mut llvm::Context,
+    llcx_raw: ptr::NonNull<llvm::Context>,
     llmod_raw: *const llvm::Module,
 
     // This field is `ManuallyDrop` because it is important that the `TargetMachine`
     // is disposed prior to the `Context` being disposed otherwise UAFs can occur.
-    pub(crate) tm: ManuallyDrop<OwnedTargetMachine>,
+    tm: ManuallyDrop<OwnedTargetMachine>,
+
+    /// Saved ThinLTO buffer for embedding in the object file.
+    ///
+    /// This is currently a `OnceLock` to avoid aliasing problems when writing to it
+    /// from code that also wants to pass around a shared ref to `ModuleCodegen`.
+    pub(crate) thin_lto_buffer: OnceLock<Vec<u8>>,
 }
 
 unsafe impl Send for ModuleLlvm {}
 unsafe impl Sync for ModuleLlvm {}
 
+/// Shared helper to call [`llvm::LLVMContextCreate`] and then configure
+/// [`llvm::LLVMContextSetDiscardValueNames`].
+fn create_context_and_set_fewer_names(fewer_names: bool) -> ptr::NonNull<llvm::Context> {
+    unsafe {
+        let llcx_raw = llvm::LLVMContextCreate();
+        llvm::LLVMContextSetDiscardValueNames(llcx_raw.as_ref(), fewer_names.to_llvm_bool());
+        llcx_raw
+    }
+}
+
 impl ModuleLlvm {
     pub(crate) fn new(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
-            let llcx = llvm::LLVMContextCreate();
-            llvm::LLVMContextSetDiscardValueNames(llcx, tcx.sess.fewer_names().to_llvm_bool());
-            let llmod_raw = context::create_module(tcx, llcx, mod_name) as *const _;
+            let llcx_raw = create_context_and_set_fewer_names(tcx.sess.fewer_names());
+            let llmod_raw = context::create_module(tcx, llcx_raw.as_ref(), mod_name);
             ModuleLlvm {
                 llmod_raw,
-                llcx,
+                llcx_raw,
                 tm: ManuallyDrop::new(create_target_machine(tcx, mod_name)),
+                thin_lto_buffer: OnceLock::new(),
             }
         }
     }
 
     pub(crate) fn new_metadata(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
-            let llcx = llvm::LLVMContextCreate();
-            llvm::LLVMContextSetDiscardValueNames(llcx, tcx.sess.fewer_names().to_llvm_bool());
-            let llmod_raw = context::create_module(tcx, llcx, mod_name) as *const _;
+            let llcx_raw = create_context_and_set_fewer_names(tcx.sess.fewer_names());
+            let llmod_raw = context::create_module(tcx, llcx_raw.as_ref(), mod_name);
             ModuleLlvm {
                 llmod_raw,
-                llcx,
+                llcx_raw,
                 tm: ManuallyDrop::new(create_informational_target_machine(tcx.sess)),
+                thin_lto_buffer: OnceLock::new(),
             }
         }
     }
@@ -467,25 +487,55 @@ impl ModuleLlvm {
         dcx: DiagCtxtHandle<'_>,
     ) -> Self {
         unsafe {
-            let llcx = llvm::LLVMContextCreate();
-            llvm::LLVMContextSetDiscardValueNames(llcx, cgcx.fewer_names.to_llvm_bool());
-            let llmod_raw = back::lto::parse_module(llcx, name, buffer, dcx);
+            let llcx_raw = create_context_and_set_fewer_names(cgcx.fewer_names);
+            let llmod_raw = back::lto::parse_module(llcx_raw.as_ref(), name, buffer, dcx);
             let tm = tm_factory(dcx, TargetMachineFactoryConfig::new(cgcx, name.to_str().unwrap()));
 
-            ModuleLlvm { llmod_raw, llcx, tm: ManuallyDrop::new(tm) }
+            ModuleLlvm {
+                llmod_raw,
+                llcx_raw,
+                tm: ManuallyDrop::new(tm),
+                thin_lto_buffer: OnceLock::new(),
+            }
         }
     }
 
-    pub(crate) fn llmod(&self) -> &llvm::Module {
-        unsafe { &*self.llmod_raw }
+    /// Passes a [`ModuleRefs`] struct to a callback function, giving it scoped
+    /// access to the resources owned by this module.
+    ///
+    /// Passing the references to a callback ensures that they have coherent
+    /// `'ll` lifetimes, and that they can't escape the callback.
+    pub(crate) fn with_module_refs<R>(
+        &self,
+        inner_fn: impl for<'ll> FnOnce(ModuleRefs<'ll>) -> R,
+    ) -> R {
+        inner_fn(ModuleRefs {
+            llcx: unsafe { self.llcx_raw.as_ref() },
+            llmod: unsafe { &*self.llmod_raw },
+            tm: self.tm.raw(),
+            _ph: PhantomData,
+        })
     }
 }
 
 impl Drop for ModuleLlvm {
     fn drop(&mut self) {
         unsafe {
             ManuallyDrop::drop(&mut self.tm);
-            llvm::LLVMContextDispose(&mut *(self.llcx as *mut _));
+            llvm::LLVMContextDispose(self.llcx_raw);
         }
     }
 }
+
+/// Bundle of references provided by [`ModuleLlvm::with_module_refs`].
+#[derive(Clone, Copy)]
+pub(crate) struct ModuleRefs<'ll> {
+    pub(crate) llcx: &'ll llvm::Context,
+    pub(crate) llmod: &'ll llvm::Module,
+    pub(crate) tm: &'ll llvm::TargetMachine,
+    /// Make sure `'ll` is invariant, even if no fields happen to require that.
+    ///
+    /// FIXME(Zalathar): Consider using `PhantomInvariantLifetime` when the API
+    /// for that is settled.
+    _ph: PhantomData<fn(&'ll ()) -> &'ll ()>,
+}