rustc 1.100

Cargo.toml

@@ -55,6 +55,14 @@ keywords = ["gpu", "compiler", "rust-gpu"]
 [workspace.lints.rust]
 unexpected_cfgs = { level = "allow", check-cfg = ['cfg(target_arch, values("spirv"))'] }
 
+[workspace.lints.cargo]
+# some crates need to depend on `rustc_codegen_spirv` to build the dylib, but can't use them due to
+# that crate requiring `#[feature(rustc_private)]` to be used
+unused_dependencies = { level = "allow" }
+# due to cargo bugs on windows, we need to repeat some workspace dependencies from the difftest
+# workspace in the root workspace
+unused_workspace_dependencies = { level = "allow" }
+
 [workspace.dependencies]
 spirv-builder = { path = "./crates/spirv-builder", version = "0.11.0", default-features = false }
 spirv-std = { path = "./crates/spirv-std", version = "0.11.0" }
@@ -80,10 +88,8 @@ toml = "0.9.2"
 tempfile = "3.22"
 test-log = "0.2.18"
 cargo_metadata = "0.21.0"
-cargo-util-schemas = "0.8.2"
 semver = "1.0.26"
 dunce = "1.0.5"
-expect-test = "1.5.1"
 regex-lite = "0.1.9"
 spirv = { version = "0.4.0", features = ["serialize", "deserialize"] }
 rspirv = "0.13.0"

crates/cargo-gpu/Cargo.toml

@@ -27,7 +27,6 @@ dunce.workspace = true
 cargo-generate = { version = "0.25.0", optional = true }
 
 [build-dependencies]
-serde.workspace = true
 serde_json.workspace = true
 
 [dev-dependencies]

crates/rustc_codegen_spirv-types/Cargo.toml

@@ -7,6 +7,9 @@ edition.workspace = true
 license.workspace = true
 repository.workspace = true
 
+[lints]
+workspace = true
+
 [dependencies]
 spirv.workspace = true
 rspirv.workspace = true

crates/rustc_codegen_spirv/Cargo.toml

@@ -8,6 +8,9 @@ edition.workspace = true
 license.workspace = true
 repository.workspace = true
 
+[lints]
+workspace = true
+
 [lib]
 crate-type = ["dylib"]
 
@@ -32,14 +35,6 @@ skip-toolchain-check = []
 naga = ["dep:naga"]
 
 [dependencies]
-# HACK(eddyb) these only exist to unify features across dependency trees,
-# in order to avoid multiple separate instances of `rustc_codegen_spirv`.
-ahash = { version = "0.8.11", features = ["no-rng"] }
-bytemuck = { workspace = true, features = ["aarch64_simd"] }
-log = { version = "0.4.22", features = ["std"] }
-regex = { version = "1", features = ["perf"] }
-rustix = { version = "1.0.8", features = ["all-apis"] }
-
 # HACK(eddyb) deps of `rustc_codegen_ssa`, for `pqp_cg_ssa` (see `build.rs`),
 # that cannot be handled with just `extern crate` pulling out of the sysroot.
 object = { version = "0.38.1", default-features = false, features = ["read_core", "elf", "macho", "pe", "xcoff", "unaligned", "archive", "write", "wasm"] }
@@ -65,6 +60,7 @@ tracing-tree = "0.4.0"
 naga = { version = "30.0.1", features = ["spv-in", "wgsl-out"], optional = true }
 strum = { version = "0.28.0", features = ["derive"] }
 rspirv2.workspace = true
+bytemuck.workspace = true
 
 [dev-dependencies]
 pretty_assertions = "1.0"

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-08-15"
+channel = "nightly-2026-09-25"
 components = ["rust-src", "rustc-dev", "llvm-tools"]
-# commit_hash = d453bdd8f092d099bc336f0bda4163f809ad18e0"#;
+# commit_hash = f7575a9da8e4a4fca3b5668d5a2ea7476db44b3f"#;
 
 fn rustc_output(arg: &str) -> Result<String, Box<dyn Error>> {
     let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".into());

crates/rustc_codegen_spirv/src/abi.rs

@@ -14,18 +14,19 @@ use rustc_abi::{
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
 use rustc_index::Idx;
+use rustc_middle::ty::consts::ConstExt;
 use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{
     self, Const, CoroutineArgs, CoroutineArgsExt as _, FloatTy, IntTy, PolyFnSig, Ty, TyCtxt,
     TyKind, UintTy, ValTreeKindExt,
 };
 use rustc_middle::ty::{GenericArgsRef, ScalarInt};
 use rustc_middle::util::Providers;
-use rustc_middle::{bug, span_bug};
 use rustc_session::config::OptLevel;
 use rustc_span::DUMMY_SP;
 use rustc_span::def_id::DefId;
 use rustc_span::{Span, Symbol};
+use rustc_span::{bug, span_bug};
 use rustc_target::callconv::{ArgAbi, ArgAttributes, FnAbi, PassMode};
 use std::cell::RefCell;
 use std::collections::hash_map::Entry;
@@ -927,7 +928,7 @@ fn trans_intrinsic_type<'tcx>(
 
     impl FromScalarInt for u32 {
         fn from_scalar_int(n: ScalarInt) -> Option<Self> {
-            Some(n.try_to_bits(Size::from_bits(32)).ok()?.try_into().unwrap())
+            Some(n.to_bits(Size::from_bits(32)).try_into().unwrap())
         }
     }
 
@@ -1173,7 +1174,7 @@ fn trans_intrinsic_type<'tcx>(
                             format!("{err_attr_name} type fields must all be vectors"),
                         )
                         .with_note(format!("field type is {}", ty.debug(element, cx)))
-                        .emit());
+                        .emit_err());
                 }
             }
             Ok(SpirvType::Matrix { element, count }.def(span, cx))
