Regenerate on sdk-1.3.296.0

.github/workflows/publish.yaml

@@ -3,6 +3,7 @@ name: Publish
 on:
   push:
     tags:
+       - '**'
     paths: "**/Cargo.toml"
 
 concurrency:

autogen/Cargo.toml

@@ -6,7 +6,6 @@ authors = [
 	"Lei Zhang <[email protected]>",
 ]
 edition = "2018"
-rust-version = "1.58"
 
 publish = false
 

autogen/src/dr.rs

@@ -391,7 +391,7 @@ pub fn gen_dr_operand_kinds(grammar: &[structs::OperandKind]) -> TokenStream {
                 let mut seen_discriminator = BTreeMap::new();
 
                 for e in enumerators {
-                    if seen_discriminator.get(&e.value).is_none() {
+                    if let std::collections::btree_map::Entry::Vacant(seen_entry) = seen_discriminator.entry(e.value) {
                         let name = match category {
                             structs::Category::BitEnum => {
                                 use heck::ShoutySnakeCase;
@@ -412,7 +412,7 @@ pub fn gen_dr_operand_kinds(grammar: &[structs::OperandKind]) -> TokenStream {
                             _ => panic!("Unexpected operand type"),
                         };
 
-                        seen_discriminator.insert(e.value, name.clone());
+                        seen_entry.insert(name.clone());
 
                         capability_clauses
                             .entry(&e.capabilities)

autogen/src/header.rs

@@ -51,18 +51,20 @@ fn generate_enum(
         .iter()
         .map(|(number, name)| quote! { #name = #number });
 
-    // Each item is a tuple indicating an inclusive range as opposed to an exclusive range like is
-    // common.
-    let mut number_runs = vec![(variants[0].0, variants[0].0)];
-    for &(number, _) in variants.iter().skip(1) {
-        let last_run = number_runs.last_mut().unwrap();
-        match number.cmp(&(last_run.1 + 1)) {
-            Ordering::Equal => last_run.1 = number,
-            Ordering::Greater => number_runs.push((number, number)),
-            Ordering::Less => unreachable!("Variants not sorted by discriminant"),
+    // Each item is a tuple indicating an inclusive range as opposed to an exclusive range like
+    // is common.
+    let mut number_runs = Vec::<(u32, u32)>::new();
+    for &(number, _) in variants.iter() {
+        if let Some(last_run) = number_runs.last_mut() {
+            match number.cmp(&(last_run.1 + 1)) {
+                Ordering::Equal => last_run.1 = number,
+                Ordering::Greater => number_runs.push((number, number)),
+                Ordering::Less => unreachable!("Variants not sorted by discriminant"),
+            }
+        } else {
+            number_runs.push((number, number));
         }
     }
-
     // We try to check if the given number is within a run of valid discriminants and if so
     // transmute the number directly to the enum type.
     let from_prim = number_runs
@@ -77,11 +79,16 @@ fn generate_enum(
         })
         .collect::<Vec<_>>();
 
+    // At least one variant is required for repr(u32).  Generate a Max member like Spirv-Headers
+    // tooling does.
+    let empty_enum = variants.is_empty().then_some(quote!(Max = 0x7fffffff));
+
     let attribute = value_enum_attribute();
     quote! {
         #[doc = #comment]
         #attribute
         pub enum #enum_name {
+            #empty_enum
             #(#enumerants),*
         }
 

rspirv/Cargo.toml

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

rspirv/binary/assemble.rs

@@ -94,6 +94,9 @@ impl Assemble for dr::Operand {
             Self::InitializationModeQualifier(v) => result.push(v as u32),
             Self::LoadCacheControl(v) => result.push(v as u32),
             Self::StoreCacheControl(v) => result.push(v as u32),
+            Self::RawAccessChainOperands(v) => result.push(v.bits()),
+            Self::NamedMaximumNumberOfRegisters(v) => result.push(v as u32),
+            Self::FPEncoding(v) => result.push(v as u32),
         }
     }
 }
@@ -321,7 +324,7 @@ mod tests {
     fn test_assemble_function_parameters() {
         let mut b = dr::Builder::new();
         b.memory_model(spirv::AddressingModel::Logical, spirv::MemoryModel::Simple);
-        let float = b.type_float(32);
+        let float = b.type_float(32, None);
         let ptr = b.type_pointer(None, spirv::StorageClass::Function, float);
         let fff = b.type_function(float, vec![float, float]);
         b.begin_function(float, None, spirv::FunctionControl::CONST, fff)

rspirv/binary/autogen_decode_operand.rs

@@ -111,6 +111,16 @@ impl<'a> Decoder<'a> {
             Err(Error::StreamExpected(self.offset))
         }
     }
+    #[doc = "Decodes and returns the next SPIR-V word as\na SPIR-V RawAccessChainOperands value."]
+    pub fn raw_access_chain_operands(&mut self) -> Result<spirv::RawAccessChainOperands> {
+        if let Ok(word) = self.word() {
+            spirv::RawAccessChainOperands::from_bits(word).ok_or(
+                Error::RawAccessChainOperandsUnknown(self.offset - WORD_NUM_BYTES, word),
+            )
+        } else {
+            Err(Error::StreamExpected(self.offset))
+        }
+    }
     #[doc = "Decodes and returns the next SPIR-V word as\na SPIR-V SourceLanguage value."]
     pub fn source_language(&mut self) -> Result<spirv::SourceLanguage> {
         if let Ok(word) = self.word() {
@@ -505,4 +515,25 @@ impl<'a> Decoder<'a> {
             Err(Error::StreamExpected(self.offset))
         }
     }
+    #[doc = "Decodes and returns the next SPIR-V word as\na SPIR-V NamedMaximumNumberOfRegisters value."]
+    pub fn named_maximum_number_of_registers(
+        &mut self,
+    ) -> Result<spirv::NamedMaximumNumberOfRegisters> {
+        if let Ok(word) = self.word() {
+            spirv::NamedMaximumNumberOfRegisters::from_u32(word).ok_or(
+                Error::NamedMaximumNumberOfRegistersUnknown(self.offset - WORD_NUM_BYTES, word),
+            )
+        } else {
+            Err(Error::StreamExpected(self.offset))
+        }
+    }
+    #[doc = "Decodes and returns the next SPIR-V word as\na SPIR-V FPEncoding value."]
+    pub fn fp_encoding(&mut self) -> Result<spirv::FPEncoding> {
+        if let Ok(word) = self.word() {
+            spirv::FPEncoding::from_u32(word)
+                .ok_or(Error::FPEncodingUnknown(self.offset - WORD_NUM_BYTES, word))
+        } else {
+            Err(Error::StreamExpected(self.offset))
+        }
+    }
 }

rspirv/binary/autogen_disas_operand.rs

@@ -92,12 +92,21 @@ impl Disassemble for spirv::FPFastMathMode {
         if self.contains(spirv::FPFastMathMode::FAST) {
             bits.push("Fast")
         }
+        if self.contains(spirv::FPFastMathMode::ALLOW_CONTRACT) {
+            bits.push("AllowContract")
+        }
         if self.contains(spirv::FPFastMathMode::ALLOW_CONTRACT_FAST_INTEL) {
             bits.push("AllowContractFastINTEL")
         }
+        if self.contains(spirv::FPFastMathMode::ALLOW_REASSOC) {
+            bits.push("AllowReassoc")
+        }
         if self.contains(spirv::FPFastMathMode::ALLOW_REASSOC_INTEL) {
             bits.push("AllowReassocINTEL")
         }
+        if self.contains(spirv::FPFastMathMode::ALLOW_TRANSFORM) {
+            bits.push("AllowTransform")
+        }
         bits.join("|")
     }
 }
@@ -383,6 +392,21 @@ impl Disassemble for spirv::FragmentShadingRate {
         bits.join("|")
     }
 }
+impl Disassemble for spirv::RawAccessChainOperands {
+    fn disassemble(&self) -> String {
+        if self.is_empty() {
+            return "None".to_string();
+        }
+        let mut bits = vec![];
+        if self.contains(spirv::RawAccessChainOperands::ROBUSTNESS_PER_COMPONENT_NV) {
+            bits.push("RobustnessPerComponentNV")
+        }
+        if self.contains(spirv::RawAccessChainOperands::ROBUSTNESS_PER_ELEMENT_NV) {
+            bits.push("RobustnessPerElementNV")
+        }
+        bits.join("|")
+    }
+}
 impl Disassemble for spirv::CooperativeMatrixOperands {
     fn disassemble(&self) -> String {
         if self.is_empty() {

rspirv/binary/autogen_error.rs

@@ -19,6 +19,7 @@ pub enum Error {
     KernelProfilingInfoUnknown(usize, spirv::Word),
     RayFlagsUnknown(usize, spirv::Word),
     FragmentShadingRateUnknown(usize, spirv::Word),
+    RawAccessChainOperandsUnknown(usize, spirv::Word),
     SourceLanguageUnknown(usize, spirv::Word),
     ExecutionModelUnknown(usize, spirv::Word),
     AddressingModelUnknown(usize, spirv::Word),
@@ -56,6 +57,8 @@ pub enum Error {
     InitializationModeQualifierUnknown(usize, spirv::Word),
     LoadCacheControlUnknown(usize, spirv::Word),
     StoreCacheControlUnknown(usize, spirv::Word),
+    NamedMaximumNumberOfRegistersUnknown(usize, spirv::Word),
+    FPEncodingUnknown(usize, spirv::Word),
     #[doc = r"Failed to decode a string."]
     #[doc = r""]
     #[doc = r"For structured error handling, the second element could be"]
@@ -120,6 +123,11 @@ impl fmt::Display for Error {
                 "unknown value {} for operand kind FragmentShadingRate at index {}",
                 word, index
             ),
+            Error::RawAccessChainOperandsUnknown(index, word) => write!(
+                f,
+                "unknown value {} for operand kind RawAccessChainOperands at index {}",
+                word, index
+            ),
             Error::SourceLanguageUnknown(index, word) => write!(
                 f,
                 "unknown value {} for operand kind SourceLanguage at index {}",
@@ -305,6 +313,16 @@ impl fmt::Display for Error {
                 "unknown value {} for operand kind StoreCacheControl at index {}",
                 word, index
             ),
+            Error::NamedMaximumNumberOfRegistersUnknown(index, word) => write!(
+                f,
+                "unknown value {} for operand kind NamedMaximumNumberOfRegisters at index {}",
+                word, index
+            ),
+            Error::FPEncodingUnknown(index, word) => write!(
+                f,
+                "unknown value {} for operand kind FPEncoding at index {}",
+                word, index
+            ),
             Error::DecodeStringFailed(index, ref e) => {
                 write!(f, "cannot decode string at index {}: {}", index, e)
             }

rspirv/binary/autogen_parse_operand.rs

@@ -24,6 +24,9 @@ impl<'c, 'd> Parser<'c, 'd> {
             GOpKind::FragmentShadingRate => vec![dr::Operand::FragmentShadingRate(
                 self.decoder.fragment_shading_rate()?,
             )],
+            GOpKind::RawAccessChainOperands => vec![dr::Operand::RawAccessChainOperands(
+                self.decoder.raw_access_chain_operands()?,
+            )],
             GOpKind::SourceLanguage => {
                 vec![dr::Operand::SourceLanguage(self.decoder.source_language()?)]
             }
@@ -117,6 +120,12 @@ impl<'c, 'd> Parser<'c, 'd> {
             GOpKind::StoreCacheControl => vec![dr::Operand::StoreCacheControl(
                 self.decoder.store_cache_control()?,
             )],
+            GOpKind::NamedMaximumNumberOfRegisters => {
+                vec![dr::Operand::NamedMaximumNumberOfRegisters(
+                    self.decoder.named_maximum_number_of_registers()?,
+                )]
+            }
+            GOpKind::FPEncoding => vec![dr::Operand::FPEncoding(self.decoder.fp_encoding()?)],
             GOpKind::IdMemorySemantics => vec![dr::Operand::IdMemorySemantics(self.decoder.id()?)],
             GOpKind::IdScope => vec![dr::Operand::IdScope(self.decoder.id()?)],
             GOpKind::IdRef => vec![dr::Operand::IdRef(self.decoder.id()?)],
@@ -361,7 +370,7 @@ impl<'c, 'd> Parser<'c, 'd> {
                 dr::Operand::IdRef(self.decoder.id()?),
                 dr::Operand::IdRef(self.decoder.id()?),
             ],
-            spirv::ExecutionMode::OutputPrimitivesNV => {
+            spirv::ExecutionMode::OutputPrimitivesEXT => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
             spirv::ExecutionMode::SharedLocalMemorySizeINTEL => {
@@ -393,6 +402,10 @@ impl<'c, 'd> Parser<'c, 'd> {
             spirv::ExecutionMode::SchedulerTargetFmaxMhzINTEL => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
+            spirv::ExecutionMode::FPFastMathDefault => vec![
+                dr::Operand::IdRef(self.decoder.id()?),
+                dr::Operand::IdRef(self.decoder.id()?),
+            ],
             spirv::ExecutionMode::StreamingInterfaceINTEL => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
@@ -402,6 +415,17 @@ impl<'c, 'd> Parser<'c, 'd> {
             spirv::ExecutionMode::NamedBarrierCountINTEL => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
+            spirv::ExecutionMode::MaximumRegistersINTEL => {
+                vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
+            }
+            spirv::ExecutionMode::MaximumRegistersIdINTEL => {
+                vec![dr::Operand::IdRef(self.decoder.id()?)]
+            }
+            spirv::ExecutionMode::NamedMaximumRegistersINTEL => {
+                vec![dr::Operand::NamedMaximumNumberOfRegisters(
+                    self.decoder.named_maximum_number_of_registers()?,
+                )]
+            }
             _ => vec![],
         })
     }
@@ -515,6 +539,12 @@ impl<'c, 'd> Parser<'c, 'd> {
             spirv::Decoration::ForcePow2DepthINTEL => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
+            spirv::Decoration::StridesizeINTEL => {
+                vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
+            }
+            spirv::Decoration::WordsizeINTEL => {
+                vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
+            }
             spirv::Decoration::CacheSizeINTEL => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
@@ -546,16 +576,6 @@ impl<'c, 'd> Parser<'c, 'd> {
                 dr::Operand::LiteralBit32(self.decoder.bit32()?),
                 dr::Operand::FPOperationMode(self.decoder.fp_operation_mode()?),
             ],
-            spirv::Decoration::InitModeINTEL => vec![dr::Operand::InitializationModeQualifier(
-                self.decoder.initialization_mode_qualifier()?,
-            )],
-            spirv::Decoration::ImplementInRegisterMapINTEL => {
-                vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
-            }
-            spirv::Decoration::HostAccessINTEL => vec![
-                dr::Operand::HostAccessQualifier(self.decoder.host_access_qualifier()?),
-                dr::Operand::LiteralString(self.decoder.string()?),
-            ],
             spirv::Decoration::FPMaxErrorDecorationINTEL => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
@@ -587,6 +607,16 @@ impl<'c, 'd> Parser<'c, 'd> {
             spirv::Decoration::MMHostInterfaceWaitRequestINTEL => {
                 vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
             }
+            spirv::Decoration::HostAccessINTEL => vec![
+                dr::Operand::HostAccessQualifier(self.decoder.host_access_qualifier()?),
+                dr::Operand::LiteralString(self.decoder.string()?),
+            ],
+            spirv::Decoration::InitModeINTEL => vec![dr::Operand::InitializationModeQualifier(
+                self.decoder.initialization_mode_qualifier()?,
+            )],
+            spirv::Decoration::ImplementInRegisterMapINTEL => {
+                vec![dr::Operand::LiteralBit32(self.decoder.bit32()?)]
+            }
             spirv::Decoration::CacheControlLoadINTEL => vec![
                 dr::Operand::LiteralBit32(self.decoder.bit32()?),
                 dr::Operand::LoadCacheControl(self.decoder.load_cache_control()?),

rspirv/binary/disassemble.rs

@@ -310,7 +310,7 @@ mod tests {
         b.source(spirv::SourceLanguage::GLSL, 450, None, None::<String>);
 
         let void = b.type_void();
-        let float32 = b.type_float(32);
+        let float32 = b.type_float(32, None);
         let voidfvoid = b.type_function(void, vec![void]);
 
         let f = b
@@ -370,8 +370,8 @@ mod tests {
         let int64 = b.type_int(64, 1);
         let uint32 = b.type_int(32, 0);
         let uint64 = b.type_int(64, 0);
-        let float32 = b.type_float(32);
-        let float64 = b.type_float(64);
+        let float32 = b.type_float(32, None);
+        let float64 = b.type_float(64, None);
         let voidfvoid = b.type_function(void, vec![void]);
 
         let f = b
@@ -442,7 +442,7 @@ mod tests {
         b.memory_model(spirv::AddressingModel::Logical, spirv::MemoryModel::Simple);
 
         let void = b.type_void();
-        let float32 = b.type_float(32);
+        let float32 = b.type_float(32, None);
         let voidfvoid = b.type_function(void, vec![void]);
 
         assert!(b
@@ -484,7 +484,7 @@ mod tests {
         b.memory_model(spirv::AddressingModel::Logical, spirv::MemoryModel::OpenCL);
 
         let void = b.type_void();
-        let float32 = b.type_float(32);
+        let float32 = b.type_float(32, None);
         let voidfvoid = b.type_function(void, vec![void]);
 
         assert!(b