Port backend internals and ABI plumbing to latest nightly

Author: LegNeato

crates/rustc_codegen_spirv/build.rs

@@ -329,6 +329,7 @@ mod maybe_pqp_cg_ssa;
     fs::write(out_dir.join("pqp_cg_ssa.rs"), pqp_cg_ssa_top_level)?;
 
     println!("cargo::rustc-check-cfg=cfg(rustc_codegen_spirv_disable_pqp_cg_ssa)");
+    println!("cargo::rustc-check-cfg=cfg(bootstrap)");
 
     // HACK(eddyb) `if cfg!(llvm_enzyme)` added upstream for autodiff support.
     println!("cargo::rustc-check-cfg=cfg(llvm_enzyme)");

crates/rustc_codegen_spirv/src/abi.rs

@@ -13,13 +13,13 @@ use rustc_abi::{
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::ErrorGuaranteed;
 use rustc_index::Idx;
-use rustc_middle::query::Providers;
 use rustc_middle::ty::layout::{FnAbiOf, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{
     self, Const, CoroutineArgs, CoroutineArgsExt as _, FloatTy, IntTy, PolyFnSig, Ty, TyCtxt,
-    TyKind, UintTy,
+    TyKind, UintTy, ValTreeKindExt,
 };
 use rustc_middle::ty::{GenericArgsRef, ScalarInt};
+use rustc_middle::util::Providers;
 use rustc_middle::{bug, span_bug};
 use rustc_span::DUMMY_SP;
 use rustc_span::def_id::DefId;
@@ -29,6 +29,19 @@ use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::fmt;
 
+fn rewrite_c_abi_to_rust<'tcx>(
+    fn_sig: ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>>,
+) -> ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>> {
+    fn_sig.map_bound(|outer| {
+        outer.map_bound(|mut inner| {
+            if let Abi::C { .. } = inner.abi {
+                inner.abi = Abi::Rust;
+            }
+            inner
+        })
+    })
+}
+
 pub(crate) fn provide(providers: &mut Providers) {
     // This is a lil weird: so, we obviously don't support C ABIs at all. However, libcore does declare some extern
     // C functions:
@@ -44,18 +57,19 @@ pub(crate) fn provide(providers: &mut Providers) {
     // NOTE: this used to rewrite to `extern "unadjusted"`, but rustc now
     // validates `#[rustc_pass_indirectly_in_non_rustic_abis]` for non-Rust ABIs,
     // and `Unadjusted` does not satisfy that requirement.
-    providers.fn_sig = |tcx, def_id| {
+    providers.queries.fn_sig = |tcx, def_id| {
         // We can't capture the old fn_sig and just call that, because fn_sig is a `fn`, not a `Fn`, i.e. it can't
         // capture variables. Fortunately, the defaults are exposed (thanks rustdoc), so use that instead.
-        let result = (rustc_interface::DEFAULT_QUERY_PROVIDERS.fn_sig)(tcx, def_id);
-        result.map_bound(|outer| {
-            outer.map_bound(|mut inner| {
-                if let Abi::C { .. } = inner.abi {
-                    inner.abi = Abi::Rust;
-                }
-                inner
-            })
-        })
+        let result = (rustc_interface::DEFAULT_QUERY_PROVIDERS.queries.fn_sig)(tcx, def_id);
+        rewrite_c_abi_to_rust(result)
+    };
+    providers.extern_queries.fn_sig = |tcx, def_id| {
+        // We can't capture the old fn_sig and just call that, because fn_sig is a `fn`, not a `Fn`, i.e. it can't
+        // capture variables. Fortunately, the defaults are exposed (thanks rustdoc), so use that instead.
+        let result = (rustc_interface::DEFAULT_QUERY_PROVIDERS
+            .extern_queries
+            .fn_sig)(tcx, def_id);
+        rewrite_c_abi_to_rust(result)
     };
 
     // For the Rust ABI, `FnAbi` adjustments are backend-agnostic, but they will
@@ -67,7 +81,7 @@ pub(crate) fn provide(providers: &mut Providers) {
         fn_abi: &'tcx FnAbi<'tcx, Ty<'tcx>>,
     ) -> &'tcx FnAbi<'tcx, Ty<'tcx>> {
         let readjust_arg_abi = |arg: &ArgAbi<'tcx, Ty<'tcx>>| {
-            let mut arg = ArgAbi::new(&tcx, arg.layout, |_, _, _| ArgAttributes::new());
+            let mut arg = ArgAbi::new(&tcx, arg.layout, |_, _| ArgAttributes::new());
             // FIXME: this is bad! https://github.com/rust-lang/rust/issues/115666
             // <https://github.com/rust-lang/rust/commit/eaaa03faf77b157907894a4207d8378ecaec7b45>
             arg.make_direct_deprecated();
@@ -86,6 +100,12 @@ pub(crate) fn provide(providers: &mut Providers) {
                 arg.mode = PassMode::Ignore;
             }
 
+            // 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 { .. }) {
+                arg.mode = PassMode::Direct(ArgAttributes::new());
+            }
+
             arg
         };
         tcx.arena.alloc(FnAbi {
@@ -101,12 +121,22 @@ pub(crate) fn provide(providers: &mut Providers) {
             can_unwind: fn_abi.can_unwind,
         })
     }
-    providers.fn_abi_of_fn_ptr = |tcx, key| {
-        let result = (rustc_interface::DEFAULT_QUERY_PROVIDERS.fn_abi_of_fn_ptr)(tcx, key);
+    providers.queries.fn_abi_of_fn_ptr = |tcx, key| {
+        let result = (rustc_interface::DEFAULT_QUERY_PROVIDERS
+            .queries
+            .fn_abi_of_fn_ptr)(tcx, key);
+        Ok(readjust_fn_abi(tcx, result?))
+    };
+    providers.queries.fn_abi_of_instance_no_deduced_attrs = |tcx, key| {
+        let result = (rustc_interface::DEFAULT_QUERY_PROVIDERS
+            .queries
+            .fn_abi_of_instance_no_deduced_attrs)(tcx, key);
         Ok(readjust_fn_abi(tcx, result?))
     };
-    providers.fn_abi_of_instance = |tcx, key| {
-        let result = (rustc_interface::DEFAULT_QUERY_PROVIDERS.fn_abi_of_instance)(tcx, key);
+    providers.queries.fn_abi_of_instance_raw = |tcx, key| {
+        let result = (rustc_interface::DEFAULT_QUERY_PROVIDERS
+            .queries
+            .fn_abi_of_instance_raw)(tcx, key);
         Ok(readjust_fn_abi(tcx, result?))
     };
 
@@ -116,7 +146,7 @@ pub(crate) fn provide(providers: &mut Providers) {
     //
     // FIXME(eddyb) same as the FIXME comment on `check_well_formed`:
     // need to migrate away from `#[repr(simd)]` ASAP.
-    providers.check_mono_item = |_, _| {};
+    providers.queries.check_mono_item = |_, _| {};
 }
 
 /// If a struct contains a pointer to itself, even indirectly, then doing a naiive recursive walk
@@ -291,6 +321,7 @@ 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()));
 
             if let Some(intrinsic_type_attr) = attrs.intrinsic_type.map(|attr| attr.value)
@@ -395,6 +426,10 @@ impl<'tcx> ConvSpirvType<'tcx> for TyAndLayout<'tcx> {
                 }
                 .def(span, cx)
             }
+            BackendRepr::ScalableVector { .. } => cx
+                .tcx
+                .dcx()
+                .fatal("scalable vectors are not supported in SPIR-V backend"),
             BackendRepr::Memory { sized: _ } => trans_aggregate(cx, span, *self),
         }
     }
@@ -614,22 +649,11 @@ fn trans_aggregate<'tcx>(cx: &CodegenCx<'tcx>, span: Span, ty: TyAndLayout<'tcx>
                 .def(span, cx)
             }
         }
-        FieldsShape::Arbitrary {
-            offsets: _,
-            memory_index: _,
-        } => trans_struct_or_union(cx, span, ty, None),
+        FieldsShape::Arbitrary { .. } => trans_struct_or_union(cx, span, ty, None),
     }
 }
 
-#[cfg_attr(
-    not(rustc_codegen_spirv_disable_pqp_cg_ssa),
-    expect(
-        unused,
-        reason = "actually used from \
-            `<rustc_codegen_ssa::traits::ConstCodegenMethods for CodegenCx<'_>>::const_struct`, \
-            but `rustc_codegen_ssa` being `pqp_cg_ssa` makes that trait unexported"
-    )
-)]
+#[cfg_attr(not(rustc_codegen_spirv_disable_pqp_cg_ssa), allow(unused))]
 // returns (field_offsets, size, align)
 pub fn auto_struct_layout(
     cx: &CodegenCx<'_>,
@@ -866,7 +890,8 @@ fn trans_intrinsic_type<'tcx>(
                 } = const_.to_value();
                 assert!(const_ty.is_integral());
                 const_val
