codegen: update attr handling for rustc 1d8897a4e

LegNeato · Firestar99 · commit 32fca6dd5855 · 2026-03-30T07:03:29.000Z
Use exact rust_gpu attribute paths with get_attrs_by_path, let
AggregatedSpirvAttributes parse filtered iterators directly, and replace the
manual debug filename arena allocation with DroplessArena::alloc_str.

Also port the rustc-private API drift in this nightly by importing
assert_matches from std, using rustc_span::Spanned directly, and renaming
BackendRepr::ScalableVector to SimdScalableVector.
diff --git a/crates/rustc_codegen_spirv/src/abi.rs b/crates/rustc_codegen_spirv/src/abi.rs
@@ -103,7 +103,7 @@ pub(crate) fn provide(providers: &mut Providers) {
 
             // SPIR-V backend lowers arguments by-value and cannot handle
             // backend-specific indirection/casts at this layer.
-            if matches!(arg.mode, PassMode::Cast { .. } | PassMode::Indirect { .. }) {
+            if matches!(arg.mode, PassMode::Cast { .. }) {
                 arg.mode = PassMode::Direct(ArgAttributes::new());
             }
 
@@ -330,8 +330,18 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
                 span = cx.tcx.def_span(adt.did());
             }
 
-            #[allow(deprecated)]
-            let attrs = AggregatedSpirvAttributes::parse(cx, cx.tcx.get_all_attrs(adt.did()));
+            let attrs = AggregatedSpirvAttributes::parse(
+                cx,
+                cx.tcx
+                    .get_attrs_by_path(
+                        adt.did(),
+                        &[cx.sym.rust_gpu, cx.sym.spirv_attr_with_version],
+                    )
+                    .chain(cx.tcx.get_attrs_by_path(
+                        adt.did(),
+                        &[cx.sym.rust_gpu, cx.sym.vector, cx.sym.v1],
+                    )),
+            );
 
             if let Some(intrinsic_type_attr) = attrs.intrinsic_type.map(|attr| attr.value)
                 && let Ok(spirv_type) =
@@ -435,7 +445,7 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
                 }
                 .def(span, cx)
             }
-            BackendRepr::ScalableVector { .. } => cx
+            BackendRepr::SimdScalableVector { .. } => cx
                 .tcx
                 .dcx()
                 .fatal("scalable vectors are not supported in SPIR-V backend"),
@@ -662,7 +672,6 @@ fn trans_aggregate<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>
     }
 }
 
