Update to nightly-2025-07-28.

- Need to create `dcx` in `back::codegen` instead of passing it in.
- LTO changes from rust-lang/rust PR 143388 and PR 144062:
  - `run_fat_lto`, `optimize_fat`, and `autodiff` were merged into
    `run_and_optimize_fat_lto`, and the parameters were changed.
  - `run_thin_lto` parameters were changed.
  - `codegen` parameters were changed.
  - `LtoModuleCodegen` was removed.
- Some `TypeMembershipCodegenMethods` methods changed arguments from
  `String` to `&[u8]`.
- Need to update `target_feature_base_cc.stderr` for an innocuous
  looking DWARF `.loc` entry change.

Author: nnethercote

crates/rustc_codegen_nvvm/src/back.rs

@@ -157,10 +157,12 @@ pub extern "C" fn demangle_callback(
 /// Compile a single module (in an nvvm context this means getting the llvm bitcode out of it)
 pub(crate) unsafe fn codegen(
     cgcx: &CodegenContext<NvvmCodegenBackend>,
-    dcx: DiagCtxtHandle<'_>,
     module: ModuleCodegen<LlvmMod>,
     config: &ModuleConfig,
 ) -> Result<CompiledModule, FatalError> {
+    let dcx = cgcx.create_dcx();
+    let dcx = dcx.handle();
+
     // For NVVM, all the codegen we need to do is turn the llvm modules
     // into llvm bitcode and write them to a tempdir. nvvm expects llvm
     // bitcode as the modules to be added to the program. Then as the last step

crates/rustc_codegen_nvvm/src/lib.rs

@@ -63,7 +63,7 @@ use rustc_ast::expand::autodiff_attrs::AutoDiffItem;
 use rustc_codegen_ssa::{
     CodegenResults, CompiledModule, ModuleCodegen, TargetConfig,
     back::{
-        lto::{LtoModuleCodegen, SerializedModule, ThinModule},
+        lto::{SerializedModule, ThinModule},
         write::{CodegenContext, FatLtoInput, ModuleConfig, OngoingCodegen},
     },
     traits::{CodegenBackend, ExtraBackendMethods, WriteBackendMethods},
@@ -83,6 +83,7 @@ use rustc_session::{
 use tracing::debug;
 
 use std::ffi::CString;
+use std::path::PathBuf;
 
 // codegen dylib entrypoint
 #[unsafe(no_mangle)]
@@ -275,19 +276,25 @@ impl WriteBackendMethods for NvvmCodegenBackend {
         todo!();
     }
 
-    fn run_fat_lto(
-        _: &CodegenContext<Self>,
-        _: Vec<FatLtoInput<Self>>,
-        _: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<LtoModuleCodegen<Self>, FatalError> {
+    fn run_and_optimize_fat_lto(
+        _cgcx: &CodegenContext<Self>,
+        _exported_symbols_for_lto: &[String],
+        _each_linked_rlib_for_lto: &[PathBuf],
+        _modules: Vec<FatLtoInput<Self>>,
+        _diff_fncs: Vec<AutoDiffItem>,
+    ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
         todo!()
     }
 
     fn run_thin_lto(
         cgcx: &CodegenContext<Self>,
+        // FIXME: Limit LTO exports to these symbols
+        _exported_symbols_for_lto: &[String],
+        // FIXME: handle these? but only relevant for non-thin LTO?
+        _each_linked_rlib_for_lto: &[PathBuf],
         modules: Vec<(String, Self::ThinBuffer)>,
         cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
-    ) -> Result<(Vec<LtoModuleCodegen<Self>>, Vec<WorkProduct>), FatalError> {
+    ) -> Result<(Vec<ThinModule<Self>>, Vec<WorkProduct>), FatalError> {
         lto::run_thin(cgcx, modules, cached_modules)
     }
 
@@ -317,11 +324,10 @@ impl WriteBackendMethods for NvvmCodegenBackend {
 
     fn codegen(
         cgcx: &CodegenContext<Self>,
-        diag_handler: DiagCtxtHandle<'_>,
         module: ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) -> Result<CompiledModule, FatalError> {
-        unsafe { back::codegen(cgcx, diag_handler, module, config) }
+        unsafe { back::codegen(cgcx, module, config) }
     }
 
     fn prepare_thin(
@@ -346,22 +352,6 @@ impl WriteBackendMethods for NvvmCodegenBackend {
             )
         }
     }
-
-    fn optimize_fat(
-        _cgcx: &CodegenContext<Self>,
-        _llmod: &mut ModuleCodegen<Self::Module>,
-    ) -> Result<(), FatalError> {
-        todo!()
-    }
-
-    fn autodiff(
-        _cgcx: &CodegenContext<Self>,
-        _module: &ModuleCodegen<Self::Module>,
-        _diff_fncs: Vec<AutoDiffItem>,
-        _config: &ModuleConfig,
-    ) -> Result<(), FatalError> {
-        todo!()
-    }
 }
 
 impl ExtraBackendMethods for NvvmCodegenBackend {

crates/rustc_codegen_nvvm/src/lto.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 use rustc_codegen_ssa::{
     ModuleCodegen,
     back::{
-        lto::{LtoModuleCodegen, SerializedModule, ThinModule, ThinShared},
+        lto::{SerializedModule, ThinModule, ThinShared},
         write::CodegenContext,
     },
     traits::{ModuleBufferMethods, ThinBufferMethods},
@@ -106,7 +106,7 @@ pub(crate) fn run_thin(
     _cgcx: &CodegenContext<NvvmCodegenBackend>,
     modules: Vec<(String, ThinBuffer)>,
     cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
-) -> Result<(Vec<LtoModuleCodegen<NvvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
+) -> Result<(Vec<ThinModule<NvvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
     debug!("Running thin LTO");
     let mut thin_buffers = Vec::with_capacity(modules.len());
     let mut module_names = Vec::with_capacity(modules.len() + cached_modules.len());
@@ -142,10 +142,10 @@ pub(crate) fn run_thin(
 
     let mut opt_jobs = vec![];
     for (module_index, _) in shared.module_names.iter().enumerate() {
-        opt_jobs.push(LtoModuleCodegen::Thin(ThinModule {
+        opt_jobs.push(ThinModule {
             shared: shared.clone(),
             idx: module_index,
-        }));
+        });
     }
 
     Ok((opt_jobs, vec![]))

crates/rustc_codegen_nvvm/src/ty.rs

@@ -651,11 +651,11 @@ impl<'tcx> CodegenCx<'_, 'tcx> {
 }
 
 impl<'tcx> TypeMembershipCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
-    fn add_type_metadata(&self, _function: Self::Function, _typeid: String) {}
+    fn add_type_metadata(&self, _function: Self::Function, _typeid: &[u8]) {}
 
-    fn set_type_metadata(&self, _function: Self::Function, _typeid: String) {}
+    fn set_type_metadata(&self, _function: Self::Function, _typeid: &[u8]) {}
 
-    fn typeid_metadata(&self, _typeid: String) -> Option<Self::Metadata> {
+    fn typeid_metadata(&self, _typeid: &[u8]) -> Option<Self::Metadata> {
         None
     }
 

rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2025-07-14"
+channel = "nightly-2025-07-28"
 components = ["clippy", "llvm-tools-preview", "rust-src", "rustc-dev", "rustfmt", "rust-analyzer"]

tests/compiletests/ui/dis/target_feature_base_cc.stderr

@@ -17,7 +17,7 @@ $L__tmp1:
     .loc    1 38 5
     bra.uni    $L__tmp2;
 $L__tmp2:
-    .loc    2 2180 9
+    .loc    2 2198 9
     mov.u32     %r1, 1124204544;
     st.volatile.global.u32     [%rd2], %r1;
 $L__tmp3: