update to nightly-2026-07-03, rustc 1.98.0

Author: Firestar99

crates/rustc_codegen_spirv/build.rs

@@ -19,9 +19,9 @@ use std::{env, fs, mem};
 /// `cargo publish`. We need to figure out a way to do this properly, but let's hardcode it for now :/
 //const REQUIRED_RUST_TOOLCHAIN: &str = include_str!("../../rust-toolchain.toml");
 const REQUIRED_RUST_TOOLCHAIN: &str = r#"[toolchain]
-channel = "nightly-2026-06-25"
+channel = "nightly-2026-07-03"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = f28ac764c36004fa6a6e098d15b4016a838c13c6"#;
+# commit_hash = c397dae808f70caebab1fc4e11b3edf7e59f58c7"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
@@ -272,7 +272,7 @@ pub(super) fn elf_e_flags(architecture: Architecture, sess: &Session) -> u32 {",
                             bx, llarg, arg.layout,
                         ));",
                 );
-                src = src.replace("fx.fill_function_debug_context();", "");
+                src = src.replace("fx.fill_function_debug_context(&mut start_bx);", "");
             }
             if relative_path == Path::new("src/mir/block.rs") {
                 src = src.replace(

crates/rustc_codegen_spirv/src/abi.rs

@@ -402,7 +402,10 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
                 // Note: We can't use auto_struct_layout here because the spirv types here might be undefined due to
                 // recursive pointer types.
                 let a_offset = Size::ZERO;
-                let b_offset = a.primitive().size(cx).align_to(b.primitive().align(cx).abi);
+                let b_offset = a
+                    .primitive()
+                    .size(cx)
+                    .align_to(b.primitive().default_align(cx).abi);
                 let a = trans_scalar(cx, span, *self, a, a_offset);
                 let b = trans_scalar(cx, span, *self, b, b_offset);
                 let size = if self.is_unsized() {
@@ -471,7 +474,10 @@ pub fn scalar_pair_element_backend_type<'tcx>(
     };
     let offset = match index {
         0 => Size::ZERO,
-        1 => a.primitive().size(cx).align_to(b.primitive().align(cx).abi),
+        1 => a
+            .primitive()
+            .size(cx)
+            .align_to(b.primitive().default_align(cx).abi),
         _ => unreachable!(),
     };
     trans_scalar(cx, span, ty, [a, b][index], offset)

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -1854,7 +1854,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         self.bitcast(loaded_val, ty)
     }
 
-    fn volatile_load(&mut self, ty: Self::Type, ptr: Self::Value) -> Self::Value {
+    fn volatile_load(&mut self, ty: Self::Type, ptr: Self::Value, _align: Align) -> Self::Value {
         // TODO: Implement this
         let result = self.load(ty, ptr, Align::from_bytes(0).unwrap());
         self.zombie(result.def(self), "volatile load is not supported yet");
@@ -1909,7 +1909,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
             let b_offset = a
                 .primitive()
                 .size(self)
-                .align_to(b.primitive().align(self).abi);
+                .align_to(b.primitive().default_align(self).abi);
 
             let mut load = |i, scalar: Scalar, align| {
                 let llptr = if i == 0 {
@@ -3485,4 +3485,8 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
     fn alloca_with_ty(&mut self, _layout: TyAndLayout<'tcx>) -> Self::Value {
         bug!("scalable alloca is not supported in SPIR-V backend")
     }
+
+    fn vscale(&mut self, _ty: Self::Type) -> Self::Value {
+        self.fatal("scalable vectors not supported");
+    }
 }

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -9,6 +9,7 @@ use crate::custom_insts::CustomInst;
 use crate::spirv_type::SpirvType;
 use rspirv::dr::Operand;
 use rspirv::spirv::GlslStd450Op as GLOp;
+use rustc_abi::Align;
 use rustc_codegen_ssa::RetagInfo;
 use rustc_codegen_ssa::mir::IntrinsicResult;
 use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
@@ -107,7 +108,8 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
             sym::volatile_load | sym::unaligned_volatile_load => {
                 let ptr = args[0].immediate();
                 let layout = self.layout_of(fn_args.type_at(0));
-                let load = self.volatile_load(layout.spirv_type(self.span(), self), ptr);
+                let load =
+                    self.volatile_load(layout.spirv_type(self.span(), self), ptr, Align::ONE);
                 if !result.layout.is_zst() {
                     self.store(load, result.val.llval, result.val.align);
                 }

crates/rustc_codegen_spirv/src/builder/mod.rs

@@ -7,7 +7,7 @@ pub mod libm_intrinsics;
 mod spirv_asm;
 
 pub use ext_inst::ExtInst;
-use rustc_span::DUMMY_SP;
+use rustc_span::{BytePos, DUMMY_SP, SourceFile, Symbol};
 pub use spirv_asm::InstructionTable;
 
 // HACK(eddyb) avoids rewriting all of the imports (see `lib.rs` and `build.rs`).
@@ -208,6 +208,54 @@ impl<'a, 'tcx> DebugInfoBuilderMethods<'_> for Builder<'a, 'tcx> {
         _fragment: &Option<Range<Size>>,
     ) {
     }
+
+    fn dbg_scope_fn(
+        &mut self,
+        _instance: Instance<'_>,
+        _fn_abi: &FnAbi<'_, Ty<'_>>,
+        _maybe_definition_llfn: Option<Self::Function>,
+    ) -> Self::DIScope {
+    }
+
+    fn dbg_create_lexical_block(
+        &mut self,
+        _pos: BytePos,
+        _parent_scope: Self::DIScope,
+    ) -> Self::DIScope {
+    }
+
+    fn dbg_location_clone_with_discriminator(
+        &mut self,
+        _loc: Self::DILocation,
+        _discriminator: u32,
+    ) -> Option<Self::DILocation> {
+        None
+    }
+
+    fn dbg_loc(
+        &mut self,
+        _scope: Self::DIScope,
+        _inlined_at: Option<Self::DILocation>,
+        _span: Span,
+    ) -> Self::DILocation {
+    }
+
+    fn extend_scope_to_file(
+        &mut self,
+        _scope_metadata: Self::DIScope,
+        _file: &SourceFile,
+    ) -> Self::DIScope {
+    }
+
+    fn create_dbg_var(
+        &mut self,
+        _variable_name: Symbol,
+        _variable_type: Ty<'_>,
+        _scope_metadata: Self::DIScope,
+        _variable_kind: rustc_codegen_ssa::mir::debuginfo::VariableKind,
+        _span: Span,
+    ) -> Self::DIVariable {
+    }
 }
 
 impl<'a, 'tcx> ArgAbiBuilderMethods<'tcx> for Builder<'a, 'tcx> {

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -8,7 +8,9 @@ use crate::spirv_type::SpirvType;
 use itertools::Itertools as _;
 use rspirv::spirv::Word;
 use rustc_abi::{self as abi, AddressSpace, Float, HasDataLayout, Integer, Primitive, Size};
-use rustc_codegen_ssa::traits::{ConstCodegenMethods, MiscCodegenMethods, StaticCodegenMethods};
+use rustc_codegen_ssa::traits::{
+    ConstCodegenMethods, MiscCodegenMethods, PacMetadata, StaticCodegenMethods,
+};
 use rustc_middle::mir::interpret::{AllocError, ConstAllocation, GlobalAlloc, Scalar, alloc_range};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_span::{DUMMY_SP, Span};
@@ -226,6 +228,16 @@ impl ConstCodegenMethods for CodegenCx<'_> {
         self.builder.lookup_const_scalar(v)
     }
 
+    fn scalar_to_backend_with_pac(
+        &self,
+        cv: Scalar,
+        layout: rustc_abi::Scalar,
+        ty: Self::Type,
+        _pac: Option<PacMetadata>,
+    ) -> Self::Value {
+        self.scalar_to_backend(cv, layout, ty)
+    }
+
     fn scalar_to_backend(
         &self,
         scalar: Scalar,
@@ -268,7 +280,7 @@ impl ConstCodegenMethods for CodegenCx<'_> {
                         (value, AddressSpace::ZERO)
                     }
                     GlobalAlloc::Function { instance } => (
-                        self.get_fn_addr(instance),
+                        self.get_fn_addr(instance, None),
                         self.data_layout().instruction_address_space,
                     ),
                     GlobalAlloc::VTable(vty, dyn_ty) => {

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -191,7 +191,7 @@ impl<'tcx> CodegenCx<'tcx> {
             self.get_fn(entry_instance).ty,
             None,
             Some(entry_fn_abi),
-            self.get_fn_addr(entry_instance),
+            self.get_fn_addr(entry_instance, None),
             &call_args,
             None,
             None,

crates/rustc_codegen_spirv/src/codegen_cx/mod.rs

@@ -20,10 +20,9 @@ use rspirv::dr::{Module, Operand};
 use rspirv::spirv::{Decoration, LinkageType, Word};
 use rustc_abi::{AddressSpace, HasDataLayout, TargetDataLayout};
 use rustc_ast::ast::{InlineAsmOptions, InlineAsmTemplatePiece};
-use rustc_codegen_ssa::mir::debuginfo::VariableKind;
 use rustc_codegen_ssa::traits::{
     AsmCodegenMethods, BackendTypes, DebugInfoCodegenMethods, GlobalAsmOperandRef,
-    MiscCodegenMethods,
+    MiscCodegenMethods, PacMetadata,
 };
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def_id::DefId;
@@ -32,8 +31,7 @@ use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv};
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypingEnv};
 use rustc_session::Session;
 use rustc_span::symbol::Symbol;
-use rustc_span::{BytePos, DUMMY_SP, SourceFile, Span};
-use rustc_target::callconv::FnAbi;
+use rustc_span::{DUMMY_SP, Span};
 use rustc_target::spec::{HasTargetSpec, Target, TargetTuple};
 use std::cell::RefCell;
 use std::collections::BTreeSet;
@@ -889,7 +887,7 @@ impl<'tcx> MiscCodegenMethods<'tcx> for CodegenCx<'tcx> {
     // NOTE(eddyb) see the comment on `SpirvValueKind::FnAddr`, this should
     // be fixed upstream, so we never see any "function pointer" values being
     // created just to perform direct calls.
-    fn get_fn_addr(&self, instance: Instance<'tcx>) -> Self::Value {
+    fn get_fn_addr(&self, instance: Instance<'tcx>, _pac: Option<PacMetadata>) -> Self::Value {
         let function = self.get_fn(instance);
         let span = self.tcx.def_span(instance.def_id());
 
@@ -944,50 +942,6 @@ impl<'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'tcx> {
     ) {
         // Ignore.
     }
-
-    fn dbg_create_lexical_block(
-        &self,
-        _pos: BytePos,
-        _parent_scope: Self::DIScope,
-    ) -> Self::DIScope {
-    }
-
-    fn dbg_location_clone_with_discriminator(
-        &self,
-        _loc: Self::DILocation,
-        _discriminator: u32,
-    ) -> Option<Self::DILocation> {
-        None
-    }
-
-    fn dbg_scope_fn(
-        &self,
-        _: Instance<'tcx>,
-        _: &FnAbi<'tcx, Ty<'tcx>>,
-        _: Option<Self::Function>,
-    ) -> Self::DIScope {
-    }
-
-    fn dbg_loc(&self, _: Self::DIScope, _: Option<Self::DILocation>, _: Span) -> Self::DILocation {}
-
-    fn extend_scope_to_file(
-        &self,
-        _scope_metadata: Self::DIScope,
-        _file: &SourceFile,
-    ) -> Self::DIScope {
-    }
-
-    fn debuginfo_finalize(&self) {}
-
-    fn create_dbg_var(
-        &self,
-        _variable_name: Symbol,
-        _variable_type: Ty<'tcx>,
-        _scope_metadata: Self::DIScope,
-        _variable_kind: VariableKind,
-        _span: Span,
-    ) -> Self::DIVariable {
-    }
 }
 
 impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'tcx> {

rust-toolchain.toml

@@ -1,7 +1,7 @@
 [toolchain]
-channel = "nightly-2026-06-25"
+channel = "nightly-2026-07-03"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = f28ac764c36004fa6a6e098d15b4016a838c13c6
+# commit_hash = c397dae808f70caebab1fc4e11b3edf7e59f58c7
 
 # Whenever changing the nightly channel, update the commit hash above, and
 # change `REQUIRED_RUST_TOOLCHAIN` in `crates/rustc_codegen_spirv/build.rs` too.

tests/compiletests/ui/dis/ptr_write.stderr

@@ -4,7 +4,7 @@
 %7 = OpLabel
 OpLine %8 7 35
 %9 = OpLoad  %10  %4
-OpLine %11 1933 40
+OpLine %11 1941 40
 OpStore %6 %9
 OpNoLine
 OpReturn