-#[cfg_attr(not(rustc_codegen_spirv_disable_pqp_cg_ssa), allow(unused))]
 // returns (field_offsets, size, align)
 pub fn auto_struct_layout(
     cx: &CodegenCx<'_>,
diff --git a/crates/rustc_codegen_spirv/src/attr.rs b/crates/rustc_codegen_spirv/src/attr.rs
@@ -153,7 +153,10 @@ impl AggregatedSpirvAttributes {
     ///
     /// Any errors for malformed/duplicate attributes will have been reported
     /// prior to codegen, by the `attr` check pass.
-    pub fn parse<'tcx>(cx: &CodegenCx<'tcx>, attrs: &'tcx [Attribute]) -> Self {
+    pub fn parse<'tcx>(
+        cx: &CodegenCx<'tcx>,
+        attrs: impl IntoIterator<Item = &'tcx Attribute>,
+    ) -> Self {
         let mut aggregated_attrs = Self::default();
 
         // NOTE(eddyb) `span_delayed_bug` ensures that if attribute checking fails
@@ -527,12 +530,17 @@ pub(crate) fn provide(providers: &mut Providers) {
 type ParseAttrError = (Span, String);
 
 #[allow(clippy::get_first)]
-fn parse_attrs_for_checking<'a>(
-    sym: &'a Symbols,
-    attrs: &'a [Attribute],
-) -> impl Iterator<Item = Result<(Span, SpirvAttribute), ParseAttrError>> + 'a {
+fn parse_attrs_for_checking<'sym, 'attr, I>(
+    sym: &'sym Symbols,
+    attrs: I,
+) -> impl Iterator<Item = Result<(Span, SpirvAttribute), ParseAttrError>> + 'sym
+where
+    I: IntoIterator<Item = &'attr Attribute> + 'sym,
+    I::IntoIter: 'sym,
+    'attr: 'sym,
+{
     attrs
-        .iter()
+        .into_iter()
         .map(move |attr| {
             // parse the #[rust_gpu::spirv(...)] attr and return the inner list
             match attr {
diff --git a/crates/rustc_codegen_spirv/src/builder_spirv.rs b/crates/rustc_codegen_spirv/src/builder_spirv.rs
@@ -15,19 +15,18 @@ use rspirv::{binary::Assemble, binary::Disassemble};
 use rustc_abi::Size;
 use rustc_arena::DroplessArena;
 use rustc_codegen_ssa::traits::ConstCodegenMethods as _;
-use rustc_data_structures::assert_matches;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::ConstAllocation;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::Symbol;
 use rustc_span::{DUMMY_SP, SourceFile, Span};
+use std::assert_matches;
 use std::cell::{RefCell, RefMut};
 use std::hash::{Hash, Hasher};
 use std::iter;
 use std::ops::Range;
-use std::str;
 use std::sync::Arc;
 use std::{fs::File, io::Write, path::Path};
 
@@ -884,23 +883,7 @@ impl<'tcx> BuilderSpirv<'tcx> {
                 // but sadly that `'_` is the lifetime of the temporary `Arc`,
                 // not `'tcx`, so we have to arena-allocate to get `&'tcx str`.
                 let file_name = sf.name.prefer_remapped_unconditionally().to_string_lossy();
-                let file_name = {
-                    // FIXME(eddyb) it should be possible to arena-allocate a
-                    // `&str` directly, but it would require upstream changes,
-                    // and strings are handled by string interning in `rustc`.
-                    fn arena_alloc_slice<'tcx, T: Copy>(
-                        dropless_arena: &'tcx DroplessArena,
-                        xs: &[T],
-                    ) -> &'tcx [T] {
-                        if xs.is_empty() {
-                            &[]
-                        } else {
-                            dropless_arena.alloc_slice(xs)
-                        }
-                    }
-                    str::from_utf8(arena_alloc_slice(self.dropless_arena, file_name.as_bytes()))
-                        .unwrap()
-                };
+                let file_name = self.dropless_arena.alloc_str(&file_name);
                 let file_name_op_string_id = builder.string(file_name.to_owned());
 
                 let file_contents = self
diff --git a/crates/rustc_codegen_spirv/src/codegen_cx/declare.rs b/crates/rustc_codegen_spirv/src/codegen_cx/declare.rs
@@ -142,8 +142,13 @@ impl<'tcx> CodegenCx<'tcx> {
             self.set_linkage(fn_id, symbol_name.to_owned(), linkage);
         }
 
-        #[allow(deprecated)]
-        let attrs = AggregatedSpirvAttributes::parse(self, self.tcx.get_all_attrs(def_id));
+        let attrs = AggregatedSpirvAttributes::parse(
+            self,
+            self.tcx.get_attrs_by_path(
+                def_id,
+                &[self.sym.rust_gpu, self.sym.spirv_attr_with_version],
+            ),
+        );
         if let Some(entry) = attrs.entry.map(|attr| attr.value) {
             // HACK(eddyb) early insert to let `shader_entry_stub` call this
             // very function via `get_fn_addr`.
diff --git a/crates/rustc_codegen_spirv/src/codegen_cx/entry.rs b/crates/rustc_codegen_spirv/src/codegen_cx/entry.rs
@@ -13,7 +13,6 @@ use rspirv::spirv::{
 };
 use rustc_abi::FieldsShape;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods, MiscCodegenMethods as _};
-use rustc_data_structures::assert_matches;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::MultiSpan;
 use rustc_hir as hir;
@@ -22,6 +21,7 @@ use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty};
 use rustc_span::{DUMMY_SP, Span};
 use rustc_target::callconv::{ArgAbi, FnAbi, PassMode};
+use std::assert_matches;
 
 /// Various information about an entry-point parameter, which can only be deduced
 /// (and/or checked) in all cases by using the original reference/value Rust type
diff --git a/crates/rustc_codegen_spirv/src/codegen_cx/type_.rs b/crates/rustc_codegen_spirv/src/codegen_cx/type_.rs
@@ -13,8 +13,7 @@ use rustc_middle::ty::layout::{
     FnAbiError, FnAbiOfHelpers, FnAbiRequest, LayoutError, LayoutOfHelpers, TyAndLayout,
 };
 use rustc_middle::{bug, span_bug};
-use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, Spanned};
 use rustc_target::callconv::{CastTarget, FnAbi};
 
 impl<'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'tcx> {
@@ -98,7 +97,7 @@ impl<'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'tcx> {
     fn is_backend_immediate(&self, layout: TyAndLayout<'tcx>) -> bool {
         match layout.backend_repr {
             BackendRepr::Scalar(_)
-            | BackendRepr::ScalableVector { .. }
+            | BackendRepr::SimdScalableVector { .. }
             | BackendRepr::SimdVector { .. } => true,
             BackendRepr::ScalarPair(..) => false,
             BackendRepr::Memory { .. } => layout.is_zst(),
@@ -109,7 +108,7 @@ impl<'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'tcx> {
         match layout.backend_repr {
             BackendRepr::ScalarPair(..) => true,
             BackendRepr::Scalar(_)
-            | BackendRepr::ScalableVector { .. }
+            | BackendRepr::SimdScalableVector { .. }
             | BackendRepr::SimdVector { .. }
             | BackendRepr::Memory { .. } => false,
         }
