Regenerate on sdk-1.4.328.1

autogen/src/sr.rs

@@ -491,7 +491,7 @@ pub fn gen_sr_code_from_instruction_grammar(
     };
 
     let ops = quote! {
-        use crate::sr::{module::Jump, storage::Token, Type};
+        use crate::sr::{module::Jump, storage::Token, Constant, Type};
 
         #[derive(Clone, Debug, Eq, PartialEq)]
         pub enum Branch {

autogen/src/structs.rs

@@ -153,6 +153,8 @@ pub enum Class {
     DeviceSideEnqueue,
     #[serde(rename = "Non-Uniform")]
     NonUniform,
+    Tensor,
+    Graph,
     Reserved,
     #[serde(rename = "@exclude")]
     Exclude,

rspirv/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rspirv"
-version = "0.12.0+sdk-1.4.309.0"
+version = "0.12.0+sdk-1.4.321.0"
 authors = ["Lei Zhang <[email protected]>"]
 edition = "2018"
 

rspirv/binary/assemble.rs

@@ -94,6 +94,7 @@ impl Assemble for dr::Operand {
             Self::CooperativeMatrixReduce(v) => result.push(v.bits()),
             Self::TensorClampMode(v) => result.push(v as u32),
             Self::TensorAddressingOperands(v) => result.push(v.bits()),
+            Self::TensorOperands(v) => result.push(v.bits()),
             Self::InitializationModeQualifier(v) => result.push(v as u32),
             Self::LoadCacheControl(v) => result.push(v as u32),
             Self::StoreCacheControl(v) => result.push(v as u32),

rspirv/binary/autogen_decode_operand.rs

@@ -602,4 +602,15 @@ impl Decoder<'_> {
             Err(Error::StreamExpected(self.offset))
         }
     }
+    #[doc = "Decodes and returns the next SPIR-V word as\na SPIR-V TensorOperands value."]
+    pub fn tensor_operands(&mut self) -> Result<spirv::TensorOperands> {
+        if let Ok(word) = self.word() {
+            spirv::TensorOperands::from_bits(word).ok_or(Error::TensorOperandsUnknown(
+                self.offset - WORD_NUM_BYTES,
+                word,
+            ))
+        } else {
+            Err(Error::StreamExpected(self.offset))
+        }
+    }
 }

rspirv/binary/autogen_disas_operand.rs

@@ -481,3 +481,27 @@ impl Disassemble for spirv::MatrixMultiplyAccumulateOperands {
         bits.join("|")
     }
 }
+impl Disassemble for spirv::TensorOperands {
+    fn disassemble(&self) -> String {
+        if self.is_empty() {
+            return "None".to_string();
+        }
+        let mut bits = vec![];
+        if self.contains(spirv::TensorOperands::NONTEMPORAL_ARM) {
+            bits.push("NontemporalARM")
+        }
+        if self.contains(spirv::TensorOperands::OUT_OF_BOUNDS_VALUE_ARM) {
+            bits.push("OutOfBoundsValueARM")
+        }
+        if self.contains(spirv::TensorOperands::MAKE_ELEMENT_AVAILABLE_ARM) {
+            bits.push("MakeElementAvailableARM")
+        }
+        if self.contains(spirv::TensorOperands::MAKE_ELEMENT_VISIBLE_ARM) {
+            bits.push("MakeElementVisibleARM")
+        }
+        if self.contains(spirv::TensorOperands::NON_PRIVATE_ELEMENT_ARM) {
+            bits.push("NonPrivateElementARM")
+        }
+        bits.join("|")
+    }
+}

rspirv/binary/autogen_error.rs

@@ -65,6 +65,7 @@ pub enum Error {
     FPEncodingUnknown(usize, spirv::Word),
     CooperativeVectorMatrixLayoutUnknown(usize, spirv::Word),
     ComponentTypeUnknown(usize, spirv::Word),
+    TensorOperandsUnknown(usize, spirv::Word),
     #[doc = r"Failed to decode a string."]
     #[doc = r""]
     #[doc = r"For structured error handling, the second element could be"]
@@ -359,6 +360,11 @@ impl fmt::Display for Error {
                 "unknown value {} for operand kind ComponentType at index {}",
                 word, index
             ),
+            Error::TensorOperandsUnknown(index, word) => write!(
+                f,
+                "unknown value {} for operand kind TensorOperands at index {}",
+                word, index
+            ),
             Error::DecodeStringFailed(index, ref e) => {
                 write!(f, "cannot decode string at index {}: {}", index, e)
             }

rspirv/binary/autogen_parse_operand.rs

@@ -198,6 +198,12 @@ impl Parser<'_, '_> {
                 ops.append(&mut self.parse_tensor_addressing_operands_arguments(val)?);
                 ops
             }
+            GOpKind::TensorOperands => {
+                let val = self.decoder.tensor_operands()?;
+                let mut ops = vec![dr::Operand::TensorOperands(val)];
+                ops.append(&mut self.parse_tensor_operands_arguments(val)?);
+                ops
+            }
             GOpKind::IdResultType => panic!(),
             GOpKind::IdResult => panic!(),
             GOpKind::LiteralContextDependentNumber => panic!(),
@@ -380,6 +386,11 @@ impl Parser<'_, '_> {
             spirv::ExecutionMode::RoundingModeRTZ => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
+            spirv::ExecutionMode::TileShadingRateQCOM => vec![
+                dr::Operand::LiteralBit32(self.decoder.bit32()?),
+                dr::Operand::LiteralBit32(self.decoder.bit32()?),
+                dr::Operand::LiteralBit32(self.decoder.bit32()?),
+            ],
             spirv::ExecutionMode::IsApiEntryAMDX => vec![dr::Operand::IdRef(self.decoder.id()?)],
             spirv::ExecutionMode::MaxNodeRecursionAMDX => {
                 vec![dr::Operand::IdRef(self.decoder.id()?)]
@@ -649,6 +660,7 @@ impl Parser<'_, '_> {
             spirv::Decoration::ImplementInRegisterMapINTEL => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
+            spirv::Decoration::ConditionalINTEL => vec![dr::Operand::IdRef(self.decoder.id()?)],
             spirv::Decoration::CacheControlLoadINTEL => vec![
                 dr::Operand::LiteralBit32(self.decoder.bit32()?),
                 dr::Operand::LoadCacheControl(self.decoder.load_cache_control()?),
@@ -673,4 +685,20 @@ impl Parser<'_, '_> {
         }
         Ok(params)
     }
+    fn parse_tensor_operands_arguments(
+        &mut self,
+        tensor_operands: spirv::TensorOperands,
+    ) -> Result<Vec<dr::Operand>> {
+        let mut params = vec![];
+        if tensor_operands.contains(spirv::TensorOperands::OUT_OF_BOUNDS_VALUE_ARM) {
+            params.append(&mut vec![dr::Operand::IdRef(self.decoder.id()?)]);
+        }
+        if tensor_operands.contains(spirv::TensorOperands::MAKE_ELEMENT_AVAILABLE_ARM) {
+            params.append(&mut vec![dr::Operand::IdRef(self.decoder.id()?)]);
+        }
+        if tensor_operands.contains(spirv::TensorOperands::MAKE_ELEMENT_VISIBLE_ARM) {
+            params.append(&mut vec![dr::Operand::IdRef(self.decoder.id()?)]);
+        }
+        Ok(params)
+    }
 }