Update Rust toolchain to nightly-2025-06-23

Author: LegNeato

crates/cust/src/function.rs

@@ -213,7 +213,7 @@ unsafe impl Send for Function<'_> {}
 unsafe impl Sync for Function<'_> {}
 
 impl Function<'_> {
-    pub(crate) fn new(inner: CUfunction, _module: &Module) -> Function {
+    pub(crate) fn new(inner: CUfunction, _module: &Module) -> Function<'_> {
         Function {
             inner,
             module: PhantomData,

crates/rustc_codegen_nvvm/src/abi.rs

@@ -2,6 +2,7 @@ use std::cmp;
 
 use libc::c_uint;
 use rustc_abi::BackendRepr::Scalar;
+use rustc_abi::CanonAbi;
 use rustc_abi::Size;
 use rustc_abi::{HasDataLayout, Primitive, Reg, RegKind};
 use rustc_codegen_ssa::mir::operand::OperandRef;
@@ -13,7 +14,7 @@ use rustc_middle::ty::layout::LayoutOf;
 pub use rustc_middle::ty::layout::{WIDE_PTR_ADDR, WIDE_PTR_EXTRA};
 use rustc_middle::ty::{Ty, TyCtxt, TyKind};
 use rustc_target::callconv::{
-    ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, CastTarget, Conv, FnAbi, PassMode,
+    ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, CastTarget, FnAbi, PassMode,
 };
 use tracing::trace;
 
@@ -28,7 +29,7 @@ pub(crate) fn readjust_fn_abi<'tcx>(
     fn_abi: &'tcx FnAbi<'tcx, Ty<'tcx>>,
 ) -> &'tcx FnAbi<'tcx, Ty<'tcx>> {
     // dont override anything in the rust abi for now
-    if fn_abi.conv == Conv::Rust {
+    if fn_abi.conv == CanonAbi::Rust {
         return fn_abi;
     }
     let readjust_arg_abi = |arg: &ArgAbi<'tcx, Ty<'tcx>>| {
@@ -260,9 +261,6 @@ impl<'ll, 'tcx> ArgAbiBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     ) {
         arg_abi.store(self, val, dst)
     }
-    fn arg_memory_ty(&self, arg_abi: &ArgAbi<'tcx, Ty<'tcx>>) -> &'ll Type {
-        arg_abi.memory_ty(self)
-    }
 }
 
 pub(crate) trait FnAbiLlvmExt<'ll, 'tcx> {
@@ -541,7 +539,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
     }
 }
 
