Port backend to newer rustc ABI/target behavior

- Rewrite extern C fn sigs to Rust ABI to satisfy new rustc fn_abi sanity checks.

- Handle direct calls represented as ptr<void> by recovering function signature from callee type/fn_abi.

- Keep generated SPIR-V target JSON aligned with backend target options and rustc 1.93 schema expectations.

Author: LegNeato

crates/rustc_codegen_spirv-types/src/target_spec.rs

@@ -55,13 +55,10 @@ impl TargetSpecVersion {
     /// format the target spec json
     pub fn format_spec(&self, target: &SpirvTarget) -> String {
         let target_env = target.env();
-        let extra = match self {
-            TargetSpecVersion::Rustc_1_76_0 => r#""os": "unknown","#,
-            _ => r#""crt-static-respected": true,"#,
-        };
-        let target_pointer_width = match self {
-            TargetSpecVersion::Rustc_1_76_0 | TargetSpecVersion::Rustc_1_85_0 => "\"32\"",
-            TargetSpecVersion::Rustc_1_93_0 => "32",
+        let (extra, target_pointer_width) = match self {
+            TargetSpecVersion::Rustc_1_76_0 => (r#""os": "unknown","#, "\"32\""),
+            TargetSpecVersion::Rustc_1_85_0 => (r#""crt-static-respected": true,"#, "\"32\""),
+            TargetSpecVersion::Rustc_1_93_0 => (r#""crt-static-respected": true,"#, "32"),
         };
         format!(
             r#"{{

crates/rustc_codegen_spirv/src/abi.rs

@@ -38,15 +38,20 @@ pub(crate) fn provide(providers: &mut Providers) {
     // This theoretically then should be fine to leave as C, but, there's no backend hook for
     // `FnAbi::adjust_for_cabi`, causing it to panic:
     // https://github.com/rust-lang/rust/blob/5fae56971d8487088c0099c82c0a5ce1638b5f62/compiler/rustc_target/src/abi/call/mod.rs#L603
-    // So, treat any `extern "C"` functions as `extern "unadjusted"`, to be able to compile libcore with arch=spirv.
+    // So, treat any `extern "C"` functions as `extern "Rust"`, to be able to
+    // compile libcore with arch=spirv.
+    //
+    // 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| {
         // 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::Unadjusted;
+                    inner.abi = Abi::Rust;
                 }
                 inner
             })

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -3274,29 +3274,55 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         // 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) {
-            SpirvType::Pointer { pointee } => match self.lookup_type(pointee) {
-                SpirvType::Function {
-                    return_type,
-                    arguments,
-                } => (
-                    if let SpirvValueKind::FnAddr { function } = callee.kind {
+            SpirvType::Pointer { pointee } => {
+                let (pointee_is_function, result_type, argument_types) = match self
+                    .lookup_type(pointee)
+                {
+                    SpirvType::Function {
+                        return_type,
+                        arguments,
+                    } => (true, return_type, arguments),
+                    // Newer rustc can represent direct call targets as `ptr<void>`,
+                    // with the callee signature carried separately.
+                    _ => match self.lookup_type(callee_ty) {
+                        SpirvType::Function {
+                            return_type,
+                            arguments,
+                        } => (false, return_type, arguments),
+                        _ => {
+                            let Some(fn_abi) = fn_abi else {
+                                bug!(
+                                    "call expected `fn` pointer to point to function type, got `{}`",
+                                    self.debug_type(pointee)
+                                );
+                            };
+                            let fn_ty = fn_abi.spirv_type(self.span(), self);
+                            match self.lookup_type(fn_ty) {
+                                SpirvType::Function {
+                                    return_type,
+                                    arguments,
+                                } => (false, return_type, arguments),
+                                _ => bug!("call expected function ABI to lower to function type"),
+                            }
+                        }
+                    },
+                };
+
+                let callee_val = if let SpirvValueKind::FnAddr { function } = callee.kind {
+                    if pointee_is_function {
                         assert_ty_eq!(self, callee_ty, pointee);
-                        function
                     }
-                    // Truly indirect call.
-                    else {
-                        let fn_ptr_val = callee.def(self);
-                        self.zombie(fn_ptr_val, "indirect calls are not supported in SPIR-V");
-                        fn_ptr_val
-                    },
-                    return_type,
-                    arguments,
-                ),
-                _ => bug!(
-                    "call expected `fn` pointer to point to function type, got `{}`",
-                    self.debug_type(pointee)
-                ),
-            },
+                    function
+                }
+                // Truly indirect call.
+                else {
+                    let fn_ptr_val = callee.def(self);
+                    self.zombie(fn_ptr_val, "indirect calls are not supported in SPIR-V");
+                    fn_ptr_val
+                };
+
+                (callee_val, result_type, argument_types)
+            }
 
             _ => bug!(
                 "call expected `fn` pointer type, got `{}`",