Minimal SPIR-T-based validation of extensions and capabilities (esp. IntN/FloatN).

Author: eddyb

crates/rustc_codegen_spirv/src/linker/mod.rs

@@ -481,16 +481,6 @@ pub fn link(
         simple_passes::remove_non_uniform_decorations(sess, &mut output)?;
     }
 
-    {
-        let _timer = sess.timer("link_remove_unused_type_capabilities");
-        simple_passes::remove_unused_type_capabilities(&mut output);
-    }
-
-    {
-        let _timer = sess.timer("link_type_capability_check");
-        simple_passes::check_type_capabilities(sess, &output)?;
-    }
-
     // NOTE(eddyb) SPIR-T pipeline is entirely limited to this block.
     {
         let (spv_words, module_or_err, lower_from_spv_timer) =
@@ -563,10 +553,16 @@ pub fn link(
                 module,
                 &opts.spirt_passes,
                 |name, _module| before_pass(name),
-                after_pass,
+                &mut after_pass,
             );
         }
 
+        {
+            let timer = before_pass("spirt_passes::validate");
+            spirt_passes::validate::validate(module);
+            after_pass("validate", module, timer);
+        }
+
         {
             let _timer = before_pass("spirt_passes::diagnostics::report_diagnostics");
             spirt_passes::diagnostics::report_diagnostics(sess, opts, module).map_err(
@@ -634,6 +630,11 @@ pub fn link(
         }
     }
 
+    {
+        let _timer = sess.timer("link_remove_unused_type_capabilities");
+        simple_passes::remove_unused_type_capabilities(&mut output);
+    }
+
     {
         let _timer = sess.timer("link_gather_all_interface_vars_from_uses");
         entry_interface::gather_all_interface_vars_from_uses(&mut output);

crates/rustc_codegen_spirv/src/linker/simple_passes.rs

@@ -293,74 +293,14 @@ pub fn check_fragment_insts(sess: &Session, module: &Module) -> super::Result<()
     }
 }
 
-/// Check that types requiring specific capabilities have those capabilities declared.
-///
-/// This function validates that if a module uses types like u8/i8 (requiring Int8),
-/// u16/i16 (requiring Int16), etc., the corresponding capabilities are declared.
-pub fn check_type_capabilities(sess: &Session, module: &Module) -> super::Result<()> {
-    use rspirv::spirv::Capability;
-
-    // Collect declared capabilities
-    let declared_capabilities: FxHashSet<Capability> = module
-        .capabilities
-        .iter()
-        .map(|inst| inst.operands[0].unwrap_capability())
-        .collect();
-
-    let mut missing_caps = vec![];
-
-    for inst in &module.types_global_values {
-        let (prefix, width, maybe_required_cap) = match inst.class.opcode {
-            Op::TypeInt => {
-                let width = inst.operands[0].unwrap_literal_bit32();
-                let signed = inst.operands[1].unwrap_literal_bit32() != 0;
-
-                (
-                    if signed { "i" } else { "u" },
-                    width,
-                    capability_for_int_width(width),
-                )
-            }
-            Op::TypeFloat => {
-                let width = inst.operands[0].unwrap_literal_bit32();
-
-                ("f", width, capability_for_float_width(width))
-            }
-            _ => continue,
-        };
-
-        match maybe_required_cap {
-            Err(UnsupportedType) => {
-                sess.dcx()
-                    .err(format!("`{prefix}{width}` unsupported in SPIR-V"));
-            }
-            Ok(Some(required_cap)) if !declared_capabilities.contains(&required_cap) => {
-                missing_caps.push(format!(
-                    "`{prefix}{width}` type used without `OpCapability {required_cap:?}`"
-                ));
-            }
-            Ok(_) => {}
-        }
-    }
-
-    if !missing_caps.is_empty() {
-        let mut err = sess
-            .dcx()
-            .struct_err("missing required capabilities for types");
-        for msg in missing_caps {
-            err.note(msg);
-        }
-        Err(err.emit())
-    } else {
-        Ok(())
-    }
-}
-
 /// Remove type-related capabilities that are not required by any types in the module.
 ///
 /// This function specifically targets Int8, Int16, Int64, Float16, and Float64 capabilities,
 /// removing them if no types in the module require them. All other capabilities are preserved.
 /// This is part of the fix for issue #300 where constant casts were creating unnecessary types.
+//
+// FIXME(eddyb) move this to a SPIR-T pass (potentially even using sets of used
+// exts/caps that validation itself can collect while traversing the module).
 pub fn remove_unused_type_capabilities(module: &mut Module) {
     use rspirv::spirv::Capability;
 

crates/rustc_codegen_spirv/src/linker/spirt_passes/mod.rs

@@ -5,6 +5,7 @@ pub(crate) mod debuginfo;
 pub(crate) mod diagnostics;
 mod fuse_selects;
 mod reduce;
+pub(crate) mod validate;
 
 use lazy_static::lazy_static;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
@@ -63,7 +64,7 @@ macro_rules! def_spv_spec_with_extra_well_known {
                         let spv_spec = spv::spec::Spec::get();
                         let wk = &spv_spec.well_known;
 
-                        let decorations = match &spv_spec.operand_kinds[wk.Decoration] {
+                        let decorations = match wk.Decoration.def() {
                             spv::spec::OperandKindDef::ValueEnum { variants } => variants,
                             _ => unreachable!(),
                         };
@@ -101,7 +102,9 @@ def_spv_spec_with_extra_well_known! {
         OpCompositeExtract,
     ],
     operand_kind: spv::spec::OperandKind = [
+        Capability,
         ExecutionModel,
+        ImageFormat,
     ],
     decoration: u32 = [
         UserTypeGOOGLE,