-                    .try_to_scalar_int()
+                    .try_to_scalar()
+                    .and_then(|scalar| scalar.try_to_scalar_int().ok())
                     .and_then(P::from_scalar_int)
                     .ok_or_else(|| {
                         cx.tcx

crates/rustc_codegen_spirv/src/attr.rs

@@ -514,7 +514,9 @@ pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers {
         check_mod_attrs: |tcx, module_def_id| {
             // Run both the default checks, and our `#[spirv(...)]` ones.
-            (rustc_interface::DEFAULT_QUERY_PROVIDERS.check_mod_attrs)(tcx, module_def_id);
+            (rustc_interface::DEFAULT_QUERY_PROVIDERS
+                .queries
+                .check_mod_attrs)(tcx, module_def_id);
             check_mod_attrs(tcx, module_def_id);
         },
         ..*providers
@@ -537,10 +539,10 @@ fn parse_attrs_for_checking<'a>(
                 Attribute::Unparsed(item) => {
                     // #[...]
                     let s = &item.path.segments;
-                    if let Some(rust_gpu) = s.get(0) && rust_gpu.name == sym.rust_gpu {
+                    if let Some(rust_gpu) = s.get(0) && *rust_gpu == sym.rust_gpu {
                         // #[rust_gpu ...]
                         match s.get(1) {
-                            Some(command) if command.name == sym.spirv_attr_with_version => {
+                            Some(command) if *command == sym.spirv_attr_with_version => {
                                 // #[rust_gpu::spirv ...]
                                 if let Some(args) = attr.meta_item_list() {
                                     // #[rust_gpu::spirv(...)]
@@ -554,11 +556,11 @@ fn parse_attrs_for_checking<'a>(
                                     ))
                                 }
                             }
-                            Some(command) if command.name == sym.vector => {
+                            Some(command) if *command == sym.vector => {
                                 // #[rust_gpu::vector ...]
                                 match s.get(2) {
                                     // #[rust_gpu::vector::v1]
-                                    Some(version) if version.name == sym.v1 => {
+                                    Some(version) if *version == sym.v1 => {
                                         Ok(SmallVec::from_iter([
                                             Ok((attr.span(), SpirvAttribute::IntrinsicType(IntrinsicType::Vector)))
                                         ]))

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -1826,8 +1826,8 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
     }
 
     fn scalable_alloca(&mut self, elt: u64, align: Align, element_ty: Ty<'_>) -> Self::Value {
-        let element = self.layout_of(element_ty).spirv_type(self.span(), self);
-        self.declare_func_local_var(self.type_array(element, elt), align)
+        let _ = (elt, align, element_ty);
+        self.fatal("scalable alloca is not supported in SPIR-V backend")
     }
 
     fn load(&mut self, ty: Self::Type, ptr: Self::Value, _align: Align) -> Self::Value {

crates/rustc_codegen_spirv/src/builder/intrinsics.rs

@@ -400,12 +400,15 @@ impl<'a, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'tcx> {
         todo!()
     }
 
-    fn va_start(&mut self, _val: Self::Value) -> Self::Value {
-        todo!()
+    fn va_start(&mut self, val: Self::Value) -> Self::Value {
+        // SPIR-V backend has no variadic ABI support; keep the placeholder
+        // operand unchanged so MIR lowering can proceed without crashing.
+        val
     }
 
-    fn va_end(&mut self, _val: Self::Value) -> Self::Value {
-        todo!()
+    fn va_end(&mut self, val: Self::Value) -> Self::Value {
+        // See `va_start` above.
+        val
     }
 }
 

crates/rustc_codegen_spirv/src/codegen_cx/constant.rs

@@ -343,9 +343,9 @@ impl<'tcx> CodegenCx<'tcx> {
             && let Some(SpirvConst::ConstDataFromAlloc(alloc)) =
                 self.builder.lookup_const_by_id(pointee)
             && let SpirvType::Pointer { pointee } = self.lookup_type(ty)
-            && self.try_read_from_const_alloc(alloc, pointee).is_some()
+            && let Some(init) = self.try_read_from_const_alloc(alloc, pointee)
         {
-            return self.static_addr_of(alloc, None);
+            return self.static_addr_of_constant(init);
         }
 
         if val.ty == ty {

crates/rustc_codegen_spirv/src/codegen_cx/declare.rs

@@ -39,6 +39,15 @@ fn attrs_to_spirv(attrs: &CodegenFnAttrs) -> FunctionControl {
 }
 
 impl<'tcx> CodegenCx<'tcx> {
+    pub(crate) fn static_addr_of_constant(&self, cv: SpirvValue) -> SpirvValue {
+        self.def_constant(
+            self.type_ptr_to(cv.ty),
+            SpirvConst::PtrTo {
+                pointee: cv.def_cx(self),
+            },
+        )
+    }
+
     /// Returns a function if it already exists, or declares a header if it doesn't.
     pub fn get_fn_ext(&self, instance: Instance<'tcx>) -> SpirvFunctionCursor {
         assert!(!instance.args.has_infer());
@@ -133,6 +142,7 @@ 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));
         if let Some(entry) = attrs.entry.map(|attr| attr.value) {
             // HACK(eddyb) early insert to let `shader_entry_stub` call this
@@ -212,11 +222,14 @@ impl<'tcx> CodegenCx<'tcx> {
 
         // HACK(eddyb) there is no good way to identify these definitions
         // (e.g. no `#[lang = "..."]` attribute), but this works well enough.
-        if let Some("panic_nounwind_fmt" | "panic_explicit") =
-            demangled_symbol_name.strip_prefix("core::panicking::")
+        if let Some(name) = demangled_symbol_name.strip_prefix("core::panicking::")
+            && (name == "panic_explicit" || name.starts_with("panic_"))
         {
             self.panic_entry_points.borrow_mut().insert(def_id);
         }
+        if demangled_symbol_name.ends_with("::precondition_check") {
+            self.panic_entry_points.borrow_mut().insert(def_id);
+        }
         if let Some(pieces_len) = demangled_symbol_name
             .strip_prefix("<core::fmt::Arguments>::new_const::<")
             .and_then(|s| s.strip_suffix(">"))
@@ -369,13 +382,7 @@ impl<'tcx> PreDefineCodegenMethods<'tcx> for CodegenCx<'tcx> {
 
 impl<'tcx> StaticCodegenMethods for CodegenCx<'tcx> {
     fn static_addr_of(&self, alloc: ConstAllocation<'_>, _kind: Option<&str>) -> Self::Value {
-        let cv = self.const_data_from_alloc(alloc);
-        self.def_constant(
-            self.type_ptr_to(cv.ty),
-            SpirvConst::PtrTo {
-                pointee: cv.def_cx(self),
-            },
-        )
+        self.static_addr_of_constant(self.const_data_from_alloc(alloc))
     }
 
     fn codegen_static(&mut self, def_id: DefId) {

crates/rustc_codegen_spirv/src/codegen_cx/type_.rs

@@ -97,7 +97,9 @@ impl<'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'tcx> {
 
     fn is_backend_immediate(&self, layout: TyAndLayout<'tcx>) -> bool {
         match layout.backend_repr {
-            BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. } => true,
+            BackendRepr::Scalar(_)
+            | BackendRepr::ScalableVector { .. }
+            | BackendRepr::SimdVector { .. } => true,
             BackendRepr::ScalarPair(..) => false,
             BackendRepr::Memory { .. } => layout.is_zst(),
         }
@@ -107,6 +109,7 @@ impl<'tcx> LayoutTypeCodegenMethods<'tcx> for CodegenCx<'tcx> {
         match layout.backend_repr {
             BackendRepr::ScalarPair(..) => true,
             BackendRepr::Scalar(_)
+            | BackendRepr::ScalableVector { .. }
             | BackendRepr::SimdVector { .. }
             | BackendRepr::Memory { .. } => false,
         }

crates/rustc_codegen_spirv/src/custom_decorations.rs

@@ -12,7 +12,6 @@ use rustc_span::{Span, source_map::SourceMap};
 use smallvec::SmallVec;
 use std::borrow::Cow;
 use std::marker::PhantomData;
-use std::path::PathBuf;
 use std::sync::Arc;
 use std::{fmt, iter, slice, str};
 
@@ -447,7 +446,7 @@ impl<'a> SpanRegenerator<'a> {
 
             // HACK(eddyb) in case the file has changed, and because `SourceMap`
             // is strictly monotonic, we need to come up with some other name.
-            let mut sm_file_name_candidates = [PathBuf::from(file_name).into()]
+            let mut sm_file_name_candidates = [FileName::Custom(file_name.to_string())]
                 .into_iter()
                 .chain((0..).map(|i| FileName::Custom(format!("outdated({i}) {file_name}"))));
 

crates/rustc_codegen_spirv/src/lib.rs

@@ -228,10 +228,10 @@ impl CodegenBackend for SpirvCodegenBackend {
         // FIXME(eddyb) this is currently only passed back to us, specifically
         // into `target_machine_factory` (which is a noop), but it might make
         // sense to move some of the target feature parsing into here.
-        providers.global_backend_features = |_tcx, ()| vec![];
+        providers.queries.global_backend_features = |_tcx, ()| vec![];
 
         crate::abi::provide(providers);
-        crate::attr::provide(providers);
+        crate::attr::provide(&mut providers.queries);
     }
 
     fn target_cpu(&self, sess: &Session) -> String {
@@ -324,7 +324,7 @@ impl WriteBackendMethods for SpirvCodegenBackend {
         _opt_level: config::OptLevel,
         _target_features: &[String],
     ) -> TargetMachineFactoryFn<Self> {
-        Arc::new(|_| Ok(()))
+        Arc::new(|_, _| ())
     }
 
     // FIXME(eddyb) reuse the "merge" stage of `crate::linker` for this, or even