-impl<'tcx> AbiBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
+impl<'tcx> AbiBuilderMethods for Builder<'_, '_, 'tcx> {
     fn get_param(&mut self, index: usize) -> Self::Value {
         let val = llvm::get_param(self.llfn(), index as c_uint);
         // trace!("Get param `{:?}`", val);
@@ -551,7 +549,7 @@ impl<'tcx> AbiBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
             // destructure so rustc doesnt complain in the call to transmute_llval
             let Self { cx, llbuilder } = self;
             let map = cx.remapped_integer_args.borrow();
-            if let Some((_, key)) = map.get(llfnty) {
+            if let Some((_, key)) = map.get(&llfnty) {
                 if let Some((_, new_ty)) = key.iter().find(|t| t.0 == index) {
                     trace!("Casting irregular param {:?} to {:?}", val, new_ty);
                     return transmute_llval(llbuilder, cx, val, new_ty);

crates/rustc_codegen_nvvm/src/asm.rs

@@ -224,7 +224,7 @@ impl<'tcx> AsmBuilderMethods<'tcx> for Builder<'_, '_, 'tcx> {
 
 impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
     fn codegen_global_asm(
-        &self,
+        &mut self,
         template: &[InlineAsmTemplatePiece],
         operands: &[GlobalAsmOperandRef],
         _options: InlineAsmOptions,

crates/rustc_codegen_nvvm/src/attributes.rs

@@ -1,8 +1,8 @@
 use crate::llvm::{self, AttributePlace::*, Value};
 use rustc_ast::{LitKind, MetaItemInner, MetaItemLit};
-use rustc_attr_parsing::{InlineAttr, OptimizeAttr};
+use rustc_attr_data_structures::{InlineAttr, OptimizeAttr};
 use rustc_hir::Attribute;
-use rustc_middle::{bug, middle::codegen_fn_attrs::CodegenFnAttrFlags, ty};
+use rustc_middle::{middle::codegen_fn_attrs::CodegenFnAttrFlags, ty};
 use rustc_session::{Session, config::OptLevel};
 use rustc_span::{Symbol, sym};
 
@@ -16,7 +16,7 @@ fn inline(val: &'_ Value, inline: InlineAttr) {
         Always => llvm::Attribute::AlwaysInline.apply_llfn(Function, val),
         Never => llvm::Attribute::NoInline.apply_llfn(Function, val),
         None => {}
-        Force { .. } => bug!("Force inline should have been inlined away by now"), // TODO: Verify this
+        Force { .. } => llvm::Attribute::AlwaysInline.apply_llfn(Function, val),
     }
 }
 

crates/rustc_codegen_nvvm/src/back.rs

@@ -176,11 +176,11 @@ pub(crate) unsafe fn codegen(
 
     let llmod = unsafe { module.module_llvm.llmod.as_ref().unwrap() };
     let mod_name = module.name.clone();
-    let module_name = Some(&mod_name[..]);
+    let module_name = &mod_name[..];
 
     let out = cgcx
         .output_filenames
-        .temp_path(OutputType::Object, module_name);
+        .temp_path_for_cgu(OutputType::Object, module_name, None);
 
     // nvvm ir *is* llvm ir so emit_ir fits the expectation of llvm ir which is why we
     // implement this. this is copy and pasted straight from rustc_codegen_llvm
@@ -189,9 +189,9 @@ pub(crate) unsafe fn codegen(
         let _timer = cgcx
             .prof
             .generic_activity_with_arg("NVVM_module_codegen_emit_ir", &module.name[..]);
-        let out = cgcx
-            .output_filenames
-            .temp_path(OutputType::LlvmAssembly, module_name);
+        let out =
+            cgcx.output_filenames
+                .temp_path_for_cgu(OutputType::LlvmAssembly, module_name, None);
         let out = out.to_str().unwrap();
 
         let result = unsafe {
@@ -229,6 +229,7 @@ pub(crate) unsafe fn codegen(
         bytecode: None,
         assembly: None,
         llvm_ir: None,
+        links_from_incr_cache: vec![],
     })
 }
 
@@ -254,7 +255,7 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol) -> (ModuleCodegen
         // Instantiate monomorphizations without filling out definitions yet...
         let llvm_module = LlvmMod::new(cgu_name.as_str());
         {
-            let cx = CodegenCx::new(tcx, cgu, &llvm_module);
+            let mut cx = CodegenCx::new(tcx, cgu, &llvm_module);
 
             let mono_items = cx.codegen_unit.items_in_deterministic_order(cx.tcx);
 
@@ -267,22 +268,27 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol) -> (ModuleCodegen
                 },
             ) in &mono_items
             {
-                mono_item.predefine::<Builder<'_, '_, '_>>(&cx, linkage, visibility);
+                mono_item.predefine::<Builder<'_, '_, '_>>(
+                    &mut cx,
+                    "mono_item",
+                    linkage,
+                    visibility,
+                );
             }
 
             // ... and now that we have everything pre-defined, fill out those definitions.
-            for &(mono_item, _) in &mono_items {
+            for &(mono_item, mono_item_data) in &mono_items {
                 if let MonoItem::Fn(func) = mono_item {
-                    define_or_override_fn(func, &cx);
+                    define_or_override_fn(func, &mut cx);
                 } else {
-                    mono_item.define::<Builder<'_, '_, '_>>(&cx);
+                    mono_item.define::<Builder<'_, '_, '_>>(&mut cx, "mono_item", mono_item_data);
                 }
             }
 
             // a main function for gpu kernels really makes no sense but
             // codegen it anyways.
             // sanitize attrs are not allowed in nvvm so do nothing further.
-            maybe_create_entry_wrapper::<Builder<'_, '_, '_>>(&cx);
+            maybe_create_entry_wrapper::<Builder<'_, '_, '_>>(&mut cx, cgu);
 
             // Run replace-all-uses-with for statics that need it
             for &(old_g, new_g) in cx.statics_to_rauw.borrow().iter() {
@@ -333,13 +339,8 @@ pub(crate) unsafe fn optimize(
 
     let llmod = unsafe { &*module.module_llvm.llmod };
 
-    let module_name = module.name.clone();
-    let module_name = Some(&module_name[..]);
-
     if config.emit_no_opt_bc {
-        let out = cgcx
-            .output_filenames
-            .temp_path_ext("no-opt.bc", module_name);
+        let out = cgcx.output_filenames.with_extension("no-opt.bc");
         let out = path_to_c_string(&out);
         unsafe { llvm::LLVMWriteBitcodeToFile(llmod, out.as_ptr()) };
     }

crates/rustc_codegen_nvvm/src/builder.rs

@@ -6,14 +6,15 @@ use libc::{c_char, c_uint};
 use rustc_abi as abi;
 use rustc_abi::{AddressSpace, Align, HasDataLayout, Size, TargetDataLayout, WrappingRange};
 use rustc_codegen_ssa::MemFlags;
-use rustc_codegen_ssa::common::{AtomicOrdering, IntPredicate, RealPredicate, TypeKind};
+use rustc_codegen_ssa::common::{IntPredicate, RealPredicate, TypeKind};
 use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::*;
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_hir::def_id::DefId;
 use rustc_middle::bug;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
+use rustc_middle::ty::AtomicOrdering;
 use rustc_middle::ty::layout::{
     FnAbiError, FnAbiOfHelpers, FnAbiRequest, HasTypingEnv, LayoutError, LayoutOfHelpers,
     TyAndLayout,
@@ -704,7 +705,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         &mut self,
         _val: &'ll Value,
         ptr: &'ll Value,
-        _order: rustc_codegen_ssa::common::AtomicOrdering,
+        _order: AtomicOrdering,
         _size: Size,
     ) {
         // see comment in atomic_load
@@ -1042,8 +1043,8 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         _dst: &'ll Value,
         _cmp: &'ll Value,
         _src: &'ll Value,
-        _order: rustc_codegen_ssa::common::AtomicOrdering,
-        _failure_order: rustc_codegen_ssa::common::AtomicOrdering,
+        _order: AtomicOrdering,
+        _failure_order: AtomicOrdering,
         _weak: bool,
     ) -> (&'ll Value, &'ll Value) {
         // allowed but only for some things and with restrictions
@@ -1055,15 +1056,15 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         _op: rustc_codegen_ssa::common::AtomicRmwBinOp,
         _dst: &'ll Value,
         _src: &'ll Value,
-        _order: rustc_codegen_ssa::common::AtomicOrdering,
+        _order: AtomicOrdering,
     ) -> &'ll Value {
         // see cmpxchg comment
         self.fatal("atomic rmw is not supported")
     }
 
     fn atomic_fence(
         &mut self,
-        _order: rustc_codegen_ssa::common::AtomicOrdering,
+        _order: AtomicOrdering,
         _scope: rustc_codegen_ssa::common::SynchronizationScope,
     ) {
         self.fatal("atomic fence is not supported, use cuda_std intrinsics instead")
@@ -1120,7 +1121,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         while self.cx.type_kind(fn_ty) == TypeKind::Pointer {
             fn_ty = self.cx.element_type(fn_ty);
         }
-        if let Some((Some(ret_ty), _)) = map.get(fn_ty) {
+        if let Some((Some(ret_ty), _)) = map.get(&fn_ty) {
             self.cx.last_call_llfn.set(Some(call));
             call = transmute_llval(self.llbuilder, self.cx, call, ret_ty);
         }

crates/rustc_codegen_nvvm/src/const_ty.rs

@@ -14,7 +14,7 @@ use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar};
 use rustc_middle::ty::layout::LayoutOf;
 use tracing::trace;
 
-impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
+impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
     fn const_data_from_alloc(&self, alloc: ConstAllocation) -> &'ll Value {
         const_alloc_to_llvm(self, alloc, /*static*/ false)
     }
@@ -82,8 +82,7 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         let val = *self
             .const_cstr_cache
             .borrow_mut()
-            .raw_entry_mut()
-            .from_key(s)
+            .entry(s.to_string())
             .or_insert_with(|| {
                 let sc = self.const_bytes(s.as_bytes());
                 let sym = self.generate_local_symbol_name("str");
@@ -97,9 +96,8 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                     llvm::LLVMSetGlobalConstant(g, True);
                     llvm::LLVMRustSetLinkage(g, llvm::Linkage::InternalLinkage);
                 }
-                (s.to_owned(), g)
-            })
-            .1;
+                g
+            });
         let len = s.len();
         let ty = self.type_ptr_to(self.layout_of(self.tcx.types.str_).llvm_type(self));
         let cs = unsafe { llvm::LLVMConstPointerCast(val, ty) };
@@ -247,10 +245,6 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         val
     }
 
-    fn is_undef(&self, v: Self::Value) -> bool {
-        unsafe { llvm::LLVMIsUndef(v) == True }
-    }
-
     fn const_poison(&self, t: Self::Type) -> Self::Value {
         // FIXME: Use LLVMGetPoision when possible.
         self.const_undef(t)

crates/rustc_codegen_nvvm/src/consts.rs

@@ -336,7 +336,7 @@ impl<'ll> StaticCodegenMethods for CodegenCx<'ll, '_> {
         gv
     }
 
-    fn codegen_static(&self, def_id: DefId) {
+    fn codegen_static(&mut self, def_id: DefId) {
         unsafe {
             assert!(
                 llvm::LLVMGetInitializer(
@@ -422,23 +422,36 @@ impl<'ll> StaticCodegenMethods for CodegenCx<'ll, '_> {
                 self.unsupported("thread locals");
             }
 
-            if attrs.flags.contains(CodegenFnAttrFlags::USED) {
+            if attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER) {
+                // `USED` and `USED_LINKER` can't be used together.
+                assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER));
+
+                // The semantics of #[used] in Rust only require the symbol to make it into the
+                // object file. It is explicitly allowed for the linker to strip the symbol if it
+                // is dead, which means we are allowed to use `llvm.compiler.used` instead of
+                // `llvm.used` here.
+                //
+                // Additionally, https://reviews.llvm.org/D97448 in LLVM 13 started emitting unique
+                // sections with SHF_GNU_RETAIN flag for llvm.used symbols, which may trigger bugs
+                // in the handling of `.init_array` (the static constructor list) in versions of
+                // the gold linker (prior to the one released with binutils 2.36).
+                //
+                // That said, we only ever emit these when `#[used(compiler)]` is explicitly
+                // requested. This is to avoid similar breakage on other targets, in particular
+                // MachO targets have *their* static constructor lists broken if `llvm.compiler.used`
+                // is emitted rather than `llvm.used`. However, that check happens when assigning
+                // the `CodegenFnAttrFlags` in the `codegen_fn_attrs` query, so we don't need to
+                // take care of it here.
+                self.add_compiler_used_global(g);
+            }
+            if attrs.flags.contains(CodegenFnAttrFlags::USED_LINKER) {
+                // `USED` and `USED_LINKER` can't be used together.
+                assert!(!attrs.flags.contains(CodegenFnAttrFlags::USED_COMPILER));
+
                 self.add_used_global(g);
             }
+
             trace!("Codegen static `{:?}`", g);
         }
     }
-
-    /// Add a global value to a list to be stored in the `llvm.used` variable, an array of i8*.
-    fn add_used_global(&self, global: &'ll Value) {
-        let cast = unsafe { llvm::LLVMConstPointerCast(global, self.type_i8p()) };
-        self.used_statics.borrow_mut().push(cast);
-    }
-
-    /// Add a global value to a list to be stored in the `llvm.compiler.used` variable,
-    /// an array of i8*.
-    fn add_compiler_used_global(&self, global: &'ll Value) {
-        let cast = unsafe { llvm::LLVMConstPointerCast(global, self.type_i8p()) };
-        self.compiler_used_statics.borrow_mut().push(cast);
-    }
 }

crates/rustc_codegen_nvvm/src/context.rs

@@ -232,10 +232,6 @@ impl<'ll, 'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         self.tcx.sess
     }
 