@@ -1195,7 +1196,7 @@ fn trans_intrinsic_type<'tcx>(
                             ),
                         )
                         .with_note(format!("field type is {}", ty.debug(element, cx)))
-                        .emit());
+                        .emit_err());
                 }
             }
             Ok(SpirvType::Vector {

crates/rustc_codegen_spirv/src/attr.rs

@@ -6,10 +6,12 @@ use crate::codegen_cx::CodegenCx;
 use crate::symbols::Symbols;
 use rspirv::spirv::{BuiltIn, ExecutionMode, ExecutionModel, StorageClass};
 use rustc_ast::{LitKind, MetaItemInner, MetaItemLit};
+use rustc_attr_ir::Attribute;
+use rustc_attr_ir::target::{MethodKind, Target};
 use rustc_hir as hir;
 use rustc_hir::def_id::LocalModId;
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{Attribute, CRATE_HIR_ID, HirId, MethodKind, Target};
+use rustc_hir::{CRATE_HIR_ID, HirId};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::TyCtxt;
@@ -260,9 +262,8 @@ impl AggregatedSpirvAttributes {
 }
 
 // FIXME(eddyb) make this reusable from somewhere in `rustc`.
-fn target_from_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>) -> Target {
+fn target_from_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>) -> Option<Target> {
     match impl_item.kind {
-        hir::ImplItemKind::Const(..) => Target::AssocConst,
         hir::ImplItemKind::Fn(..) => {
             let parent_owner_id = tcx.hir_get_parent_item(impl_item.hir_id());
             let containing_item = tcx.hir_expect_item(parent_owner_id.def_id);
@@ -271,12 +272,12 @@ fn target_from_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>) -> Targ
                 _ => unreachable!("parent of an ImplItem must be an Impl"),
             };
             if containing_impl_is_for_trait {
-                Target::Method(MethodKind::Trait { body: true })
+                Some(Target::Method(MethodKind::Trait { body: true }))
             } else {
-                Target::Method(MethodKind::Inherent)
+                Some(Target::Method(MethodKind::Inherent))
             }
         }
-        hir::ImplItemKind::Type(..) => Target::AssocTy,
+        hir::ImplItemKind::Const(..) | hir::ImplItemKind::Type(..) => None,
     }
 }
 
@@ -467,8 +468,9 @@ impl<'tcx> Visitor<'tcx> for CheckSpirvAttrVisitor<'tcx> {
     }
 
     fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) {
-        let target = target_from_impl_item(self.tcx, impl_item);
-        self.check_spirv_attributes(impl_item.hir_id(), target);
+        if let Some(target) = target_from_impl_item(self.tcx, impl_item) {
+            self.check_spirv_attributes(impl_item.hir_id(), target);
+        }
         intravisit::walk_impl_item(self, impl_item);
     }
 

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -23,13 +23,13 @@ use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::{
     BackendTypes, BaseTypeCodegenMethods, BuilderMethods, ConstCodegenMethods,
-    LayoutTypeCodegenMethods, OverflowOp,
+    LayoutTypeCodegenMethods, OverflowOp, ReturnSlot,
 };
-use rustc_middle::bug;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{self, AtomicOrdering, Ty};
 use rustc_span::Span;
+use rustc_span::bug;
 use rustc_target::callconv::FnAbi;
 use smallvec::SmallVec;
 use std::iter::{self, empty};
