Update for rspirv sdk-update branch API changes

Adapt to changes in rspirv 0.12.0+sdk-1.4.335.0:
- Replace `rspirv::grammar::reflect::is_type(op)` with `op.is_type()`
- Replace `rspirv::grammar::reflect::is_constant(op)` with `op.is_constant()`
- Update `type_float_id` to include FPEncoding parameter (None)
- Change `MemorySemantics::NONE` to `MemorySemantics::RELAXED`
- Change `Decoration::UserTypeGOOGLE` to `Decoration::UserSemantic`
- Update ExecutionMode NV suffixes to EXT/KHR (OutputLinesNV → OutputLinesEXT, etc.)
- Add aliases for DemoteToHelperInvocationEXT and IsHelperInvocationEXT
- Update ImageOperands and MemorySemantics KHR constants (now unified)
- Add stubs for new operand kinds (RawAccessChainOperands, CooperativeMatrixReduce, etc.)
- Update renamed ops (FinalizeNodePayloadsAMDX → EnqueueNodePayloadsAMDX, etc.)
- Add catch-all for new ops in spirv_type_constraints

Author: LegNeato

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -341,7 +341,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     fn ordering_to_semantics_def(&mut self, ordering: AtomicOrdering) -> SpirvValue {
         let mut invalid_seq_cst = false;
         let semantics = match ordering {
-            AtomicOrdering::Relaxed => MemorySemantics::NONE,
+            AtomicOrdering::Relaxed => MemorySemantics::RELAXED,
             AtomicOrdering::Acquire => MemorySemantics::MAKE_VISIBLE | MemorySemantics::ACQUIRE,
             AtomicOrdering::Release => MemorySemantics::MAKE_AVAILABLE | MemorySemantics::RELEASE,
             AtomicOrdering::AcqRel => {

crates/rustc_codegen_spirv/src/builder/spirv_asm.rs

@@ -32,9 +32,23 @@ pub struct InstructionTable {
 
 impl InstructionTable {
     pub fn new() -> Self {
-        let table = rspirv::grammar::CoreInstructionTable::iter()
+        let mut table: FxHashMap<_, _> = rspirv::grammar::CoreInstructionTable::iter()
             .map(|inst| (inst.opname, inst))
             .collect();
+
+        // Add aliases for EXT/KHR instructions whose suffixes were removed
+        for inst in rspirv::grammar::CoreInstructionTable::iter() {
+            match inst.opname {
+                "DemoteToHelperInvocation" => {
+                    table.insert("DemoteToHelperInvocationEXT", inst);
+                }
+                "IsHelperInvocation" => {
+                    table.insert("IsHelperInvocationEXT", inst);
+                }
+                _ => {}
+            }
+        }
+
         Self { table }
     }
 }
@@ -1529,6 +1543,32 @@ impl<'cx, 'tcx> Builder<'cx, 'tcx> {
                 Ok(x) => inst.operands.push(dr::Operand::StoreCacheControl(x)),
                 Err(()) => self.err(format!("unknown StoreCacheControl {word}")),
             },
+            // New operand kinds added in newer SPIR-V versions - not yet supported in inline asm
+            (OperandKind::RawAccessChainOperands, Some(word)) => {
+                self.err(format!("RawAccessChainOperands not yet supported: {word}"));
+            }
+            (OperandKind::CooperativeMatrixReduce, Some(word)) => {
+                self.err(format!("CooperativeMatrixReduce not yet supported: {word}"));
+            }
+            (OperandKind::TensorClampMode, Some(word)) => {
+                self.err(format!("TensorClampMode not yet supported: {word}"));
+            }
+            (OperandKind::TensorAddressingOperands, Some(word)) => {
+                self.err(format!("TensorAddressingOperands not yet supported: {word}"));
+            }
+            (OperandKind::FPEncoding, Some(word)) => {
+                self.err(format!("FPEncoding not yet supported: {word}"));
+            }
+            (OperandKind::NamedMaximumNumberOfRegisters, Some(word)) => {
+                self.err(format!("NamedMaximumNumberOfRegisters not yet supported: {word}"));
+            }
+            (OperandKind::MatrixMultiplyAccumulateOperands, Some(word)) => {
+                self.err(format!("MatrixMultiplyAccumulateOperands not yet supported: {word}"));
+            }
+            // Catch-all for any other new operand kinds
+            (kind, Some(word)) => {
+                self.err(format!("unsupported operand kind {kind:?}: {word}"));
+            }
             (kind, None) => match token {
                 Token::Word(_) => bug!(),
                 Token::String(_) => {
@@ -1565,14 +1605,14 @@ pub const IMAGE_OPERANDS: &[(&str, ImageOperands)] = &[
     ("MakeTexelAvailable", ImageOperands::MAKE_TEXEL_AVAILABLE),
     (
         "MakeTexelAvailableKHR",
-        ImageOperands::MAKE_TEXEL_AVAILABLE_KHR,
+        ImageOperands::MAKE_TEXEL_AVAILABLE,
     ),
     ("MakeTexelVisible", ImageOperands::MAKE_TEXEL_VISIBLE),
-    ("MakeTexelVisibleKHR", ImageOperands::MAKE_TEXEL_VISIBLE_KHR),
+    ("MakeTexelVisibleKHR", ImageOperands::MAKE_TEXEL_VISIBLE),
     ("NonPrivateTexel", ImageOperands::NON_PRIVATE_TEXEL),
-    ("NonPrivateTexelKHR", ImageOperands::NON_PRIVATE_TEXEL_KHR),
+    ("NonPrivateTexelKHR", ImageOperands::NON_PRIVATE_TEXEL),
     ("VolatileTexel", ImageOperands::VOLATILE_TEXEL),
-    ("VolatileTexelKHR", ImageOperands::VOLATILE_TEXEL_KHR),
+    ("VolatileTexelKHR", ImageOperands::VOLATILE_TEXEL),
     ("SignExtend", ImageOperands::SIGN_EXTEND),
     ("ZeroExtend", ImageOperands::ZERO_EXTEND),
 ];
@@ -1610,7 +1650,7 @@ pub const FUNCTION_CONTROL: &[(&str, FunctionControl)] = &[
 ];
 pub const MEMORY_SEMANTICS: &[(&str, MemorySemantics)] = &[
     ("Relaxed", MemorySemantics::RELAXED),
-    ("None", MemorySemantics::NONE),
+    ("None", MemorySemantics::RELAXED),
     ("Acquire", MemorySemantics::ACQUIRE),
     ("Release", MemorySemantics::RELEASE),
     ("AcquireRelease", MemorySemantics::ACQUIRE_RELEASE),
@@ -1631,11 +1671,11 @@ pub const MEMORY_SEMANTICS: &[(&str, MemorySemantics)] = &[
     ),
     ("ImageMemory", MemorySemantics::IMAGE_MEMORY),
     ("OutputMemory", MemorySemantics::OUTPUT_MEMORY),
-    ("OutputMemoryKHR", MemorySemantics::OUTPUT_MEMORY_KHR),
+    ("OutputMemoryKHR", MemorySemantics::OUTPUT_MEMORY),
     ("MakeAvailable", MemorySemantics::MAKE_AVAILABLE),
-    ("MakeAvailableKHR", MemorySemantics::MAKE_AVAILABLE_KHR),
+    ("MakeAvailableKHR", MemorySemantics::MAKE_AVAILABLE),
     ("MakeVisible", MemorySemantics::MAKE_VISIBLE),
-    ("MakeVisibleKHR", MemorySemantics::MAKE_VISIBLE_KHR),
+    ("MakeVisibleKHR", MemorySemantics::MAKE_VISIBLE),
     ("Volatile", MemorySemantics::VOLATILE),
 ];
 pub const MEMORY_ACCESS: &[(&str, MemoryAccess)] = &[
@@ -1646,17 +1686,17 @@ pub const MEMORY_ACCESS: &[(&str, MemoryAccess)] = &[
     ("MakePointerAvailable", MemoryAccess::MAKE_POINTER_AVAILABLE),
     (
         "MakePointerAvailableKHR",
-        MemoryAccess::MAKE_POINTER_AVAILABLE_KHR,
+        MemoryAccess::MAKE_POINTER_AVAILABLE,
     ),
     ("MakePointerVisible", MemoryAccess::MAKE_POINTER_VISIBLE),
     (
         "MakePointerVisibleKHR",
-        MemoryAccess::MAKE_POINTER_VISIBLE_KHR,
+        MemoryAccess::MAKE_POINTER_VISIBLE,
     ),
     ("NonPrivatePointer", MemoryAccess::NON_PRIVATE_POINTER),
     (
         "NonPrivatePointerKHR",
-        MemoryAccess::NON_PRIVATE_POINTER_KHR,
+        MemoryAccess::NON_PRIVATE_POINTER,
     ),
 ];
 pub const KERNEL_PROFILING_INFO: &[(&str, KernelProfilingInfo)] = &[

crates/rustc_codegen_spirv/src/custom_decorations.rs

@@ -18,7 +18,7 @@ use std::{fmt, iter, slice, str};
 
 /// Decorations not native to SPIR-V require some form of encoding into existing
 /// SPIR-V constructs, for which we use `OpDecorateString` with decoration type
-/// `UserTypeGOOGLE` and some encoded Rust value as the decoration string.
+/// `UserSemantic` and some encoded Rust value as the decoration string.
 ///
 /// Each decoration type has to implement this trait, and use a different
 /// `ENCODING_PREFIX` from any other decoration type, to disambiguate them.
@@ -27,7 +27,10 @@ use std::{fmt, iter, slice, str};
 /// ideally as soon as they're no longer needed, because no other tools
 /// processing the SPIR-V would understand them correctly.
 ///
-/// TODO: uses `non_semantic` instead of piggybacking off of `UserTypeGOOGLE`
+/// Custom decorations are encoded using `OpDecorateString` with `UserSemantic`,
+/// which is a standard SPIR-V decoration that doesn't require any extension.
+///
+/// TODO: consider using `non_semantic` instead for even cleaner separation
 /// <https://htmlpreview.github.io/?https://github.com/KhronosGroup/SPIRV-Registry/blob/master/extensions/KHR/SPV_KHR_non_semantic_info.html>
 pub trait CustomDecoration<'a>: Sized {
     const ENCODING_PREFIX: &'static str;
@@ -45,15 +48,15 @@ pub trait CustomDecoration<'a>: Sized {
             None,
             vec![
                 Operand::IdRef(id),
-                Operand::Decoration(Decoration::UserTypeGOOGLE),
+                Operand::Decoration(Decoration::UserSemantic),
                 Operand::LiteralString(encoded),
             ],
         )
     }
 
     fn try_decode_from_inst(inst: &Instruction) -> Option<(Word, LazilyDecoded<'_, Self>)> {
         if inst.class.opcode == Op::DecorateString
-            && inst.operands[1].unwrap_decoration() == Decoration::UserTypeGOOGLE
+            && inst.operands[1].unwrap_decoration() == Decoration::UserSemantic
         {
             let id = inst.operands[0].unwrap_id_ref();
             let prefixed_encoded = inst.operands[2].unwrap_literal_string();

crates/rustc_codegen_spirv/src/linker/inline.rs

@@ -298,8 +298,8 @@ impl LegalGlobal {
             let global = match inst.class.opcode {
                 Op::TypePointer => Self::TypePointer(inst.operands[0].unwrap_storage_class()),
                 Op::Variable => Self::Variable,
-                op if rspirv::grammar::reflect::is_type(op) => Self::TypeNonPointer,
-                op if rspirv::grammar::reflect::is_constant(op) => Self::Const,
+                op if op.is_type() => Self::TypeNonPointer,
+                op if op.is_constant() => Self::Const,
 
                 // FIXME(eddyb) should this be `unreachable!()`?
                 _ => continue,

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

@@ -128,7 +128,7 @@ fn try_decode_custom_decoration<'a, D: CustomDecoration<'a>>(
         };
         let str_imms = spv_inst
             .imms
-            .strip_prefix(&[spv::Imm::Short(wk.Decoration, wk.UserTypeGOOGLE)])?;
+            .strip_prefix(&[spv::Imm::Short(wk.Decoration, wk.UserSemantic)])?;
 
         decode_spv_lit_str_with(str_imms, |prefixed_encoded| {
             let encoded = prefixed_encoded.strip_prefix(D::ENCODING_PREFIX)?;

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

@@ -113,7 +113,7 @@ def_spv_spec_with_extra_well_known! {
         MemoryAccess,
     ],
     decoration: u32 = [
-        UserTypeGOOGLE,
+        UserSemantic,
         MatrixStride,
     ],
     storage_class: u32 = [

crates/rustc_codegen_spirv/src/spirv_type.rs

@@ -104,7 +104,7 @@ impl SpirvType<'_> {
             Self::Void => cx.emit_global().type_void_id(id),
             Self::Bool => cx.emit_global().type_bool_id(id),
             Self::Integer(width, signed) => cx.emit_global().type_int_id(id, width, signed as u32),
-            Self::Float(width) => cx.emit_global().type_float_id(id, width),
+            Self::Float(width) => cx.emit_global().type_float_id(id, width, None),
             Self::Adt {
                 def_id: _,
                 align: _,

crates/rustc_codegen_spirv/src/spirv_type_constraints.rs

@@ -1096,9 +1096,9 @@ pub fn instruction_signatures(op: Op) -> Option<&'static [InstSig<'static>]> {
         | Op::ImageBlockMatchSSDQCOM
         | Op::ImageBlockMatchSADQCOM => reserved!(SPV_QCOM_image_processing),
         // SPV_AMDX_shader_enqueue
-        Op::FinalizeNodePayloadsAMDX
+        Op::EnqueueNodePayloadsAMDX
         | Op::FinishWritingNodePayloadAMDX
-        | Op::InitializeNodePayloadsAMDX => reserved!(SPV_AMDX_shader_enqueue),
+        | Op::AllocateNodePayloadsAMDX => reserved!(SPV_AMDX_shader_enqueue),
         // SPV_NV_displacement_micromap
         Op::FetchMicroTriangleVertexPositionNV | Op::FetchMicroTriangleVertexBarycentricNV => {
             reserved!(SPV_NV_displacement_micromap)
@@ -1124,6 +1124,8 @@ pub fn instruction_signatures(op: Op) -> Option<&'static [InstSig<'static>]> {
         | Op::SpecConstantCompositeContinuedINTEL
         | Op::ControlBarrierArriveINTEL
         | Op::ControlBarrierWaitINTEL => reserved!(unknown_extension_INTEL),
+        // Catch-all for any new ops added in newer SPIR-V versions
+        _ => return None,
     }
 
     None

crates/rustc_codegen_spirv/src/symbols.rs

@@ -271,10 +271,10 @@ const EXECUTION_MODES: &[(&str, ExecutionMode, ExecutionModeExtraDim)] = {
         ("rounding_mode_rte", RoundingModeRTE, Value),
         ("rounding_mode_rtz", RoundingModeRTZ, Value),
         ("stencil_ref_replacing_ext", StencilRefReplacingEXT, None),
-        ("output_lines_nv", OutputLinesNV, None),
-        ("output_primitives_nv", OutputPrimitivesNV, Value),
-        ("derivative_group_quads_nv", DerivativeGroupQuadsNV, None),
-        ("output_triangles_nv", OutputTrianglesNV, None),
+        ("output_lines_nv", OutputLinesEXT, None),
+        ("output_primitives_nv", OutputPrimitivesEXT, Value),
+        ("derivative_group_quads_nv", DerivativeGroupQuadsKHR, None),
+        ("output_triangles_nv", OutputTrianglesEXT, None),
         ("output_lines_ext", ExecutionMode::OutputLinesEXT, None),
         (
             "output_triangles_ext",