-    fn codegen_unit(&self) -> &'tcx CodegenUnit<'tcx> {
-        self.codegen_unit
-    }
-
     fn declare_c_main(
         &self,
         _fn_type: <CodegenCx<'ll, 'tcx> as rustc_codegen_ssa::traits::BackendTypes>::Type,
@@ -541,6 +537,19 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
 
         llfn
     }
+
+    /// Add a global value to a list to be stored in the `llvm.used` variable, an array of i8*.
+    pub fn add_used_global(&self, global: &'ll Value) {
+        let cast = unsafe { llvm::LLVMConstPointerCast(global, self.type_i8p()) };
+        self.used_statics.borrow_mut().push(cast);
+    }
+
+    /// Add a global value to a list to be stored in the `llvm.compiler.used` variable,
+    /// an array of i8*.
+    pub fn add_compiler_used_global(&self, global: &'ll Value) {
+        let cast = unsafe { llvm::LLVMConstPointerCast(global, self.type_i8p()) };
+        self.compiler_used_statics.borrow_mut().push(cast);
+    }
 }
 
 #[derive(Default, Clone)]

crates/rustc_codegen_nvvm/src/debug_info/metadata.rs

@@ -814,7 +814,8 @@ pub(crate) fn build_compile_unit_di_node<'ll, 'tcx>(
         && let Some(f) = output_filenames.split_dwarf_path(
             tcx.sess.split_debuginfo(),
             tcx.sess.opts.unstable_opts.split_dwarf_kind,
-            Some(codegen_unit_name),
+            codegen_unit_name,
+            None,
         ) {
         // We get a path relative to the working directory from split_dwarf_path
         Some(tcx.sess.source_map().path_mapping().to_real_filename(f))