Add rich validation error messages with source spans

Improve spirv-val error messages by looking up source locations from
SrcLocDecoration annotations:
- Add validation_err.rs module to parse validation errors and look up
  source spans from the SPIR-V module's custom SrcLocDecoration
- Strip SrcLocDecoration and ZombieDecoration before validation (these
  are invalid on functions) but keep the original module for span lookup
- Add --preserve-debug-decorations flag to optionally keep decorations
- Add SrcLocDecoration to entry point interface variables so validation
  errors for conflicting locations show the relevant source spans
- Keep decorations in linker output (they're stripped after validation)
For location conflict errors, the error message now shows:
- The specific variable causing the conflict with its source location
- The conflicting variable with its source location
- A help message explaining why the conflict occurs (e.g., Mat4 uses 4 locations)

Author: LegNeato

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -6,6 +6,7 @@ use crate::abi::ConvSpirvType;
 use crate::attr::{AggregatedSpirvAttributes, Entry, Spanned, SpecConstant};
 use crate::builder::Builder;
 use crate::builder_spirv::{SpirvFunctionCursor, SpirvValue, SpirvValueExt};
+use crate::custom_decorations::{CustomDecoration, SrcLocDecoration};
 use crate::spirv_type::SpirvType;
 use rspirv::dr::Operand;
 use rspirv::spirv::{
@@ -987,6 +988,14 @@ impl<'tcx> CodegenCx<'tcx> {
                 self.emit_global()
                     .variable(var_ptr_spirv_type, Some(var), storage_class, None);
 
+                // Add SrcLocDecoration to the variable for rich error messages.
+                let src_loc_inst = SrcLocDecoration::from_rustc_span(hir_param.span, &self.builder)
+                    .map(|src_loc| src_loc.encode_to_inst(var));
+                self.emit_global()
+                    .module_mut()
+                    .annotations
+                    .extend(src_loc_inst);
+
                 // Record this `OpVariable` as needing to be added (if applicable),
                 // to the *Interface* operands of the `OpEntryPoint` instruction.
                 if self.emit_global().version().unwrap() > (1, 3) {

crates/rustc_codegen_spirv/src/codegen_cx/mod.rs

@@ -313,6 +313,10 @@ pub struct CodegenArgs {
 
     pub run_spirv_opt: bool,
 
+    /// Preserve internal debug decorations (SrcLocDecoration, ZombieDecoration) in the output.
+    /// These are normally stripped after validation. Enable for debugging or testing.
+    pub preserve_debug_decorations: bool,
+
     /// All options pertinent to `rustc_codegen_spirv::linker` specifically.
     //
     // FIXME(eddyb) should these be handled as `-C linker-args="..."` instead?
@@ -384,6 +388,12 @@ impl CodegenArgs {
             "disables running spirv-opt on the final output",
         );
 
+        opts.optflag(
+            "",
+            "preserve-debug-decorations",
+            "preserve internal debug decorations (SrcLocDecoration, ZombieDecoration) in the output",
+        );
+
         opts.optflag(
             "",
             "preserve-bindings",
@@ -652,6 +662,8 @@ impl CodegenArgs {
 
             run_spirv_opt,
 
+            preserve_debug_decorations: matches.opt_present("preserve-debug-decorations"),
+
             linker_opts,
 
             // NOTE(eddyb) these are debugging options that used to be env vars

crates/rustc_codegen_spirv/src/lib.rs

@@ -138,6 +138,7 @@ mod spirv_type_constraints;
 mod symbols;
 mod target;
 mod target_feature;
+mod validation_err;
 
 use builder::Builder;
 use codegen_cx::CodegenCx;

crates/rustc_codegen_spirv/src/link.rs

@@ -253,8 +253,27 @@ fn post_link_single_module(
     out_filename: &Path,
     dump_prefix: Option<&OsStr>,
 ) {
-    cg_args.do_disassemble(&module);
-    let spv_binary = module.assemble();
+    use crate::custom_decorations::{CustomDecoration, SrcLocDecoration, ZombieDecoration};
+
+    // Strip internal debug decorations (SrcLocDecoration, ZombieDecoration) BEFORE
+    // disassembly/validation/optimization unless preserve_debug_decorations is set.
+    // These decorations are only valid on certain targets (variables), but rust-gpu
+    // also places them on functions for span tracking which is invalid SPIR-V.
+    // Keep the original module for span lookup in error messages.
+    let (module_for_output, original_module_for_spans) = if cg_args.preserve_debug_decorations {
+        // When preserving decorations, use the same module for both
+        (module.clone(), module)
+    } else {
+        let mut stripped = module.clone();
+        SrcLocDecoration::remove_all(&mut stripped);
+        ZombieDecoration::remove_all(&mut stripped);
+        (stripped, module)
+    };
+
+    // Disassemble the stripped module (unless preserving decorations)
+    cg_args.do_disassemble(&module_for_output);
+    let spv_binary = module_for_output.assemble();
+    let original_binary_for_spans = original_module_for_spans.assemble();
 
     if let Some(dir) = &cg_args.dump_post_link {
         // FIXME(eddyb) rename `filename` with `file_path` to make this less confusing.
@@ -305,7 +324,7 @@ fn post_link_single_module(
     };
 
     if cg_args.run_spirv_val {
-        do_spirv_val(sess, &spv_binary, out_filename, val_options);
+        do_spirv_val(sess, &spv_binary, &original_binary_for_spans, out_filename, val_options);
     }
 
     {
@@ -393,18 +412,25 @@ fn do_spirv_opt(
 fn do_spirv_val(
     sess: &Session,
     spv_binary: &[u32],
+    original_binary_for_spans: &[u32],
     filename: &Path,
     options: spirv_tools::val::ValidatorOptions,
 ) {
+    use crate::validation_err::ValidationErrorContext;
     use spirv_tools::val::{self, Validator};
 
     let validator = val::create(sess.target.options.env.parse().ok());
 
     if let Err(e) = validator.validate(spv_binary, Some(options)) {
-        let mut err = sess.dcx().struct_err(e.to_string());
-        err.note("spirv-val failed");
-        err.note(format!("module `{}`", filename.display()));
-        err.emit();
+        // Parse the ORIGINAL binary (with SrcLocDecoration) to look up source spans
+        // Note: We validate the stripped binary, but look up spans in the original
+        let module = with_rspirv_loader(|loader| {
+            rspirv::binary::parse_words(original_binary_for_spans, loader)
+        })
+        .ok();
+
+        let mut ctx = ValidationErrorContext::new(sess, module.as_ref(), filename);
+        ctx.emit_error(&e);
     }
 }
 

crates/rustc_codegen_spirv/src/linker/mod.rs

@@ -19,7 +19,7 @@ mod zombies;
 use std::borrow::Cow;
 
 use crate::codegen_cx::{ModuleOutputType, SpirvMetadata};
-use crate::custom_decorations::{CustomDecoration, SrcLocDecoration, ZombieDecoration};
+// Note: SrcLocDecoration and ZombieDecoration are stripped in link.rs after validation
 use crate::custom_insts;
 use either::Either;
 use rspirv::binary::Assemble;
@@ -768,13 +768,10 @@ pub fn link(
             output.header.as_mut().unwrap().bound = simple_passes::compact_ids(output);
         };
 
-        // FIXME(eddyb) convert these into actual `OpLine`s with a SPIR-T pass,
-        // but that'd require keeping the modules in SPIR-T form (once lowered),
-        // and never loading them back into `rspirv` once lifted back to SPIR-V.
-        SrcLocDecoration::remove_all(output);
-
-        // FIXME(eddyb) might make more sense to rewrite these away on SPIR-T.
-        ZombieDecoration::remove_all(output);
+        // NOTE: We keep SrcLocDecoration and ZombieDecoration in the module
+        // so that they can be used for rich error messages during validation.
+        // These are encoded as OpDecorateString with UserSemantic, which is
+        // valid SPIR-V and should not cause validation failures.
     }
 
     Ok(output)