@@ -1560,18 +1560,28 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
 
     fn invoke(
         &mut self,
-        llty: Self::Type,
+        llty: Self::FunctionSignature,
         fn_attrs: Option<&CodegenFnAttrs>,
         fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,
         llfn: Self::Value,
+        return_slot: ReturnSlot<Self::Value>,
         args: &[Self::Value],
         then: Self::BasicBlock,
         _catch: Self::BasicBlock,
         funclet: Option<&Self::Funclet>,
         instance: Option<ty::Instance<'tcx>>,
     ) -> Self::Value {
         // Exceptions don't exist, jump directly to then block
-        let result = self.call(llty, fn_attrs, fn_abi, llfn, args, funclet, instance);
+        let result = self.call(
+            llty,
+            fn_attrs,
+            fn_abi,
+            llfn,
+            return_slot,
+            args,
+            funclet,
+            instance,
+        );
         self.emit().branch(then.id).unwrap();
         result
     }
@@ -1886,6 +1896,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         ty: Self::Type,
         ptr: Self::Value,
         order: AtomicOrdering,
+        _volatile: bool,
         _size: Size,
     ) -> Self::Value {
         let (ptr, access_ty) = self.adjust_pointer_for_typed_access(ptr, ty);
@@ -2025,6 +2036,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         val: Self::Value,
         ptr: Self::Value,
         order: AtomicOrdering,
+        _volatile: bool,
         _size: Size,
     ) {
         let (ptr, access_ty) = self.adjust_pointer_for_typed_access(ptr, val.ty);
@@ -2069,14 +2081,14 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
 
         self.maybe_inbounds_gep(ty, ptr, indices, true)
     }
-
     // intcast has the logic for dealing with bools, so use that
     fn trunc(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value {
         self.intcast(val, dest_ty, false)
     }
     fn sext(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value {
         self.intcast(val, dest_ty, true)
     }
+
     fn fptoui_sat(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value {
         self.fptoint_sat(false, val, dest_ty)
     }
@@ -3297,14 +3309,15 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
 
     #[tracing::instrument(
         level = "debug",
-        skip(self, callee_ty, _fn_attrs, fn_abi, callee, args, funclet)
+        skip(self, callee_ty, _fn_attrs, fn_abi, fn_val, args, funclet)
     )]
     fn call(
         &mut self,
         callee_ty: Self::Type,
         _fn_attrs: Option<&CodegenFnAttrs>,
         fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,
-        callee: Self::Value,
+        fn_val: Self::Value,
+        _return_slot: ReturnSlot<Self::Value>,
         args: &[Self::Value],
         funclet: Option<&Self::Funclet>,
         instance: Option<ty::Instance<'tcx>>,
@@ -3316,7 +3329,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, '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.
-        let (callee_val, result_type, argument_types) = match self.lookup_type(callee.ty) {
+        let (callee_val, result_type, argument_types) = match self.lookup_type(fn_val.ty) {
             SpirvType::Pointer { pointee } => {
                 let (pointee_is_function, result_type, argument_types) = match self
                     .lookup_type(pointee)
@@ -3353,15 +3366,15 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
                     }
                 };
 
-                let callee_val = if let SpirvValueKind::FnAddr { function } = callee.kind {
+                let callee_val = if let SpirvValueKind::FnAddr { function } = fn_val.kind {
                     if pointee_is_function {
                         assert_ty_eq!(self, callee_ty, pointee);
                     }
                     function
                 }
                 // Truly indirect call.
                 else {
-                    let fn_ptr_val = callee.def(self);
+                    let fn_ptr_val = fn_val.def(self);
                     self.zombie(fn_ptr_val, "indirect calls are not supported in SPIR-V");
                     fn_ptr_val
                 };
@@ -3371,7 +3384,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
 
             _ => bug!(
                 "call expected `fn` pointer type, got `{}`",
-                self.debug_type(callee.ty)
+                self.debug_type(fn_val.ty)
             ),
         };
 
@@ -3481,6 +3494,7 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         _fn_attrs: Option<&CodegenFnAttrs>,
         _fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
         _llfn: Self::Value,
+        _return_slot: ReturnSlot<Self::Value>,
         _args: &[Self::Value],
         _funclet: Option<&Self::Funclet>,
         _instance: Option<ty::Instance<'tcx>>,

crates/rustc_codegen_spirv/src/builder/byte_addressable_buffer.rs

@@ -224,7 +224,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         if original_type != value.ty {
             err.note(format!("due to containing type {}", value.ty));
         }
-        Err(err.emit())
+        Err(err.emit_err())
     }
 
     fn store_u32(

crates/rustc_codegen_spirv/src/builder/format_args_decompiler.rs

@@ -764,7 +764,7 @@ impl<'a, 'tcx> CodegenPanic<'a, 'tcx> for FormatArgsResult<'tcx> {
                     && !builder.tcx.sess.opts.unstable_opts.ui_testing
                 {
                     // HACK(eddyb) Cargo silences warnings in dependencies.
-                    let force_warn = |span, msg| -> rustc_errors::Diag<'_, ()> {
+                    let force_warn = |span, msg| -> rustc_errors::Diag<'_> {
                         rustc_errors::Diag::new(
                             builder.tcx.dcx(),
                             rustc_errors::Level::ForceWarning,