diff --git a/.cargo/config.toml b/.cargo/config.toml index 54ff3502..560b12ff 100644 --- a/.cargo/config.toml +++ b/.cargo/config.toml @@ -1,3 +1,3 @@ [alias] autogen = "run --bin autogen --release --" -dis = "run -p rspirv2-tools --bin rspirv2-dis -q --" +dis = "run -p rspirv2-tools --bin rspirv2-dis --release -q --" diff --git a/Cargo.lock b/Cargo.lock index 22e69751..0e68ea02 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -235,6 +235,7 @@ dependencies = [ "anyhow", "bitflags", "bytemuck", + "expect-test", "rspirv2-types", "smallvec", "spv", @@ -295,9 +296,16 @@ dependencies = [ "anyhow", "bitflags", "bytemuck", + "rustc-hash", "smallvec", ] +[[package]] +name = "rustc-hash" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" + [[package]] name = "serde" version = "1.0.228" diff --git a/Cargo.toml b/Cargo.toml index 72310013..83c55547 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -42,6 +42,7 @@ clap = { version = "4.5.57", features = ["derive"] } anstream = "0.6.21" anstyle = "1.0.13" expect-test = "1.5.1" +rustc-hash = "2.1.1" [workspace.lints.rust] #missing_docs = "warn" diff --git a/crates/grammar-parser/src/codegen/instructions.rs b/crates/grammar-parser/src/codegen/instructions.rs index 8c790a5a..7b4a21bc 100644 --- a/crates/grammar-parser/src/codegen/instructions.rs +++ b/crates/grammar-parser/src/codegen/instructions.rs @@ -48,11 +48,26 @@ pub fn write_inst(writer: &mut GrammarWriter, grammar: &Grammar<'_>) -> anyhow:: let reader = (!members.is_empty()).then(|| quote!(let mut op_reader = )); // disassembly - let (dis_id_result_pat, dis_id_result_value) = if let Some(id_result) = id_result { - let name = &id_result.name; - ("{} = ", Some(quote!(, self.#name.dis(_ctx)))) - } else { - ("", None) + let dis_operand_ctx = { + let id_result_opt = if let Some(id_result) = id_result { + let name = &id_result.name; + quote!(self.#name) + } else { + quote!(None) + }; + let id_result_type_opt = if let Some(id_result_type) = id_result_type { + let name = &id_result_type.name; + quote!(Some(self.#name)) + } else { + quote!(None) + }; + quote! { + let ctx = &OperandDisContext { + id_result: #id_result_opt, + id_result_type: #id_result_type_opt, + ctx, + }; + } }; // `name: Ident` is a good key to filter out the id_result, as names must be unique anyway let operands_without_result_id = member_operands @@ -63,10 +78,10 @@ pub fn write_inst(writer: &mut GrammarWriter, grammar: &Grammar<'_>) -> anyhow:: .iter() .map(|op| { let name = &op.name; - quote!(, self.#name.dis(_ctx)) + quote!(, self.#name.dis(ctx)) }) .collect::>(); - let pat = [dis_id_result_pat, inst.opname.as_ref()] + let pat = ["{}", inst.opname.as_ref()] .into_iter() .chain( operands_without_result_id @@ -84,7 +99,7 @@ pub fn write_inst(writer: &mut GrammarWriter, grammar: &Grammar<'_>) -> anyhow:: ) .collect::(); let rspirv_spaces_prefix = if id_result_type.is_some() { - quote!(let rspirv_space = _ctx.rspirv_space();) + quote!(let rspirv_space = ctx.rspirv_space();) } else { quote!() }; @@ -121,9 +136,10 @@ pub fn write_inst(writer: &mut GrammarWriter, grammar: &Grammar<'_>) -> anyhow:: }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + #dis_operand_ctx #rspirv_spaces_prefix - write!(f, #pat #dis_id_result_value #(#dis_operands_value)*) + write!(f, #pat, ctx.id_result_writer() #(#dis_operands_value)*) } } } @@ -196,7 +212,7 @@ pub fn write_inst_enum( let opcode = reader.opcode(); Ok(match opcode { #(#decode_match)* - _ => return Err(DecodeError::UnknownOpCode { opcode }), + _ => return Err(DecodeErrorKind::UnknownOpCode { opcode }.into()), }) } diff --git a/crates/grammar-parser/src/codegen/operands.rs b/crates/grammar-parser/src/codegen/operands.rs index fb39247b..11ee5a7c 100644 --- a/crates/grammar-parser/src/codegen/operands.rs +++ b/crates/grammar-parser/src/codegen/operands.rs @@ -139,15 +139,15 @@ fn emit_rust_like_enum( let variant = reader.pull()?.0; Ok(match variant { #(#decode,)* - _ => return Err(DecodeError::UnknownEnumVariant { + _ => return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(#name), variant, - }) + }.into()) }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &OperandDisContext<'_>) -> std::fmt::Result { match self { #(#dis),* } @@ -211,15 +211,15 @@ fn emit_c_like_enum(operand_kind: &OperandKind<'_>, enumerants: &[Enumerant<'_>] let variant = reader.pull()?.0; Ok(match variant { #(#decode,)* - _ => return Err(DecodeError::UnknownEnumVariant { + _ => return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(#name), variant, - }) + }.into()) }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { #(#dis),* } @@ -298,7 +298,7 @@ fn emit_bitflags_enum(operand_kind: &OperandKind<'_>, enumerants: &[Enumerant<'_ } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -329,7 +329,7 @@ fn emit_composite(operand_kind: &OperandKind<'_>, bases: &[Cow<'_, str>]) -> Tok quote!(OperandEncoding::encode(&self.#i, &mut *writer)?) }); let decode = (0..bases.len()).map(|_| quote!(OperandEncoding::decode(&mut *reader)?)); - let dis_pat = (0..bases.len()).map(|_| " {}").collect::(); + let dis_pat = (0..bases.len()).map(|_| "{}").collect::(); let dis_values = (0..bases.len()).map(|i| { let i = proc_macro2::Literal::usize_unsuffixed(i); quote!(OperandEncoding::dis(&self.#i, ctx)) @@ -357,7 +357,7 @@ fn emit_composite(operand_kind: &OperandKind<'_>, bases: &[Cow<'_, str>]) -> Tok } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { write!(f, #dis_pat, #(#dis_values),*) } } diff --git a/crates/rspirv2-types/Cargo.toml b/crates/rspirv2-types/Cargo.toml index 020bbc5e..756975b0 100644 --- a/crates/rspirv2-types/Cargo.toml +++ b/crates/rspirv2-types/Cargo.toml @@ -15,6 +15,7 @@ bytemuck = { workspace = true, optional = true } bitflags.workspace = true smallvec.workspace = true anstyle.workspace = true +rustc-hash.workspace = true [dev-dependencies] anyhow.workspace = true diff --git a/crates/rspirv2-types/src/binary/decode_error.rs b/crates/rspirv2-types/src/binary/decode_error.rs index 336d1928..6d4e1298 100644 --- a/crates/rspirv2-types/src/binary/decode_error.rs +++ b/crates/rspirv2-types/src/binary/decode_error.rs @@ -1,3 +1,4 @@ +use crate::binary::InstOffset; use bitflags::Flags; use std::error::Error; use std::ffi::FromBytesUntilNulError; @@ -6,7 +7,7 @@ use std::str::Utf8Error; use std::string::FromUtf8Error; #[derive(Clone, PartialEq)] -pub enum DecodeError { +pub enum DecodeErrorKind { UnknownOpCode { opcode: u16, }, @@ -55,7 +56,7 @@ pub enum DecodeError { }, } -impl Display for DecodeError { +impl Display for DecodeErrorKind { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { match self { Self::UnknownOpCode { opcode } => write!( @@ -139,39 +140,82 @@ impl Display for DecodeError { } } -impl Debug for DecodeError { +impl Debug for DecodeErrorKind { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { Display::fmt(self, f) } } -impl Error for DecodeError {} +impl Error for DecodeErrorKind {} + +#[derive(Clone, PartialEq)] +pub struct DecodeError { + pub kind: DecodeErrorKind, + pub inst_offset: Option, +} impl DecodeError { + #[inline] + pub fn new(kind: DecodeErrorKind) -> Self { + Self { + kind, + inst_offset: None, + } + } + + #[inline] + pub fn with_inst_offset(mut self, offset: impl Into>) -> Self { + self.inst_offset = offset.into(); + self + } + #[inline] pub fn invalid_bitflags>(name: &'static str, bits: u32) -> Self { - Self::InvalidBitflags { + Self::new(DecodeErrorKind::InvalidBitflags { name, unknown: bits & T::all().bits(), bits, - } + }) + } +} + +impl From for DecodeError { + fn from(variant: DecodeErrorKind) -> Self { + Self::new(variant) } } impl From for DecodeError { fn from(_: FromBytesUntilNulError) -> Self { - Self::StringNotNulTerminated + Self::new(DecodeErrorKind::StringNotNulTerminated) } } impl From for DecodeError { fn from(value: Utf8Error) -> Self { - Self::Utf8Error(value) + Self::new(DecodeErrorKind::Utf8Error(value)) } } impl From for DecodeError { fn from(value: FromUtf8Error) -> Self { - Self::Utf8Error(value.utf8_error()) + Self::new(DecodeErrorKind::Utf8Error(value.utf8_error())) + } +} + +impl Display for DecodeError { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + if let Some(inst_offset) = self.inst_offset { + write!(f, "Instruction at offset {inst_offset}: ")?; + } + write!(f, "{}", self.kind) } } + +impl Debug for DecodeError { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + Display::fmt(self, f) + } +} + +impl Error for DecodeError {} diff --git a/crates/rspirv2-types/src/binary/reader.rs b/crates/rspirv2-types/src/binary/reader.rs index 29222531..37964614 100644 --- a/crates/rspirv2-types/src/binary/reader.rs +++ b/crates/rspirv2-types/src/binary/reader.rs @@ -1,5 +1,5 @@ use crate::Word; -use crate::binary::DecodeError; +use crate::binary::{DecodeError, DecodeErrorKind}; use crate::meta::InstMeta; use std::cmp::Ordering; use std::fmt::{Display, Formatter}; @@ -39,15 +39,15 @@ impl<'a> InstReader<'a> { /// words not associated with this instruction. Use [`Self::len`] to figure out how many words have been consumed /// by this instruction. pub fn from_words(words: &'a [Word]) -> Result { - let first = words.first().ok_or(DecodeError::OutOfInstructions)?; + let first = words.first().ok_or(DecodeErrorKind::OutOfInstructions)?; let (_, op_len) = first.to_op(); if op_len == 0 { // len must at least be 1, as it includes the op Word itself - return Err(DecodeError::InstructionZeroSized); + return Err(DecodeErrorKind::InstructionZeroSized.into()); } let inst_words = words .get(0..op_len) - .ok_or(DecodeError::InstructionTooLong { + .ok_or(DecodeErrorKind::InstructionTooLong { op_len, module_remaining: words.len(), })?; @@ -72,11 +72,12 @@ impl<'a> InstReader<'a> { pub fn check_opcode(&self, meta: &InstMeta) -> Result, DecodeError> { let opcode = self.opcode(); if opcode != meta.opcode { - Err(DecodeError::WrongOpCode { + Err(DecodeErrorKind::WrongOpCode { name: meta.opname, expected: meta.opcode, actual: opcode, - }) + } + .into()) } else { Ok(self.operand_reader()) } @@ -142,19 +143,21 @@ impl<'a> OperandReader<'a> { pub fn finalize(&self) -> Result<(), DecodeError> { let remaining = self.remaining(); match 0.cmp(&remaining) { - Ordering::Less => Err(DecodeError::InstructionWithAdditionalOperants { + Ordering::Less => Err(DecodeErrorKind::InstructionWithAdditionalOperants { param_len: self.params.len(), remaining, - }), + } + .into()), Ordering::Equal => Ok(()), Ordering::Greater => Err(self.err_too_many_words()), } } fn err_too_many_words(&self) -> DecodeError { - DecodeError::InstructionDecodePulledTooManyWords { + DecodeErrorKind::InstructionDecodePulledTooManyWords { param_len: self.len(), } + .into() } /// View the *remaining* Words as a slice, does not advance the `params_offset`. diff --git a/crates/rspirv2-types/src/dis.rs b/crates/rspirv2-types/src/dis.rs index 38cef186..783c01a0 100644 --- a/crates/rspirv2-types/src/dis.rs +++ b/crates/rspirv2-types/src/dis.rs @@ -1,9 +1,14 @@ //! Module for Disassembly -use crate::operand::LiteralStringEscape; +use crate::inst::InstEncoding; +use crate::operand::{ConstFmt, IdResult, LiteralStringEscape}; +use crate::slice::{InstSlice, RawInstSlice}; use anstyle::Style; +use rustc_hash::FxHashMap; use std::cell::Cell; +use std::collections::hash_map::Entry; use std::fmt::{Display, Formatter}; +use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; /// Options for disassembly @@ -15,8 +20,49 @@ pub struct DisOptions { pub literal_string_escape: LiteralStringEscape, /// Add extra spaces around [`crate::operand::IdResultType`] to match `rspirv`'s behaviour pub rspirv_space: bool, + /// Format constants based on the `IdResultType` of the `OpConstant`, requires scanning the module for type + /// information to provide context. + /// + /// **REQUIRED** for correct disassembly + pub const_fmt: bool, + /// Defines whether to use raw ids (`%53`) or named ids (`%my_name`) resolved from `OpName` descriptors or other + /// sources of metadata. See [`IdNaming`]. + pub id_naming: IdNaming, + /// How to derive names for types + pub type_naming: TypeNaming, + /// The padding to add before each instruction to make the `=` be on the same line. Usually N-many spaces. + pub padding: String, } +/// Defines where names of types should be derived from. +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum IdNaming { + /// Only use raw ids (`%53`) + RawId, + /// Only use names for explicitly named types (`OpName`) + ExplicitNames, + /// Use names from both explicit naming (`OpName`) and other sources of metadata. + /// + /// Typical sources of names, besides `OpName`: + /// * `OpType*`: `%u32 = OpTypeInt 32 0` + /// * `OpConstant`: `%u32_42 = OpConstant %u32 42` + All, +} + +/// Defines how to derive names for types +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +pub enum TypeNaming { + /// Rust naming conventions, eg. `u32`, `i32`, `f32` + Rust, + /// C naming conventions, eg. `uint`, `int`, `float` + /// + /// should match spirv-dis + C, +} + +/// `&str` of 15 spaces, the default padding in spirv-tools +pub const STR_15_SPACES: &str = " "; + impl Default for DisOptions { #[inline] fn default() -> Self { @@ -24,6 +70,10 @@ impl Default for DisOptions { color: true, literal_string_escape: LiteralStringEscape::default(), rspirv_space: false, + const_fmt: true, + id_naming: IdNaming::All, + type_naming: TypeNaming::Rust, + padding: STR_15_SPACES.into(), } } } @@ -33,6 +83,7 @@ impl DisOptions { pub fn simple() -> Self { Self { color: false, + padding: "".to_string(), ..Default::default() } } @@ -43,6 +94,10 @@ impl DisOptions { color: false, literal_string_escape: LiteralStringEscape::EscapeNewlines, rspirv_space: true, + const_fmt: true, + id_naming: IdNaming::RawId, + type_naming: TypeNaming::Rust, + padding: String::new(), } } @@ -52,6 +107,10 @@ impl DisOptions { color: true, literal_string_escape: LiteralStringEscape::MultiLine, rspirv_space: false, + const_fmt: true, + id_naming: IdNaming::All, + type_naming: TypeNaming::C, + padding: STR_15_SPACES.into(), } } @@ -72,17 +131,129 @@ impl DisOptions { } /// Context object for disassembly generation +/// +/// Next to [`DisOptions`], contains lookup tables to aid in disassembly generation. Initializing these tables is +/// **required** to generate correct disassembly that `spirv-as` can read, otherwise, we'll generate the best possible +/// disassembly we can. Since instructions are not available within the `rspirv2-types` crate, we can't actually +/// implement the context information retrieval here. Instead, it needs to be implemented for each instruction set with +/// the [`InstSetDisCtx`] trait, which may delegate to our default implementation in +/// `rspirv2::dis::create_dis_context_core`. #[derive(Clone, Debug, Default)] pub struct DisContext { + /// Options opt: DisOptions, + /// Maps an [`IdResult`] of a type declaration to a [`ConstFmt`] to tell `OpConstant` instructions how to format + /// the untyped constant value + pub id_to_const_fmt: FxHashMap, + /// Maps an [`IdResult`] to the "highest priority" [`IdName`] + pub id_to_name: FxHashMap, +} + +#[derive(Clone, Debug, Default)] +pub enum IdName { + /// Use the raw id + #[default] + RawId, + /// Use this explicitly assigned name, has priority over [`Self::DerivedName`] + ExplicitName(String), + /// Derived name from the definition of the id + DerivedName(String), +} + +#[derive(Copy, Clone, Debug)] +pub enum ResolvedIdName<'a> { + Named(&'a str), + Raw(IdResult), +} + +impl Display for ResolvedIdName<'_> { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + match self { + ResolvedIdName::Named(name) => write!(f, "{name}"), + ResolvedIdName::Raw(id) => write!(f, "{}", id.0.0), + } + } } impl DisContext { - pub fn new(opt: DisOptions) -> Self { - Self { opt } + /// Creates a new [`DisContext`] without having scanned the module for the required extra information. + /// + /// **WARNING**: You need to [`Self::add_context`] the instructions you want to decode before disassembling, + /// as the disassembly generated may be invalid without the required context. For example, `OpConstant` needs to + /// query the type of constant their value is to format it correctly as a float or an int. + #[inline] + pub fn no_context(opt: DisOptions) -> Self { + Self { + opt, + ..Default::default() + } + } + + /// Scan the supplied [`InstSlice`] for useful context + pub fn add_context(&mut self, slice: &InstSlice) { + ISA::add_context(slice.as_raw(), self); + } + + /// Scan the supplied [`InstSlice`] for useful context, skip over any [`DecodeError`]s that may arise + /// + /// [`DecodeError`]: crate::binary::DecodeError + pub fn add_context_raw(&mut self, slice: &RawInstSlice) { + ISA::add_context(slice, self); + } + + /// Add a mapping from an [`IdResult`] to an [`IdName`] + pub fn add_id_to_name(&mut self, id: IdResult, name: IdName) { + // In the name of Hades, I accept this message! + #[allow(clippy::match_same_arms)] + let accept = match (self.opt.id_naming, &name) { + // no need to store anything, default is `RawId` + (_, IdName::RawId) => false, + (IdNaming::RawId, _) => false, + + (IdNaming::All, _) => true, + (IdNaming::ExplicitNames, IdName::ExplicitName(..)) => true, + (IdNaming::ExplicitNames, IdName::DerivedName(..)) => false, + }; + if accept { + match self.id_to_name.entry(id) { + Entry::Occupied(mut slot) => { + let overwrite = match (&name, slot.get()) { + // don't overwrite an explicit name + (IdName::DerivedName(..), IdName::ExplicitName(..)) => false, + (_, _) => true, + }; + if overwrite { + slot.insert(name); + } + } + Entry::Vacant(slot) => { + slot.insert(name); + } + } + } + } + + pub fn id_to_name(&self, id: IdResult) -> ResolvedIdName<'_> { + match self.id_to_name.get(&id).unwrap_or(&IdName::RawId) { + IdName::RawId => ResolvedIdName::Raw(id), + IdName::ExplicitName(name) | IdName::DerivedName(name) => ResolvedIdName::Named(name), + } } } +/// An instruction set that provides additional context information for disassembly. +pub trait InstSetDisCtx: InstEncoding { + /// Add context to the supplied [`DisContext`] by modifying the various public members of it. + /// + /// Only supplies a [`RawInstSlice`] instead of a full [`InstSlice`] that has been error checked, as to allow + /// disassembly of partially corrupt instructions. Any [`DecodeError`] that arrises during decode should be silently + /// ignored. We recommend using `slice.iter().try_decode::().skip_errors()` to decode instructions + /// from the [`RawInstSlice`]. + /// + /// [`DecodeError`]: crate::binary::DecodeError + fn add_context(slice: &RawInstSlice, ctx: &mut DisContext); +} + impl Deref for DisContext { type Target = DisOptions; fn deref(&self) -> &Self::Target { @@ -96,6 +267,82 @@ impl DerefMut for DisContext { } } +/// Either [`DisContext`] or [`DisOptions`] that is turned into one via [`DisContext::no_context`]. Actual context needs +/// to be gathered yourself, see warning in [`DisContext::no_context`]. +pub trait IntoDisContext { + fn into_dis_ctx(self) -> DisContext; +} + +impl IntoDisContext for DisContext { + fn into_dis_ctx(self) -> DisContext { + self + } +} + +impl IntoDisContext for DisOptions { + fn into_dis_ctx(self) -> DisContext { + DisContext::no_context(self) + } +} + +/// A sequence of words that has been pre-processed and may be [`Display`]ed. +/// +/// The `ISA: `[`InstEncoding`] generic determines for which instruction set these Words are disassembled. +pub struct DisInstSlice<'a, ISA: InstSetDisCtx> { + slice: &'a RawInstSlice, + ctx: DisContext, + _phantom: PhantomData, +} + +impl<'a, ISA: InstSetDisCtx> DisInstSlice<'a, ISA> { + #[inline] + pub fn new(slice: impl Into<&'a RawInstSlice>, ctx: impl IntoDisContext) -> Self { + let slice = slice.into(); + let mut ctx = ctx.into_dis_ctx(); + ctx.add_context_raw::(slice); + Self::new_no_context(slice, ctx) + } + + #[inline] + pub fn new_no_context(slice: impl Into<&'a RawInstSlice>, ctx: impl IntoDisContext) -> Self { + Self { + slice: slice.into(), + ctx: ctx.into_dis_ctx(), + _phantom: PhantomData, + } + } +} + +impl<'a, ISA: InstSetDisCtx> Display for DisInstSlice<'a, ISA> { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + for maybe_reader in self.slice.iter() { + match maybe_reader.and_then(|reader| ISA::decode(reader)) { + Ok(inst) => writeln!(f, "{}", inst.dis(&self.ctx))?, + Err(e) => writeln!(f, "Error: {}", e)?, + } + } + Ok(()) + } +} + +#[allow(clippy::match_same_arms)] +pub fn escape_id_name(str: &str) -> Option { + let escaped = str + .chars() + .map(|c| match c { + 'A'..='Z' => c, + 'a'..='z' => c, + '0'..='9' => c, + _ => '_', + }) + .collect::(); + if escaped.chars().all(|c| c == ' ') { + None + } else { + Some(escaped) + } +} + /// Utility struct for inserting separators between variants. Use it like `format!({sep}{value})`, will skip the /// separator on first write. /// diff --git a/crates/rspirv2-types/src/inst.rs b/crates/rspirv2-types/src/inst.rs index f9a5278e..d29d69e0 100644 --- a/crates/rspirv2-types/src/inst.rs +++ b/crates/rspirv2-types/src/inst.rs @@ -1,5 +1,7 @@ use crate::Word; -use crate::binary::{DecodeError, EncodeError, IdResultAlloc, InstReader, WordWriter}; +use crate::binary::{ + DecodeError, DecodeErrorKind, EncodeError, IdResultAlloc, InstReader, WordWriter, +}; use crate::dis::DisContext; use crate::meta::InstMeta; use crate::operand::{IdResult, OptionIdResult}; @@ -38,7 +40,10 @@ pub trait InstEncoding: Sized + Debug + Eq { fn try_decode(reader: InstReader<'_>) -> Result, DecodeError> { match Self::decode(reader) { Ok(e) => Ok(Some(e)), - Err(DecodeError::WrongOpCode { .. } | DecodeError::UnknownOpCode { .. }) => Ok(None), + Err(DecodeError { + kind: DecodeErrorKind::WrongOpCode { .. } | DecodeErrorKind::UnknownOpCode { .. }, + .. + }) => Ok(None), Err(e) => Err(e), } } @@ -65,9 +70,10 @@ impl InstEncoding for () { } fn decode(reader: InstReader<'_>) -> Result { - Err(DecodeError::UnknownOpCode { + Err(DecodeErrorKind::UnknownOpCode { opcode: reader.opcode(), - }) + } + .into()) } fn dis_fmt(&self, _: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { diff --git a/crates/rspirv2-types/src/operand/id.rs b/crates/rspirv2-types/src/operand/id.rs index a79c5866..eb0f4d0b 100644 --- a/crates/rspirv2-types/src/operand/id.rs +++ b/crates/rspirv2-types/src/operand/id.rs @@ -2,11 +2,11 @@ use crate::Word; use crate::binary::{DecodeError, EncodeError, OperandReader, WordWriter}; -use crate::dis::DisContext; +use crate::dis::ResolvedIdName; use crate::meta::{Category, OperandKind}; -use crate::operand::{Operand, OperandEncoding}; +use crate::operand::{Operand, OperandDisContext, OperandEncoding}; use anstyle::AnsiColor; -use std::fmt::Formatter; +use std::fmt::{Display, Formatter}; pub const OPERAND_KIND_ID_RESULT_TYPE: OperandKind = OperandKind { name: "IdResultType", @@ -74,22 +74,45 @@ unsafe impl OperandEncoding for IdResult { } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { - self.dis_fmt_color(f, ctx, AnsiColor::Blue.on_default(), false) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { + self.dis_fmt_color(f, ctx, ID_RESULT_COLOR, false) } } +pub const ID_RESULT_COLOR: anstyle::Style = AnsiColor::Blue.on_default(); + impl IdResult { pub fn dis_fmt_color( &self, f: &mut Formatter<'_>, - ctx: &DisContext, + ctx: &OperandDisContext<'_>, style: anstyle::Style, prepend_space: bool, ) -> std::fmt::Result { let style = ctx.color(style); let prepend_space = if prepend_space { " " } else { "" }; - write!(f, "{prepend_space}{style}%{}{style:#}", self.0.0) + let name = ctx.id_to_name(*self); + write!(f, "{prepend_space}{style}%{name}{style:#}") + } +} + +pub struct IdResultWriter<'a>(pub &'a OperandDisContext<'a>); + +impl Display for IdResultWriter<'_> { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + let ctx = self.0; + if let Some(id_result) = self.0.id_result { + let name = ctx.id_to_name(id_result); + let name_len = match name { + ResolvedIdName::Named(name) => name.len(), + ResolvedIdName::Raw(id) => id.0.0.checked_ilog10().unwrap_or(1) as usize + 1, + }; + let pad_len = ctx.padding.len().saturating_sub(name_len + 4); + let style = ctx.color(ID_RESULT_COLOR); + write!(f, "{}{style}%{}{style:#} = ", &ctx.padding[..pad_len], name) + } else { + write!(f, "{}", &ctx.padding) + } } } @@ -141,7 +164,7 @@ macro_rules! id_ref { } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { self.0.dis_fmt_color(f, ctx, AnsiColor::Yellow.on_default(), true) } } diff --git a/crates/rspirv2-types/src/operand/literal_const.rs b/crates/rspirv2-types/src/operand/literal_const.rs index a0ae4585..6b9565b8 100644 --- a/crates/rspirv2-types/src/operand/literal_const.rs +++ b/crates/rspirv2-types/src/operand/literal_const.rs @@ -1,11 +1,10 @@ use crate::Word; -use crate::binary::{DecodeError, EncodeError, OperandReader, WordWriter}; -use crate::dis::DisContext; +use crate::binary::{DecodeError, DecodeErrorKind, EncodeError, OperandReader, WordWriter}; use crate::meta::{Category, OperandKind}; -use crate::operand::{Operand, OperandEncoding}; +use crate::operand::{Operand, OperandDisContext, OperandEncoding}; use anstyle::AnsiColor; use smallvec::SmallVec; -use std::fmt::Formatter; +use std::fmt::{Display, Formatter}; pub const OPERAND_KIND_LITERAL_CONTEXT_DEPENDENT_NUMBER: OperandKind = OperandKind { name: "LiteralContextDependentNumber", @@ -96,10 +95,11 @@ impl LiteralConst { if self.0.len() == 2 { Ok(self.0[0].0 as u64 | (self.0[1].0 as u64) << 32) } else { - Err(DecodeError::LiteralConstOfWrongWordSize { + Err(DecodeErrorKind::LiteralConstOfWrongWordSize { expected_size: 2, actual_size: self.0.len(), - }) + } + .into()) } } @@ -107,21 +107,24 @@ impl LiteralConst { if self.0.len() == 1 { Ok(self.0[0].0) } else { - Err(DecodeError::LiteralConstOfWrongWordSize { + Err(DecodeErrorKind::LiteralConstOfWrongWordSize { expected_size: 1, actual_size: self.0.len(), - }) + } + .into()) } } pub fn as_u16(&self) -> Result { let value = self.as_u32()?; - u16::try_from(value).map_err(|_| DecodeError::LiteralConstTooLarge { value, bits: 16 }) + u16::try_from(value) + .map_err(|_| DecodeErrorKind::LiteralConstTooLarge { value, bits: 16 }.into()) } pub fn as_u8(&self) -> Result { let value = self.as_u32()?; - u8::try_from(value).map_err(|_| DecodeError::LiteralConstTooLarge { value, bits: 8 }) + u8::try_from(value) + .map_err(|_| DecodeErrorKind::LiteralConstTooLarge { value, bits: 8 }.into()) } } @@ -170,7 +173,7 @@ unsafe impl OperandEncoding for LiteralConst { #[inline] fn decode(_: &mut OperandReader<'_>) -> Result { - Err(DecodeError::LiteralConstNotLastOperand) + Err(DecodeErrorKind::LiteralConstNotLastOperand.into()) } #[inline] @@ -179,12 +182,60 @@ unsafe impl OperandEncoding for LiteralConst { } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { let color = ctx.color(AnsiColor::Red.on_default()); - match self.0.len() { - 1 => write!(f, " {color}{}{color:#}", self.as_u32().unwrap()), - 2 => write!(f, " {color}{}{color:#}", self.as_u64().unwrap()), - _ => write!(f, " {color}{:?}{color:#}", self.0.as_slice()), + write!(f, " {color}{}{color:#}", self.fmt_value(ctx)) + } +} + +impl LiteralConst { + pub fn fmt_value<'a>(&'a self, ctx: &'a OperandDisContext<'a>) -> FormattedValue<'a> { + FormattedValue(self, ctx) + } +} + +pub struct FormattedValue<'a>(&'a LiteralConst, &'a OperandDisContext<'a>); + +impl Display for FormattedValue<'_> { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + let fmt = self + .1 + .id_result_type + .and_then(|ty| self.1.id_to_const_fmt.get(&ty.0)) + .copied() + .unwrap_or_default(); + match (self.0.0.len(), fmt) { + (1, ConstFmt::Unsigned) => write!(f, "{}", self.0.as_u32().unwrap()), + (2, ConstFmt::Unsigned) => write!(f, "{}", self.0.as_u64().unwrap()), + (1, ConstFmt::Signed) => write!(f, "{}", self.0.as_i32().unwrap()), + (2, ConstFmt::Signed) => write!(f, "{}", self.0.as_i64().unwrap()), + (1, ConstFmt::LowerHex) => write!(f, "{:x}", self.0.as_u32().unwrap()), + (2, ConstFmt::LowerHex) => write!(f, "{:x}", self.0.as_u64().unwrap()), + (1, ConstFmt::UpperHex) => write!(f, "{:X}", self.0.as_u32().unwrap()), + (2, ConstFmt::UpperHex) => write!(f, "{:X}", self.0.as_u64().unwrap()), + (1, ConstFmt::Float) => write!(f, "{}", self.0.as_f32().unwrap()), + (2, ConstFmt::Float) => write!(f, "{}", self.0.as_f64().unwrap()), + (_, _) => write!(f, "{:?}", self.0.0.as_slice()), } } } + +/// How the untyped constant value of a [`LiteralConst`] should be formatted +#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash)] +pub enum ConstFmt { + /// Format constant as an unsigned decimal integer + #[default] + Unsigned, + /// Format constant as a signed decimal integer + Signed, + /// **INCOMPLIANT** Format constant as a lower case hex value + /// + /// Hex values in disassembly are not supported by `spirv-as` + LowerHex, + /// **INCOMPLIANT** Format constant as an upper case hex value + /// + /// Hex values in disassembly are not supported by `spirv-as` + UpperHex, + /// Format constant as a float + Float, +} diff --git a/crates/rspirv2-types/src/operand/literal_float.rs b/crates/rspirv2-types/src/operand/literal_float.rs index b950b97a..3f0d85d4 100644 --- a/crates/rspirv2-types/src/operand/literal_float.rs +++ b/crates/rspirv2-types/src/operand/literal_float.rs @@ -1,8 +1,7 @@ use crate::Word; use crate::binary::{DecodeError, EncodeError, OperandReader, WordWriter}; -use crate::dis::DisContext; use crate::meta::{Category, OperandKind}; -use crate::operand::{Operand, OperandEncoding}; +use crate::operand::{Operand, OperandDisContext, OperandEncoding}; use anstyle::AnsiColor; use std::fmt::Formatter; @@ -69,7 +68,7 @@ unsafe impl OperandEncoding for LiteralFloat { } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { let color = ctx.color(AnsiColor::Red.on_default()); write!(f, " {color}{}{color:#}", self.to_f32()) } diff --git a/crates/rspirv2-types/src/operand/literal_integer.rs b/crates/rspirv2-types/src/operand/literal_integer.rs index 3e79a476..8d5ff21f 100644 --- a/crates/rspirv2-types/src/operand/literal_integer.rs +++ b/crates/rspirv2-types/src/operand/literal_integer.rs @@ -1,8 +1,7 @@ use crate::Word; use crate::binary::{DecodeError, EncodeError, OperandReader, WordWriter}; -use crate::dis::DisContext; use crate::meta::{Category, OperandKind}; -use crate::operand::{Operand, OperandEncoding}; +use crate::operand::{Operand, OperandDisContext, OperandEncoding}; use anstyle::AnsiColor; use std::fmt::Formatter; @@ -35,25 +34,35 @@ macro_rules! def_literal_integer { unsafe impl bytemuck::Pod for $name {} impl $name { + #[inline] + pub fn from_word(value: Word) -> Self { + Self(value) + } + #[inline] pub fn new(value: u32) -> Self { Self(Word(value)) } #[inline] - pub fn from_word(value: Word) -> Self { - Self(value) + pub fn from_bool(value: bool) -> Self { + Self(Word(value as u32)) } #[inline] pub fn to_word(&self) -> Word { self.0 } - #[inline] + #[inline] pub fn to_u32(&self) -> u32 { self.0.0 } + + #[inline] + pub fn to_bool(&self) -> bool { + self.0.0 != 0 + } } unsafe impl Operand for $name { @@ -75,7 +84,11 @@ macro_rules! def_literal_integer { } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt( + &self, + f: &mut Formatter<'_>, + ctx: &OperandDisContext<'_>, + ) -> std::fmt::Result { let color = ctx.color(AnsiColor::Red.on_default()); write!(f, " {color}{}{color:#}", self.0.0) } diff --git a/crates/rspirv2-types/src/operand/literal_string.rs b/crates/rspirv2-types/src/operand/literal_string.rs index 3b0ff288..a5b24696 100644 --- a/crates/rspirv2-types/src/operand/literal_string.rs +++ b/crates/rspirv2-types/src/operand/literal_string.rs @@ -1,8 +1,7 @@ use crate::Word; -use crate::binary::{DecodeError, EncodeError, OperandReader, WordWriter}; -use crate::dis::DisContext; +use crate::binary::{DecodeError, DecodeErrorKind, EncodeError, OperandReader, WordWriter}; use crate::meta::{Category, OperandKind}; -use crate::operand::{Operand, OperandEncoding}; +use crate::operand::{Operand, OperandDisContext, OperandEncoding}; use anstyle::AnsiColor; use std::borrow::Cow; use std::fmt::{Debug, Formatter}; @@ -67,12 +66,12 @@ unsafe impl OperandEncoding for LiteralString { if found_null_terminator { Ok(Self(String::from_utf8(bytes)?)) } else { - Err(DecodeError::StringNotNulTerminated) + Err(DecodeErrorKind::StringNotNulTerminated.into()) } } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { let color = ctx.color(AnsiColor::Green.on_default()); let str = ctx.literal_string_escape.escape(&self.0); write!(f, " {color}\"{str}\"{color:#}") diff --git a/crates/rspirv2-types/src/operand/mod.rs b/crates/rspirv2-types/src/operand/mod.rs index addbec57..1609aaf4 100644 --- a/crates/rspirv2-types/src/operand/mod.rs +++ b/crates/rspirv2-types/src/operand/mod.rs @@ -4,7 +4,9 @@ mod literal_float; mod literal_integer; mod literal_string; -use crate::binary::{DecodeError, EncodeError, OperandReader, WordCounter, WordWriter}; +use crate::binary::{ + DecodeError, DecodeErrorKind, EncodeError, OperandReader, WordCounter, WordWriter, +}; use crate::dis::DisContext; use crate::meta::{OperandKind, Quantifier}; pub use id::*; @@ -14,6 +16,7 @@ pub use literal_integer::*; pub use literal_string::*; use smallvec::SmallVec; use std::fmt::{Debug, Display, Formatter}; +use std::ops::Deref; /// A SPIR-V operand. The associated const [`Self::KIND`] links to it's [`OperandKind`]. /// @@ -122,7 +125,7 @@ pub unsafe trait OperandEncoding: Sized + Debug { } /// Disassemble this operand to the supplied [`Formatter`]. Prefer [`Self::dis`] over calling this. - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result; + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result; /// Disassemble this operand /// @@ -134,12 +137,12 @@ pub unsafe trait OperandEncoding: Sized + Debug { /// assert_eq!(dis, "OpMyInst %42"); /// ``` #[inline] - fn dis<'a>(&'a self, ctx: &'a DisContext) -> OperandDis<'a, Self> { + fn dis<'a>(&'a self, ctx: &'a OperandDisContext<'_>) -> OperandDis<'a, Self> { OperandDis(self, ctx) } } -pub struct OperandDis<'a, T: OperandEncoding>(&'a T, &'a DisContext); +pub struct OperandDis<'a, T: OperandEncoding>(&'a T, &'a OperandDisContext<'a>); impl<'a, T: OperandEncoding> Display for OperandDis<'a, T> { #[inline] @@ -148,6 +151,35 @@ impl<'a, T: OperandEncoding> Display for OperandDis<'a, T> { } } +/// Context object for disassembly generation of operands within an instruction +#[derive(Copy, Clone, Debug)] +pub struct OperandDisContext<'a> { + pub ctx: &'a DisContext, + pub id_result: Option, + pub id_result_type: Option, +} + +impl<'a> OperandDisContext<'a> { + pub fn new(ctx: &'a DisContext) -> Self { + Self { + ctx, + id_result: None, + id_result_type: None, + } + } + + pub fn id_result_writer(&self) -> IdResultWriter<'_> { + IdResultWriter(self) + } +} + +impl<'a> Deref for OperandDisContext<'a> { + type Target = DisContext; + fn deref(&self) -> &Self::Target { + self.ctx + } +} + unsafe impl OperandEncoding for Option { const FIXED_LEN: Option = None; @@ -187,7 +219,7 @@ unsafe impl OperandEncoding for Option { } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { match self { None => Ok(()), Some(e) => e.dis_fmt(f, ctx), @@ -233,10 +265,11 @@ unsafe impl OperandEncoding for Vec { let mut vec = if let Some(fixed_len) = T::FIXED_LEN { let remaining = reader.remaining(); if !remaining.is_multiple_of(fixed_len) { - return Err(DecodeError::InstructionWithMismatchedVariableOperants { + return Err(DecodeErrorKind::InstructionWithMismatchedVariableOperants { op_len: reader.remaining(), expected_multiple: fixed_len, - }); + } + .into()); } Vec::with_capacity(remaining / fixed_len) } else { @@ -249,7 +282,7 @@ unsafe impl OperandEncoding for Vec { } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { for v in self { T::dis_fmt(v, &mut *f, ctx)?; } @@ -284,10 +317,11 @@ unsafe impl OperandEncoding for SmallVec<[T; let mut vec = if let Some(fixed_len) = T::FIXED_LEN { let remaining = reader.remaining(); if !remaining.is_multiple_of(fixed_len) { - return Err(DecodeError::InstructionWithMismatchedVariableOperants { + return Err(DecodeErrorKind::InstructionWithMismatchedVariableOperants { op_len: reader.remaining(), expected_multiple: fixed_len, - }); + } + .into()); } SmallVec::with_capacity(remaining / fixed_len) } else { @@ -300,7 +334,7 @@ unsafe impl OperandEncoding for SmallVec<[T; } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { for v in self { T::dis_fmt(v, &mut *f, ctx)?; } diff --git a/crates/rspirv2-types/src/slice.rs b/crates/rspirv2-types/src/slice.rs index def6186f..194b2c4b 100644 --- a/crates/rspirv2-types/src/slice.rs +++ b/crates/rspirv2-types/src/slice.rs @@ -1,8 +1,8 @@ use crate::Word; -use crate::binary::{DecodeError, InstOffset, InstReader}; -use crate::dis::{DisContext, DisOptions}; +use crate::binary::{DecodeError, DecodeErrorKind, InstOffset, InstReader}; +use crate::dis::{DisInstSlice, InstSetDisCtx, IntoDisContext}; use crate::inst::{InstEncoding, InstRef}; -use std::fmt::{Debug, Display, Formatter}; +use std::fmt::{Debug, Formatter}; use std::marker::PhantomData; use std::ops::Deref; @@ -92,12 +92,6 @@ impl InstSlice { pub const fn iter(&self) -> InstIter<'_, ISA> { InstIter::new(self) } - - /// disassemble - #[inline] - pub fn dis(&self, opt: DisOptions) -> Result, DecodeError> { - DisInstSlice::new(self, opt) - } } impl Deref for InstSlice { @@ -117,30 +111,11 @@ impl Debug for InstSlice { } } -/// A sequence of words that has been pre-processed and may be [`Display`]ed. -/// -/// The `ISA: `[`InstEncoding`] generic determines for which instruction set these Words are disassembled. -pub struct DisInstSlice<'a, ISA: InstEncoding> { - slice: &'a InstSlice, - dis: DisContext, -} - -impl<'a, ISA: InstEncoding> DisInstSlice<'a, ISA> { +impl InstSlice { + /// disassemble #[inline] - pub fn new(slice: &'a InstSlice, opt: DisOptions) -> Result { - Ok(Self { - slice, - dis: DisContext::new(opt), - }) - } -} - -impl<'a, ISA: InstEncoding> Display for DisInstSlice<'a, ISA> { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - for inst in self.slice.iter() { - writeln!(f, "{}", inst.dis(&self.dis))?; - } - Ok(()) + pub fn dis(&self, ctx: impl IntoDisContext) -> DisInstSlice<'_, ISA> { + DisInstSlice::::new(self, ctx) } } @@ -343,6 +318,14 @@ impl<'a, ISA: InstEncoding> From<&'a InstSlice> for &'a RawInstSlice { } } +impl RawInstSlice { + /// disassemble + #[inline] + pub fn dis(&self, ctx: impl IntoDisContext) -> DisInstSlice<'_, ISA> { + DisInstSlice::::new(self, ctx) + } +} + /// An [`Iterator`] of [`Result`]s yielding either a tuple of [`InstOffset`] and [`InstReader`], or a [`DecodeError`] #[derive(Clone, Debug)] pub struct RawInstOffsetRefIter<'a> { @@ -366,14 +349,24 @@ impl<'a> Iterator for RawInstOffsetRefIter<'a> { #[inline] fn next(&mut self) -> Option { - match InstReader::from_words(&self.raw.0[*self.offset..]) { - Ok(inst_reader) => { - let old_offset = self.offset; - *self.offset += inst_reader.len(); - Some(Ok((old_offset, inst_reader))) + let old_offset = self.offset; + if let Some(words) = self.raw.0.get(*old_offset..) { + match InstReader::from_words(words) { + Ok(inst_reader) => { + *self.offset += inst_reader.len(); + Some(Ok((old_offset, inst_reader))) + } + Err(DecodeError { + kind: DecodeErrorKind::OutOfInstructions, + .. + }) => None, + Err(e) => { + self.offset = InstOffset(!0); + Some(Err(e.with_inst_offset(old_offset))) + } } - Err(DecodeError::OutOfInstructions) => None, - Err(e) => Some(Err(e)), + } else { + None } } } diff --git a/crates/rspirv2/Cargo.toml b/crates/rspirv2/Cargo.toml index a56b66e9..1e2526dd 100644 --- a/crates/rspirv2/Cargo.toml +++ b/crates/rspirv2/Cargo.toml @@ -19,3 +19,4 @@ bytemuck = { workspace = true, optional = true } anyhow.workspace = true spv.workspace = true anstream.workspace = true +expect-test.workspace = true diff --git a/crates/rspirv2/src/core/inst.rs b/crates/rspirv2/src/core/inst.rs index da80176c..25a88fad 100644 --- a/crates/rspirv2/src/core/inst.rs +++ b/crates/rspirv2/src/core/inst.rs @@ -18,8 +18,13 @@ impl InstEncoding for OpNop { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpNop") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpNop", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -51,13 +56,18 @@ impl InstEncoding for OpUndef { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUndef{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpUndef{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -85,8 +95,18 @@ impl InstEncoding for OpSourceContinued { continued_source: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpSourceContinued{}", self.continued_source.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpSourceContinued{}", + ctx.id_result_writer(), + self.continued_source.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -126,14 +146,20 @@ impl InstEncoding for OpSource { source: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSource{}{}{}{}", - self.source_language.dis(_ctx), - self.version.dis(_ctx), - self.file.dis(_ctx), - self.source.dis(_ctx) + "{}OpSource{}{}{}{}", + ctx.id_result_writer(), + self.source_language.dis(ctx), + self.version.dis(ctx), + self.file.dis(ctx), + self.source.dis(ctx) ) } } @@ -161,8 +187,18 @@ impl InstEncoding for OpSourceExtension { extension: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpSourceExtension{}", self.extension.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpSourceExtension{}", + ctx.id_result_writer(), + self.extension.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -193,8 +229,19 @@ impl InstEncoding for OpName { name: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpName{}{}", self.target.dis(_ctx), self.name.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpName{}{}", + ctx.id_result_writer(), + self.target.dis(ctx), + self.name.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -230,13 +277,19 @@ impl InstEncoding for OpMemberName { name: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpMemberName{}{}{}", - self.ty.dis(_ctx), - self.member.dis(_ctx), - self.name.dis(_ctx) + "{}OpMemberName{}{}{}", + ctx.id_result_writer(), + self.ty.dis(ctx), + self.member.dis(ctx), + self.name.dis(ctx) ) } } @@ -269,12 +322,17 @@ impl InstEncoding for OpString { string: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpString{}", - self.id_result.dis(_ctx), - self.string.dis(_ctx) + "{}OpString{}", + ctx.id_result_writer(), + self.string.dis(ctx) ) } } @@ -311,13 +369,19 @@ impl InstEncoding for OpLine { column: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpLine{}{}{}", - self.file.dis(_ctx), - self.line.dis(_ctx), - self.column.dis(_ctx) + "{}OpLine{}{}{}", + ctx.id_result_writer(), + self.file.dis(ctx), + self.line.dis(ctx), + self.column.dis(ctx) ) } } @@ -345,8 +409,18 @@ impl InstEncoding for OpExtension { name: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpExtension{}", self.name.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpExtension{}", + ctx.id_result_writer(), + self.name.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -377,12 +451,17 @@ impl InstEncoding for OpExtInstImport { name: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpExtInstImport{}", - self.id_result.dis(_ctx), - self.name.dis(_ctx) + "{}OpExtInstImport{}", + ctx.id_result_writer(), + self.name.dis(ctx) ) } } @@ -427,16 +506,21 @@ impl InstEncoding for OpExtInst { id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpExtInst{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.set.dis(_ctx), - self.instruction.dis(_ctx), - self.id_ref.dis(_ctx) + "{}OpExtInst{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.set.dis(ctx), + self.instruction.dis(ctx), + self.id_ref.dis(ctx) ) } } @@ -469,12 +553,18 @@ impl InstEncoding for OpMemoryModel { memory_model: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpMemoryModel{}{}", - self.addressing_model.dis(_ctx), - self.memory_model.dis(_ctx) + "{}OpMemoryModel{}{}", + ctx.id_result_writer(), + self.addressing_model.dis(ctx), + self.memory_model.dis(ctx) ) } } @@ -515,14 +605,20 @@ impl InstEncoding for OpEntryPoint { interface: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpEntryPoint{}{}{}{}", - self.execution_model.dis(_ctx), - self.entry_point.dis(_ctx), - self.name.dis(_ctx), - self.interface.dis(_ctx) + "{}OpEntryPoint{}{}{}{}", + ctx.id_result_writer(), + self.execution_model.dis(ctx), + self.entry_point.dis(ctx), + self.name.dis(ctx), + self.interface.dis(ctx) ) } } @@ -555,12 +651,18 @@ impl InstEncoding for OpExecutionMode { mode: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpExecutionMode{}{}", - self.entry_point.dis(_ctx), - self.mode.dis(_ctx) + "{}OpExecutionMode{}{}", + ctx.id_result_writer(), + self.entry_point.dis(ctx), + self.mode.dis(ctx) ) } } @@ -588,8 +690,18 @@ impl InstEncoding for OpCapability { capability: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpCapability{}", self.capability.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpCapability{}", + ctx.id_result_writer(), + self.capability.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -616,8 +728,13 @@ impl InstEncoding for OpTypeVoid { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeVoid", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeVoid", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -644,8 +761,13 @@ impl InstEncoding for OpTypeBool { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeBool", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeBool", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -681,13 +803,18 @@ impl InstEncoding for OpTypeInt { signedness: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeInt{}{}", - self.id_result.dis(_ctx), - self.width.dis(_ctx), - self.signedness.dis(_ctx) + "{}OpTypeInt{}{}", + ctx.id_result_writer(), + self.width.dis(ctx), + self.signedness.dis(ctx) ) } } @@ -724,13 +851,18 @@ impl InstEncoding for OpTypeFloat { floating_point_encoding: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeFloat{}{}", - self.id_result.dis(_ctx), - self.width.dis(_ctx), - self.floating_point_encoding.dis(_ctx) + "{}OpTypeFloat{}{}", + ctx.id_result_writer(), + self.width.dis(ctx), + self.floating_point_encoding.dis(ctx) ) } } @@ -767,13 +899,18 @@ impl InstEncoding for OpTypeVector { component_count: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeVector{}{}", - self.id_result.dis(_ctx), - self.component_type.dis(_ctx), - self.component_count.dis(_ctx) + "{}OpTypeVector{}{}", + ctx.id_result_writer(), + self.component_type.dis(ctx), + self.component_count.dis(ctx) ) } } @@ -810,13 +947,18 @@ impl InstEncoding for OpTypeMatrix { column_count: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeMatrix{}{}", - self.id_result.dis(_ctx), - self.column_type.dis(_ctx), - self.column_count.dis(_ctx) + "{}OpTypeMatrix{}{}", + ctx.id_result_writer(), + self.column_type.dis(ctx), + self.column_count.dis(ctx) ) } } @@ -877,19 +1019,24 @@ impl InstEncoding for OpTypeImage { access_qualifier: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeImage{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.sampled_type.dis(_ctx), - self.dim.dis(_ctx), - self.depth.dis(_ctx), - self.arrayed.dis(_ctx), - self.ms.dis(_ctx), - self.sampled.dis(_ctx), - self.image_format.dis(_ctx), - self.access_qualifier.dis(_ctx) + "{}OpTypeImage{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.sampled_type.dis(ctx), + self.dim.dis(ctx), + self.depth.dis(ctx), + self.arrayed.dis(ctx), + self.ms.dis(ctx), + self.sampled.dis(ctx), + self.image_format.dis(ctx), + self.access_qualifier.dis(ctx) ) } } @@ -917,8 +1064,13 @@ impl InstEncoding for OpTypeSampler { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeSampler", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeSampler", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -950,12 +1102,17 @@ impl InstEncoding for OpTypeSampledImage { image_type: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeSampledImage{}", - self.id_result.dis(_ctx), - self.image_type.dis(_ctx) + "{}OpTypeSampledImage{}", + ctx.id_result_writer(), + self.image_type.dis(ctx) ) } } @@ -992,13 +1149,18 @@ impl InstEncoding for OpTypeArray { length: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeArray{}{}", - self.id_result.dis(_ctx), - self.element_type.dis(_ctx), - self.length.dis(_ctx) + "{}OpTypeArray{}{}", + ctx.id_result_writer(), + self.element_type.dis(ctx), + self.length.dis(ctx) ) } } @@ -1031,12 +1193,17 @@ impl InstEncoding for OpTypeRuntimeArray { element_type: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeRuntimeArray{}", - self.id_result.dis(_ctx), - self.element_type.dis(_ctx) + "{}OpTypeRuntimeArray{}", + ctx.id_result_writer(), + self.element_type.dis(ctx) ) } } @@ -1069,12 +1236,17 @@ impl InstEncoding for OpTypeStruct { id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeStruct{}", - self.id_result.dis(_ctx), - self.id_ref.dis(_ctx) + "{}OpTypeStruct{}", + ctx.id_result_writer(), + self.id_ref.dis(ctx) ) } } @@ -1107,12 +1279,17 @@ impl InstEncoding for OpTypeOpaque { literal_string: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeOpaque{}", - self.id_result.dis(_ctx), - self.literal_string.dis(_ctx) + "{}OpTypeOpaque{}", + ctx.id_result_writer(), + self.literal_string.dis(ctx) ) } } @@ -1149,13 +1326,18 @@ impl InstEncoding for OpTypePointer { ty: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypePointer{}{}", - self.id_result.dis(_ctx), - self.storage_class.dis(_ctx), - self.ty.dis(_ctx) + "{}OpTypePointer{}{}", + ctx.id_result_writer(), + self.storage_class.dis(ctx), + self.ty.dis(ctx) ) } } @@ -1192,13 +1374,18 @@ impl InstEncoding for OpTypeFunction { id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeFunction{}{}", - self.id_result.dis(_ctx), - self.return_type.dis(_ctx), - self.id_ref.dis(_ctx) + "{}OpTypeFunction{}{}", + ctx.id_result_writer(), + self.return_type.dis(ctx), + self.id_ref.dis(ctx) ) } } @@ -1226,8 +1413,13 @@ impl InstEncoding for OpTypeEvent { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeEvent", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeEvent", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1254,8 +1446,13 @@ impl InstEncoding for OpTypeDeviceEvent { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeDeviceEvent", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeDeviceEvent", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1282,8 +1479,13 @@ impl InstEncoding for OpTypeReserveId { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeReserveId", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeReserveId", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1310,8 +1512,13 @@ impl InstEncoding for OpTypeQueue { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeQueue", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeQueue", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1343,12 +1550,17 @@ impl InstEncoding for OpTypePipe { qualifier: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypePipe{}", - self.id_result.dis(_ctx), - self.qualifier.dis(_ctx) + "{}OpTypePipe{}", + ctx.id_result_writer(), + self.qualifier.dis(ctx) ) } } @@ -1381,12 +1593,18 @@ impl InstEncoding for OpTypeForwardPointer { storage_class: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpTypeForwardPointer{}{}", - self.pointer_type.dis(_ctx), - self.storage_class.dis(_ctx) + "{}OpTypeForwardPointer{}{}", + ctx.id_result_writer(), + self.pointer_type.dis(ctx), + self.storage_class.dis(ctx) ) } } @@ -1419,13 +1637,18 @@ impl InstEncoding for OpConstantTrue { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstantTrue{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpConstantTrue{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -1458,13 +1681,18 @@ impl InstEncoding for OpConstantFalse { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstantFalse{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpConstantFalse{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -1501,14 +1729,19 @@ impl InstEncoding for OpConstant { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstant{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx) + "{}OpConstant{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx) ) } } @@ -1545,14 +1778,19 @@ impl InstEncoding for OpConstantComposite { constituents: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstantComposite{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.constituents.dis(_ctx) + "{}OpConstantComposite{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.constituents.dis(ctx) ) } } @@ -1597,16 +1835,21 @@ impl InstEncoding for OpConstantSampler { sampler_filter_mode: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstantSampler{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampler_addressing_mode.dis(_ctx), - self.param.dis(_ctx), - self.sampler_filter_mode.dis(_ctx) + "{}OpConstantSampler{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampler_addressing_mode.dis(ctx), + self.param.dis(ctx), + self.sampler_filter_mode.dis(ctx) ) } } @@ -1639,13 +1882,18 @@ impl InstEncoding for OpConstantNull { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstantNull{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpConstantNull{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -1678,13 +1926,18 @@ impl InstEncoding for OpSpecConstantTrue { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSpecConstantTrue{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpSpecConstantTrue{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -1717,13 +1970,18 @@ impl InstEncoding for OpSpecConstantFalse { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSpecConstantFalse{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpSpecConstantFalse{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -1760,14 +2018,19 @@ impl InstEncoding for OpSpecConstant { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSpecConstant{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx) + "{}OpSpecConstant{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx) ) } } @@ -1804,14 +2067,19 @@ impl InstEncoding for OpSpecConstantComposite { constituents: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSpecConstantComposite{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.constituents.dis(_ctx) + "{}OpSpecConstantComposite{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.constituents.dis(ctx) ) } } @@ -1848,14 +2116,19 @@ impl InstEncoding for OpSpecConstantOp { opcode: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSpecConstantOp{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.opcode.dis(_ctx) + "{}OpSpecConstantOp{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.opcode.dis(ctx) ) } } @@ -1896,15 +2169,20 @@ impl InstEncoding for OpFunction { function_type: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFunction{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.function_control.dis(_ctx), - self.function_type.dis(_ctx) + "{}OpFunction{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.function_control.dis(ctx), + self.function_type.dis(ctx) ) } } @@ -1937,13 +2215,18 @@ impl InstEncoding for OpFunctionParameter { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFunctionParameter{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpFunctionParameter{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -1966,8 +2249,13 @@ impl InstEncoding for OpFunctionEnd { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpFunctionEnd") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpFunctionEnd", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2007,15 +2295,20 @@ impl InstEncoding for OpFunctionCall { id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFunctionCall{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.function.dis(_ctx), - self.id_ref.dis(_ctx) + "{}OpFunctionCall{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.function.dis(ctx), + self.id_ref.dis(ctx) ) } } @@ -2056,15 +2349,20 @@ impl InstEncoding for OpVariable { initializer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpVariable{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.storage_class.dis(_ctx), - self.initializer.dis(_ctx) + "{}OpVariable{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.storage_class.dis(ctx), + self.initializer.dis(ctx) ) } } @@ -2109,16 +2407,21 @@ impl InstEncoding for OpImageTexelPointer { sample: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageTexelPointer{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.sample.dis(_ctx) + "{}OpImageTexelPointer{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.sample.dis(ctx) ) } } @@ -2159,15 +2462,20 @@ impl InstEncoding for OpLoad { memory_access: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpLoad{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory_access.dis(_ctx) + "{}OpLoad{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory_access.dis(ctx) ) } } @@ -2204,13 +2512,19 @@ impl InstEncoding for OpStore { memory_access: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpStore{}{}{}", - self.pointer.dis(_ctx), - self.object.dis(_ctx), - self.memory_access.dis(_ctx) + "{}OpStore{}{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.object.dis(ctx), + self.memory_access.dis(ctx) ) } } @@ -2251,14 +2565,20 @@ impl InstEncoding for OpCopyMemory { memory_access_1: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCopyMemory{}{}{}{}", - self.target.dis(_ctx), - self.source.dis(_ctx), - self.memory_access_0.dis(_ctx), - self.memory_access_1.dis(_ctx) + "{}OpCopyMemory{}{}{}{}", + ctx.id_result_writer(), + self.target.dis(ctx), + self.source.dis(ctx), + self.memory_access_0.dis(ctx), + self.memory_access_1.dis(ctx) ) } } @@ -2303,15 +2623,21 @@ impl InstEncoding for OpCopyMemorySized { memory_access_1: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCopyMemorySized{}{}{}{}{}", - self.target.dis(_ctx), - self.source.dis(_ctx), - self.size.dis(_ctx), - self.memory_access_0.dis(_ctx), - self.memory_access_1.dis(_ctx) + "{}OpCopyMemorySized{}{}{}{}{}", + ctx.id_result_writer(), + self.target.dis(ctx), + self.source.dis(ctx), + self.size.dis(ctx), + self.memory_access_0.dis(ctx), + self.memory_access_1.dis(ctx) ) } } @@ -2352,15 +2678,20 @@ impl InstEncoding for OpAccessChain { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAccessChain{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpAccessChain{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -2401,15 +2732,20 @@ impl InstEncoding for OpInBoundsAccessChain { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpInBoundsAccessChain{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpInBoundsAccessChain{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -2454,16 +2790,21 @@ impl InstEncoding for OpPtrAccessChain { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpPtrAccessChain{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.element.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpPtrAccessChain{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.element.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -2504,15 +2845,20 @@ impl InstEncoding for OpArrayLength { array_member: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArrayLength{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.structure.dis(_ctx), - self.array_member.dis(_ctx) + "{}OpArrayLength{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.structure.dis(ctx), + self.array_member.dis(ctx) ) } } @@ -2549,14 +2895,19 @@ impl InstEncoding for OpGenericPtrMemSemantics { pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGenericPtrMemSemantics{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx) + "{}OpGenericPtrMemSemantics{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx) ) } } @@ -2601,16 +2952,21 @@ impl InstEncoding for OpInBoundsPtrAccessChain { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpInBoundsPtrAccessChain{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.element.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpInBoundsPtrAccessChain{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.element.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -2643,12 +2999,18 @@ impl InstEncoding for OpDecorate { decoration: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpDecorate{}{}", - self.target.dis(_ctx), - self.decoration.dis(_ctx) + "{}OpDecorate{}{}", + ctx.id_result_writer(), + self.target.dis(ctx), + self.decoration.dis(ctx) ) } } @@ -2685,13 +3047,19 @@ impl InstEncoding for OpMemberDecorate { decoration: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpMemberDecorate{}{}{}", - self.structure_type.dis(_ctx), - self.member.dis(_ctx), - self.decoration.dis(_ctx) + "{}OpMemberDecorate{}{}{}", + ctx.id_result_writer(), + self.structure_type.dis(ctx), + self.member.dis(ctx), + self.decoration.dis(ctx) ) } } @@ -2719,8 +3087,13 @@ impl InstEncoding for OpDecorationGroup { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpDecorationGroup", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpDecorationGroup", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2752,12 +3125,18 @@ impl InstEncoding for OpGroupDecorate { targets: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpGroupDecorate{}{}", - self.decoration_group.dis(_ctx), - self.targets.dis(_ctx) + "{}OpGroupDecorate{}{}", + ctx.id_result_writer(), + self.decoration_group.dis(ctx), + self.targets.dis(ctx) ) } } @@ -2790,12 +3169,18 @@ impl InstEncoding for OpGroupMemberDecorate { targets: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpGroupMemberDecorate{}{}", - self.decoration_group.dis(_ctx), - self.targets.dis(_ctx) + "{}OpGroupMemberDecorate{}{}", + ctx.id_result_writer(), + self.decoration_group.dis(ctx), + self.targets.dis(ctx) ) } } @@ -2836,15 +3221,20 @@ impl InstEncoding for OpVectorExtractDynamic { index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpVectorExtractDynamic{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector.dis(_ctx), - self.index.dis(_ctx) + "{}OpVectorExtractDynamic{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector.dis(ctx), + self.index.dis(ctx) ) } } @@ -2889,16 +3279,21 @@ impl InstEncoding for OpVectorInsertDynamic { index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpVectorInsertDynamic{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector.dis(_ctx), - self.component.dis(_ctx), - self.index.dis(_ctx) + "{}OpVectorInsertDynamic{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector.dis(ctx), + self.component.dis(ctx), + self.index.dis(ctx) ) } } @@ -2943,16 +3338,21 @@ impl InstEncoding for OpVectorShuffle { components: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpVectorShuffle{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector_1.dis(_ctx), - self.vector_2.dis(_ctx), - self.components.dis(_ctx) + "{}OpVectorShuffle{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector_1.dis(ctx), + self.vector_2.dis(ctx), + self.components.dis(ctx) ) } } @@ -2989,14 +3389,19 @@ impl InstEncoding for OpCompositeConstruct { constituents: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCompositeConstruct{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.constituents.dis(_ctx) + "{}OpCompositeConstruct{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.constituents.dis(ctx) ) } } @@ -3037,15 +3442,20 @@ impl InstEncoding for OpCompositeExtract { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCompositeExtract{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.composite.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpCompositeExtract{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.composite.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -3090,16 +3500,21 @@ impl InstEncoding for OpCompositeInsert { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCompositeInsert{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.object.dis(_ctx), - self.composite.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpCompositeInsert{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.object.dis(ctx), + self.composite.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -3136,14 +3551,19 @@ impl InstEncoding for OpCopyObject { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCopyObject{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpCopyObject{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -3180,14 +3600,19 @@ impl InstEncoding for OpTranspose { matrix: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTranspose{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.matrix.dis(_ctx) + "{}OpTranspose{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.matrix.dis(ctx) ) } } @@ -3228,15 +3653,20 @@ impl InstEncoding for OpSampledImage { sampler: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSampledImage{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.sampler.dis(_ctx) + "{}OpSampledImage{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.sampler.dis(ctx) ) } } @@ -3281,16 +3711,21 @@ impl InstEncoding for OpImageSampleImplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSampleImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3335,16 +3770,21 @@ impl InstEncoding for OpImageSampleExplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSampleExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3393,17 +3833,22 @@ impl InstEncoding for OpImageSampleDrefImplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleDrefImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSampleDrefImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3452,17 +3897,22 @@ impl InstEncoding for OpImageSampleDrefExplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleDrefExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSampleDrefExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3507,16 +3957,21 @@ impl InstEncoding for OpImageSampleProjImplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleProjImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSampleProjImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3561,16 +4016,21 @@ impl InstEncoding for OpImageSampleProjExplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleProjExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSampleProjExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3619,17 +4079,22 @@ impl InstEncoding for OpImageSampleProjDrefImplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleProjDrefImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSampleProjDrefImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3678,17 +4143,22 @@ impl InstEncoding for OpImageSampleProjDrefExplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleProjDrefExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSampleProjDrefExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3733,16 +4203,21 @@ impl InstEncoding for OpImageFetch { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageFetch{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageFetch{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3791,17 +4266,22 @@ impl InstEncoding for OpImageGather { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageGather{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.component.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageGather{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.component.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3850,17 +4330,22 @@ impl InstEncoding for OpImageDrefGather { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageDrefGather{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageDrefGather{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3905,16 +4390,21 @@ impl InstEncoding for OpImageRead { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageRead{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageRead{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3955,14 +4445,20 @@ impl InstEncoding for OpImageWrite { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpImageWrite{}{}{}{}", - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.texel.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageWrite{}{}{}{}", + ctx.id_result_writer(), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.texel.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -3999,14 +4495,19 @@ impl InstEncoding for OpImage { sampled_image: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImage{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx) + "{}OpImage{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx) ) } } @@ -4043,14 +4544,19 @@ impl InstEncoding for OpImageQueryFormat { image: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageQueryFormat{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx) + "{}OpImageQueryFormat{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx) ) } } @@ -4087,14 +4593,19 @@ impl InstEncoding for OpImageQueryOrder { image: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageQueryOrder{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx) + "{}OpImageQueryOrder{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx) ) } } @@ -4135,15 +4646,20 @@ impl InstEncoding for OpImageQuerySizeLod { level_of_detail: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageQuerySizeLod{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.level_of_detail.dis(_ctx) + "{}OpImageQuerySizeLod{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.level_of_detail.dis(ctx) ) } } @@ -4180,14 +4696,19 @@ impl InstEncoding for OpImageQuerySize { image: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageQuerySize{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx) + "{}OpImageQuerySize{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx) ) } } @@ -4228,15 +4749,20 @@ impl InstEncoding for OpImageQueryLod { coordinate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageQueryLod{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx) + "{}OpImageQueryLod{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx) ) } } @@ -4273,14 +4799,19 @@ impl InstEncoding for OpImageQueryLevels { image: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageQueryLevels{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx) + "{}OpImageQueryLevels{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx) ) } } @@ -4317,14 +4848,19 @@ impl InstEncoding for OpImageQuerySamples { image: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageQuerySamples{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx) + "{}OpImageQuerySamples{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx) ) } } @@ -4361,14 +4897,19 @@ impl InstEncoding for OpConvertFToU { float_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertFToU{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.float_value.dis(_ctx) + "{}OpConvertFToU{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.float_value.dis(ctx) ) } } @@ -4405,14 +4946,19 @@ impl InstEncoding for OpConvertFToS { float_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertFToS{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.float_value.dis(_ctx) + "{}OpConvertFToS{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.float_value.dis(ctx) ) } } @@ -4449,14 +4995,19 @@ impl InstEncoding for OpConvertSToF { signed_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertSToF{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.signed_value.dis(_ctx) + "{}OpConvertSToF{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.signed_value.dis(ctx) ) } } @@ -4493,14 +5044,19 @@ impl InstEncoding for OpConvertUToF { unsigned_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertUToF{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.unsigned_value.dis(_ctx) + "{}OpConvertUToF{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.unsigned_value.dis(ctx) ) } } @@ -4537,14 +5093,19 @@ impl InstEncoding for OpUConvert { unsigned_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUConvert{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.unsigned_value.dis(_ctx) + "{}OpUConvert{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.unsigned_value.dis(ctx) ) } } @@ -4581,14 +5142,19 @@ impl InstEncoding for OpSConvert { signed_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSConvert{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.signed_value.dis(_ctx) + "{}OpSConvert{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.signed_value.dis(ctx) ) } } @@ -4625,14 +5191,19 @@ impl InstEncoding for OpFConvert { float_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFConvert{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.float_value.dis(_ctx) + "{}OpFConvert{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.float_value.dis(ctx) ) } } @@ -4669,14 +5240,19 @@ impl InstEncoding for OpQuantizeToF16 { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpQuantizeToF16{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx) + "{}OpQuantizeToF16{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx) ) } } @@ -4713,14 +5289,19 @@ impl InstEncoding for OpConvertPtrToU { pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertPtrToU{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx) + "{}OpConvertPtrToU{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx) ) } } @@ -4757,14 +5338,19 @@ impl InstEncoding for OpSatConvertSToU { signed_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSatConvertSToU{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.signed_value.dis(_ctx) + "{}OpSatConvertSToU{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.signed_value.dis(ctx) ) } } @@ -4801,14 +5387,19 @@ impl InstEncoding for OpSatConvertUToS { unsigned_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSatConvertUToS{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.unsigned_value.dis(_ctx) + "{}OpSatConvertUToS{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.unsigned_value.dis(ctx) ) } } @@ -4845,14 +5436,19 @@ impl InstEncoding for OpConvertUToPtr { integer_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertUToPtr{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.integer_value.dis(_ctx) + "{}OpConvertUToPtr{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.integer_value.dis(ctx) ) } } @@ -4889,14 +5485,19 @@ impl InstEncoding for OpPtrCastToGeneric { pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpPtrCastToGeneric{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx) + "{}OpPtrCastToGeneric{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx) ) } } @@ -4933,14 +5534,19 @@ impl InstEncoding for OpGenericCastToPtr { pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGenericCastToPtr{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx) + "{}OpGenericCastToPtr{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx) ) } } @@ -4981,15 +5587,20 @@ impl InstEncoding for OpGenericCastToPtrExplicit { storage: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGenericCastToPtrExplicit{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.storage.dis(_ctx) + "{}OpGenericCastToPtrExplicit{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.storage.dis(ctx) ) } } @@ -5026,14 +5637,19 @@ impl InstEncoding for OpBitcast { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitcast{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpBitcast{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -5070,14 +5686,19 @@ impl InstEncoding for OpSNegate { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSNegate{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpSNegate{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -5114,14 +5735,19 @@ impl InstEncoding for OpFNegate { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFNegate{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpFNegate{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -5162,15 +5788,20 @@ impl InstEncoding for OpIAdd { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIAdd{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpIAdd{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5211,15 +5842,20 @@ impl InstEncoding for OpFAdd { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFAdd{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFAdd{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5260,15 +5896,20 @@ impl InstEncoding for OpISub { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpISub{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpISub{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5309,15 +5950,20 @@ impl InstEncoding for OpFSub { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFSub{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFSub{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5358,15 +6004,20 @@ impl InstEncoding for OpIMul { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIMul{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpIMul{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5407,15 +6058,20 @@ impl InstEncoding for OpFMul { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFMul{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFMul{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5456,15 +6112,20 @@ impl InstEncoding for OpUDiv { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUDiv{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUDiv{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5505,15 +6166,20 @@ impl InstEncoding for OpSDiv { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSDiv{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpSDiv{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5554,15 +6220,20 @@ impl InstEncoding for OpFDiv { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFDiv{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFDiv{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5603,15 +6274,20 @@ impl InstEncoding for OpUMod { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUMod{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUMod{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5652,15 +6328,20 @@ impl InstEncoding for OpSRem { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSRem{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpSRem{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5701,15 +6382,20 @@ impl InstEncoding for OpSMod { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSMod{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpSMod{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5750,15 +6436,20 @@ impl InstEncoding for OpFRem { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFRem{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFRem{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5799,15 +6490,20 @@ impl InstEncoding for OpFMod { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFMod{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFMod{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -5848,15 +6544,20 @@ impl InstEncoding for OpVectorTimesScalar { scalar: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpVectorTimesScalar{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector.dis(_ctx), - self.scalar.dis(_ctx) + "{}OpVectorTimesScalar{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector.dis(ctx), + self.scalar.dis(ctx) ) } } @@ -5897,15 +6598,20 @@ impl InstEncoding for OpMatrixTimesScalar { scalar: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpMatrixTimesScalar{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.matrix.dis(_ctx), - self.scalar.dis(_ctx) + "{}OpMatrixTimesScalar{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.matrix.dis(ctx), + self.scalar.dis(ctx) ) } } @@ -5946,15 +6652,20 @@ impl InstEncoding for OpVectorTimesMatrix { matrix: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpVectorTimesMatrix{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector.dis(_ctx), - self.matrix.dis(_ctx) + "{}OpVectorTimesMatrix{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector.dis(ctx), + self.matrix.dis(ctx) ) } } @@ -5995,15 +6706,20 @@ impl InstEncoding for OpMatrixTimesVector { vector: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpMatrixTimesVector{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.matrix.dis(_ctx), - self.vector.dis(_ctx) + "{}OpMatrixTimesVector{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.matrix.dis(ctx), + self.vector.dis(ctx) ) } } @@ -6044,15 +6760,20 @@ impl InstEncoding for OpMatrixTimesMatrix { right_matrix: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpMatrixTimesMatrix{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.left_matrix.dis(_ctx), - self.right_matrix.dis(_ctx) + "{}OpMatrixTimesMatrix{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.left_matrix.dis(ctx), + self.right_matrix.dis(ctx) ) } } @@ -6093,15 +6814,20 @@ impl InstEncoding for OpOuterProduct { vector_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpOuterProduct{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector_1.dis(_ctx), - self.vector_2.dis(_ctx) + "{}OpOuterProduct{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector_1.dis(ctx), + self.vector_2.dis(ctx) ) } } @@ -6142,15 +6868,20 @@ impl InstEncoding for OpDot { vector_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpDot{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector_1.dis(_ctx), - self.vector_2.dis(_ctx) + "{}OpDot{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector_1.dis(ctx), + self.vector_2.dis(ctx) ) } } @@ -6191,15 +6922,20 @@ impl InstEncoding for OpIAddCarry { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIAddCarry{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpIAddCarry{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -6240,15 +6976,20 @@ impl InstEncoding for OpISubBorrow { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpISubBorrow{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpISubBorrow{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -6289,15 +7030,20 @@ impl InstEncoding for OpUMulExtended { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUMulExtended{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUMulExtended{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -6338,15 +7084,20 @@ impl InstEncoding for OpSMulExtended { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSMulExtended{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpSMulExtended{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -6383,14 +7134,19 @@ impl InstEncoding for OpAny { vector: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAny{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector.dis(_ctx) + "{}OpAny{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector.dis(ctx) ) } } @@ -6427,14 +7183,19 @@ impl InstEncoding for OpAll { vector: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAll{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector.dis(_ctx) + "{}OpAll{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector.dis(ctx) ) } } @@ -6471,14 +7232,19 @@ impl InstEncoding for OpIsNan { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIsNan{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.x.dis(_ctx) + "{}OpIsNan{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.x.dis(ctx) ) } } @@ -6515,14 +7281,19 @@ impl InstEncoding for OpIsInf { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIsInf{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.x.dis(_ctx) + "{}OpIsInf{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.x.dis(ctx) ) } } @@ -6559,14 +7330,19 @@ impl InstEncoding for OpIsFinite { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIsFinite{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.x.dis(_ctx) + "{}OpIsFinite{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.x.dis(ctx) ) } } @@ -6603,14 +7379,19 @@ impl InstEncoding for OpIsNormal { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIsNormal{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.x.dis(_ctx) + "{}OpIsNormal{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.x.dis(ctx) ) } } @@ -6647,14 +7428,19 @@ impl InstEncoding for OpSignBitSet { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSignBitSet{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.x.dis(_ctx) + "{}OpSignBitSet{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.x.dis(ctx) ) } } @@ -6695,15 +7481,20 @@ impl InstEncoding for OpLessOrGreater { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpLessOrGreater{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.x.dis(_ctx), - self.y.dis(_ctx) + "{}OpLessOrGreater{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.x.dis(ctx), + self.y.dis(ctx) ) } } @@ -6744,15 +7535,20 @@ impl InstEncoding for OpOrdered { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpOrdered{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.x.dis(_ctx), - self.y.dis(_ctx) + "{}OpOrdered{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.x.dis(ctx), + self.y.dis(ctx) ) } } @@ -6793,15 +7589,20 @@ impl InstEncoding for OpUnordered { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUnordered{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.x.dis(_ctx), - self.y.dis(_ctx) + "{}OpUnordered{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.x.dis(ctx), + self.y.dis(ctx) ) } } @@ -6842,15 +7643,20 @@ impl InstEncoding for OpLogicalEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpLogicalEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpLogicalEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -6891,15 +7697,20 @@ impl InstEncoding for OpLogicalNotEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpLogicalNotEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpLogicalNotEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -6940,15 +7751,20 @@ impl InstEncoding for OpLogicalOr { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpLogicalOr{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpLogicalOr{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -6989,15 +7805,20 @@ impl InstEncoding for OpLogicalAnd { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpLogicalAnd{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpLogicalAnd{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7034,14 +7855,19 @@ impl InstEncoding for OpLogicalNot { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpLogicalNot{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpLogicalNot{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -7086,16 +7912,21 @@ impl InstEncoding for OpSelect { object_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSelect{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.condition.dis(_ctx), - self.object_1.dis(_ctx), - self.object_2.dis(_ctx) + "{}OpSelect{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.condition.dis(ctx), + self.object_1.dis(ctx), + self.object_2.dis(ctx) ) } } @@ -7136,15 +7967,20 @@ impl InstEncoding for OpIEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpIEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7185,15 +8021,20 @@ impl InstEncoding for OpINotEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpINotEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpINotEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7234,15 +8075,20 @@ impl InstEncoding for OpUGreaterThan { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUGreaterThan{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUGreaterThan{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7283,15 +8129,20 @@ impl InstEncoding for OpSGreaterThan { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSGreaterThan{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpSGreaterThan{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7332,15 +8183,20 @@ impl InstEncoding for OpUGreaterThanEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUGreaterThanEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUGreaterThanEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7381,15 +8237,20 @@ impl InstEncoding for OpSGreaterThanEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSGreaterThanEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpSGreaterThanEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7430,15 +8291,20 @@ impl InstEncoding for OpULessThan { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpULessThan{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpULessThan{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7479,15 +8345,20 @@ impl InstEncoding for OpSLessThan { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSLessThan{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpSLessThan{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7528,15 +8399,20 @@ impl InstEncoding for OpULessThanEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpULessThanEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpULessThanEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7577,15 +8453,20 @@ impl InstEncoding for OpSLessThanEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSLessThanEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpSLessThanEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7626,15 +8507,20 @@ impl InstEncoding for OpFOrdEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFOrdEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFOrdEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7675,15 +8561,20 @@ impl InstEncoding for OpFUnordEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFUnordEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFUnordEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7724,15 +8615,20 @@ impl InstEncoding for OpFOrdNotEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFOrdNotEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFOrdNotEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7773,15 +8669,20 @@ impl InstEncoding for OpFUnordNotEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFUnordNotEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFUnordNotEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7822,15 +8723,20 @@ impl InstEncoding for OpFOrdLessThan { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFOrdLessThan{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFOrdLessThan{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7871,15 +8777,20 @@ impl InstEncoding for OpFUnordLessThan { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFUnordLessThan{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFUnordLessThan{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7920,15 +8831,20 @@ impl InstEncoding for OpFOrdGreaterThan { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFOrdGreaterThan{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFOrdGreaterThan{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -7969,15 +8885,20 @@ impl InstEncoding for OpFUnordGreaterThan { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFUnordGreaterThan{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFUnordGreaterThan{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -8018,15 +8939,20 @@ impl InstEncoding for OpFOrdLessThanEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFOrdLessThanEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFOrdLessThanEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -8067,15 +8993,20 @@ impl InstEncoding for OpFUnordLessThanEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFUnordLessThanEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFUnordLessThanEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -8116,15 +9047,20 @@ impl InstEncoding for OpFOrdGreaterThanEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFOrdGreaterThanEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFOrdGreaterThanEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -8165,15 +9101,20 @@ impl InstEncoding for OpFUnordGreaterThanEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFUnordGreaterThanEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpFUnordGreaterThanEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -8214,15 +9155,20 @@ impl InstEncoding for OpShiftRightLogical { shift: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpShiftRightLogical{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.shift.dis(_ctx) + "{}OpShiftRightLogical{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.shift.dis(ctx) ) } } @@ -8263,15 +9209,20 @@ impl InstEncoding for OpShiftRightArithmetic { shift: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpShiftRightArithmetic{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.shift.dis(_ctx) + "{}OpShiftRightArithmetic{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.shift.dis(ctx) ) } } @@ -8312,15 +9263,20 @@ impl InstEncoding for OpShiftLeftLogical { shift: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpShiftLeftLogical{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.shift.dis(_ctx) + "{}OpShiftLeftLogical{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.shift.dis(ctx) ) } } @@ -8361,15 +9317,20 @@ impl InstEncoding for OpBitwiseOr { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitwiseOr{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpBitwiseOr{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -8410,15 +9371,20 @@ impl InstEncoding for OpBitwiseXor { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitwiseXor{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpBitwiseXor{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -8459,15 +9425,20 @@ impl InstEncoding for OpBitwiseAnd { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitwiseAnd{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpBitwiseAnd{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -8504,14 +9475,19 @@ impl InstEncoding for OpNot { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpNot{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpNot{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -8560,17 +9536,22 @@ impl InstEncoding for OpBitFieldInsert { count: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitFieldInsert{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.insert.dis(_ctx), - self.offset.dis(_ctx), - self.count.dis(_ctx) + "{}OpBitFieldInsert{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.insert.dis(ctx), + self.offset.dis(ctx), + self.count.dis(ctx) ) } } @@ -8615,16 +9596,21 @@ impl InstEncoding for OpBitFieldSExtract { count: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitFieldSExtract{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.offset.dis(_ctx), - self.count.dis(_ctx) + "{}OpBitFieldSExtract{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.offset.dis(ctx), + self.count.dis(ctx) ) } } @@ -8669,16 +9655,21 @@ impl InstEncoding for OpBitFieldUExtract { count: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitFieldUExtract{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.offset.dis(_ctx), - self.count.dis(_ctx) + "{}OpBitFieldUExtract{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.offset.dis(ctx), + self.count.dis(ctx) ) } } @@ -8715,14 +9706,19 @@ impl InstEncoding for OpBitReverse { base: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitReverse{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx) + "{}OpBitReverse{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx) ) } } @@ -8759,14 +9755,19 @@ impl InstEncoding for OpBitCount { base: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitCount{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx) + "{}OpBitCount{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx) ) } } @@ -8803,14 +9804,19 @@ impl InstEncoding for OpDPdx { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpDPdx{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.p.dis(_ctx) + "{}OpDPdx{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.p.dis(ctx) ) } } @@ -8847,14 +9853,19 @@ impl InstEncoding for OpDPdy { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpDPdy{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.p.dis(_ctx) + "{}OpDPdy{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.p.dis(ctx) ) } } @@ -8891,14 +9902,19 @@ impl InstEncoding for OpFwidth { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFwidth{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.p.dis(_ctx) + "{}OpFwidth{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.p.dis(ctx) ) } } @@ -8935,14 +9951,19 @@ impl InstEncoding for OpDPdxFine { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpDPdxFine{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.p.dis(_ctx) + "{}OpDPdxFine{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.p.dis(ctx) ) } } @@ -8979,14 +10000,19 @@ impl InstEncoding for OpDPdyFine { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpDPdyFine{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.p.dis(_ctx) + "{}OpDPdyFine{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.p.dis(ctx) ) } } @@ -9023,14 +10049,19 @@ impl InstEncoding for OpFwidthFine { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFwidthFine{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.p.dis(_ctx) + "{}OpFwidthFine{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.p.dis(ctx) ) } } @@ -9067,14 +10098,19 @@ impl InstEncoding for OpDPdxCoarse { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpDPdxCoarse{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.p.dis(_ctx) + "{}OpDPdxCoarse{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.p.dis(ctx) ) } } @@ -9111,14 +10147,19 @@ impl InstEncoding for OpDPdyCoarse { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpDPdyCoarse{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.p.dis(_ctx) + "{}OpDPdyCoarse{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.p.dis(ctx) ) } } @@ -9155,14 +10196,19 @@ impl InstEncoding for OpFwidthCoarse { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFwidthCoarse{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.p.dis(_ctx) + "{}OpFwidthCoarse{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.p.dis(ctx) ) } } @@ -9185,8 +10231,13 @@ impl InstEncoding for OpEmitVertex { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpEmitVertex") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpEmitVertex", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -9208,8 +10259,13 @@ impl InstEncoding for OpEndPrimitive { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpEndPrimitive") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpEndPrimitive", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -9236,8 +10292,18 @@ impl InstEncoding for OpEmitStreamVertex { stream: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpEmitStreamVertex{}", self.stream.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpEmitStreamVertex{}", + ctx.id_result_writer(), + self.stream.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -9264,8 +10330,18 @@ impl InstEncoding for OpEndStreamPrimitive { stream: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpEndStreamPrimitive{}", self.stream.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpEndStreamPrimitive{}", + ctx.id_result_writer(), + self.stream.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -9301,13 +10377,19 @@ impl InstEncoding for OpControlBarrier { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpControlBarrier{}{}{}", - self.execution.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpControlBarrier{}{}{}", + ctx.id_result_writer(), + self.execution.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -9340,12 +10422,18 @@ impl InstEncoding for OpMemoryBarrier { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpMemoryBarrier{}{}", - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpMemoryBarrier{}{}", + ctx.id_result_writer(), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -9390,16 +10478,21 @@ impl InstEncoding for OpAtomicLoad { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicLoad{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpAtomicLoad{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -9440,14 +10533,20 @@ impl InstEncoding for OpAtomicStore { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpAtomicStore{}{}{}{}", - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicStore{}{}{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -9496,17 +10595,22 @@ impl InstEncoding for OpAtomicExchange { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicExchange{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicExchange{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -9563,19 +10667,24 @@ impl InstEncoding for OpAtomicCompareExchange { comparator: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicCompareExchange{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.equal.dis(_ctx), - self.unequal.dis(_ctx), - self.value.dis(_ctx), - self.comparator.dis(_ctx) + "{}OpAtomicCompareExchange{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.equal.dis(ctx), + self.unequal.dis(ctx), + self.value.dis(ctx), + self.comparator.dis(ctx) ) } } @@ -9632,19 +10741,24 @@ impl InstEncoding for OpAtomicCompareExchangeWeak { comparator: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicCompareExchangeWeak{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.equal.dis(_ctx), - self.unequal.dis(_ctx), - self.value.dis(_ctx), - self.comparator.dis(_ctx) + "{}OpAtomicCompareExchangeWeak{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.equal.dis(ctx), + self.unequal.dis(ctx), + self.value.dis(ctx), + self.comparator.dis(ctx) ) } } @@ -9689,16 +10803,21 @@ impl InstEncoding for OpAtomicIIncrement { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicIIncrement{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpAtomicIIncrement{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -9743,16 +10862,21 @@ impl InstEncoding for OpAtomicIDecrement { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicIDecrement{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpAtomicIDecrement{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -9801,17 +10925,22 @@ impl InstEncoding for OpAtomicIAdd { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicIAdd{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicIAdd{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -9860,17 +10989,22 @@ impl InstEncoding for OpAtomicISub { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicISub{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicISub{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -9919,17 +11053,22 @@ impl InstEncoding for OpAtomicSMin { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicSMin{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicSMin{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -9978,17 +11117,22 @@ impl InstEncoding for OpAtomicUMin { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicUMin{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicUMin{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -10037,17 +11181,22 @@ impl InstEncoding for OpAtomicSMax { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicSMax{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicSMax{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -10096,17 +11245,22 @@ impl InstEncoding for OpAtomicUMax { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicUMax{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicUMax{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -10155,17 +11309,22 @@ impl InstEncoding for OpAtomicAnd { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicAnd{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicAnd{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -10214,17 +11373,22 @@ impl InstEncoding for OpAtomicOr { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicOr{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicOr{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -10273,17 +11437,22 @@ impl InstEncoding for OpAtomicXor { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicXor{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicXor{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -10320,14 +11489,19 @@ impl InstEncoding for OpPhi { pair_id_ref_id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpPhi{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pair_id_ref_id_ref.dis(_ctx) + "{}OpPhi{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pair_id_ref_id_ref.dis(ctx) ) } } @@ -10364,13 +11538,19 @@ impl InstEncoding for OpLoopMerge { loop_control: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpLoopMerge{}{}{}", - self.merge_block.dis(_ctx), - self.continue_target.dis(_ctx), - self.loop_control.dis(_ctx) + "{}OpLoopMerge{}{}{}", + ctx.id_result_writer(), + self.merge_block.dis(ctx), + self.continue_target.dis(ctx), + self.loop_control.dis(ctx) ) } } @@ -10403,12 +11583,18 @@ impl InstEncoding for OpSelectionMerge { selection_control: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSelectionMerge{}{}", - self.merge_block.dis(_ctx), - self.selection_control.dis(_ctx) + "{}OpSelectionMerge{}{}", + ctx.id_result_writer(), + self.merge_block.dis(ctx), + self.selection_control.dis(ctx) ) } } @@ -10436,8 +11622,13 @@ impl InstEncoding for OpLabel { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpLabel", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpLabel", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -10464,8 +11655,18 @@ impl InstEncoding for OpBranch { target_label: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpBranch{}", self.target_label.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpBranch{}", + ctx.id_result_writer(), + self.target_label.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -10505,14 +11706,20 @@ impl InstEncoding for OpBranchConditional { branch_weights: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpBranchConditional{}{}{}{}", - self.condition.dis(_ctx), - self.true_label.dis(_ctx), - self.false_label.dis(_ctx), - self.branch_weights.dis(_ctx) + "{}OpBranchConditional{}{}{}{}", + ctx.id_result_writer(), + self.condition.dis(ctx), + self.true_label.dis(ctx), + self.false_label.dis(ctx), + self.branch_weights.dis(ctx) ) } } @@ -10549,13 +11756,19 @@ impl InstEncoding for OpSwitch { target: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSwitch{}{}{}", - self.selector.dis(_ctx), - self.default.dis(_ctx), - self.target.dis(_ctx) + "{}OpSwitch{}{}{}", + ctx.id_result_writer(), + self.selector.dis(ctx), + self.default.dis(ctx), + self.target.dis(ctx) ) } } @@ -10578,8 +11791,13 @@ impl InstEncoding for OpKill { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpKill") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpKill", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -10601,8 +11819,13 @@ impl InstEncoding for OpReturn { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpReturn") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpReturn", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -10629,8 +11852,18 @@ impl InstEncoding for OpReturnValue { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpReturnValue{}", self.value.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpReturnValue{}", + ctx.id_result_writer(), + self.value.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -10652,8 +11885,13 @@ impl InstEncoding for OpUnreachable { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpUnreachable") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpUnreachable", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -10684,12 +11922,18 @@ impl InstEncoding for OpLifetimeStart { size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpLifetimeStart{}{}", - self.pointer.dis(_ctx), - self.size.dis(_ctx) + "{}OpLifetimeStart{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.size.dis(ctx) ) } } @@ -10721,12 +11965,18 @@ impl InstEncoding for OpLifetimeStop { size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpLifetimeStop{}{}", - self.pointer.dis(_ctx), - self.size.dis(_ctx) + "{}OpLifetimeStop{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.size.dis(ctx) ) } } @@ -10783,19 +12033,24 @@ impl InstEncoding for OpGroupAsyncCopy { event: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupAsyncCopy{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.destination.dis(_ctx), - self.source.dis(_ctx), - self.num_elements.dis(_ctx), - self.stride.dis(_ctx), - self.event.dis(_ctx) + "{}OpGroupAsyncCopy{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.destination.dis(ctx), + self.source.dis(ctx), + self.num_elements.dis(ctx), + self.stride.dis(ctx), + self.event.dis(ctx) ) } } @@ -10832,13 +12087,19 @@ impl InstEncoding for OpGroupWaitEvents { events_list: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpGroupWaitEvents{}{}{}", - self.execution.dis(_ctx), - self.num_events.dis(_ctx), - self.events_list.dis(_ctx) + "{}OpGroupWaitEvents{}{}{}", + ctx.id_result_writer(), + self.execution.dis(ctx), + self.num_events.dis(ctx), + self.events_list.dis(ctx) ) } } @@ -10879,15 +12140,20 @@ impl InstEncoding for OpGroupAll { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupAll{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpGroupAll{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -10928,15 +12194,20 @@ impl InstEncoding for OpGroupAny { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupAny{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpGroupAny{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -10981,16 +12252,21 @@ impl InstEncoding for OpGroupBroadcast { local_id: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupBroadcast{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.local_id.dis(_ctx) + "{}OpGroupBroadcast{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.local_id.dis(ctx) ) } } @@ -11035,16 +12311,21 @@ impl InstEncoding for OpGroupIAdd { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupIAdd{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupIAdd{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -11089,16 +12370,21 @@ impl InstEncoding for OpGroupFAdd { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupFAdd{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupFAdd{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -11143,16 +12429,21 @@ impl InstEncoding for OpGroupFMin { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupFMin{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupFMin{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -11197,16 +12488,21 @@ impl InstEncoding for OpGroupUMin { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupUMin{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupUMin{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -11251,16 +12547,21 @@ impl InstEncoding for OpGroupSMin { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupSMin{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupSMin{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -11305,16 +12606,21 @@ impl InstEncoding for OpGroupFMax { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupFMax{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupFMax{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -11359,16 +12665,21 @@ impl InstEncoding for OpGroupUMax { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupUMax{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupUMax{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -11413,16 +12724,21 @@ impl InstEncoding for OpGroupSMax { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupSMax{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupSMax{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -11471,17 +12787,22 @@ impl InstEncoding for OpReadPipe { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpReadPipe{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pipe.dis(_ctx), - self.pointer.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpReadPipe{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pipe.dis(ctx), + self.pointer.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -11530,17 +12851,22 @@ impl InstEncoding for OpWritePipe { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpWritePipe{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pipe.dis(_ctx), - self.pointer.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpWritePipe{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pipe.dis(ctx), + self.pointer.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -11597,19 +12923,24 @@ impl InstEncoding for OpReservedReadPipe { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpReservedReadPipe{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pipe.dis(_ctx), - self.reserve_id.dis(_ctx), - self.index.dis(_ctx), - self.pointer.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpReservedReadPipe{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pipe.dis(ctx), + self.reserve_id.dis(ctx), + self.index.dis(ctx), + self.pointer.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -11666,19 +12997,24 @@ impl InstEncoding for OpReservedWritePipe { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpReservedWritePipe{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pipe.dis(_ctx), - self.reserve_id.dis(_ctx), - self.index.dis(_ctx), - self.pointer.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpReservedWritePipe{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pipe.dis(ctx), + self.reserve_id.dis(ctx), + self.index.dis(ctx), + self.pointer.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -11727,17 +13063,22 @@ impl InstEncoding for OpReserveReadPipePackets { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpReserveReadPipePackets{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pipe.dis(_ctx), - self.num_packets.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpReserveReadPipePackets{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pipe.dis(ctx), + self.num_packets.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -11786,17 +13127,22 @@ impl InstEncoding for OpReserveWritePipePackets { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpReserveWritePipePackets{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pipe.dis(_ctx), - self.num_packets.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpReserveWritePipePackets{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pipe.dis(ctx), + self.num_packets.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -11837,14 +13183,20 @@ impl InstEncoding for OpCommitReadPipe { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCommitReadPipe{}{}{}{}", - self.pipe.dis(_ctx), - self.reserve_id.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpCommitReadPipe{}{}{}{}", + ctx.id_result_writer(), + self.pipe.dis(ctx), + self.reserve_id.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -11885,14 +13237,20 @@ impl InstEncoding for OpCommitWritePipe { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCommitWritePipe{}{}{}{}", - self.pipe.dis(_ctx), - self.reserve_id.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpCommitWritePipe{}{}{}{}", + ctx.id_result_writer(), + self.pipe.dis(ctx), + self.reserve_id.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -11929,14 +13287,19 @@ impl InstEncoding for OpIsValidReserveId { reserve_id: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIsValidReserveId{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.reserve_id.dis(_ctx) + "{}OpIsValidReserveId{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.reserve_id.dis(ctx) ) } } @@ -11981,16 +13344,21 @@ impl InstEncoding for OpGetNumPipePackets { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGetNumPipePackets{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pipe.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpGetNumPipePackets{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pipe.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -12035,16 +13403,21 @@ impl InstEncoding for OpGetMaxPipePackets { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGetMaxPipePackets{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pipe.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpGetMaxPipePackets{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pipe.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -12097,18 +13470,23 @@ impl InstEncoding for OpGroupReserveReadPipePackets { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupReserveReadPipePackets{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.pipe.dis(_ctx), - self.num_packets.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpGroupReserveReadPipePackets{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.pipe.dis(ctx), + self.num_packets.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -12161,18 +13539,23 @@ impl InstEncoding for OpGroupReserveWritePipePackets { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupReserveWritePipePackets{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.pipe.dis(_ctx), - self.num_packets.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpGroupReserveWritePipePackets{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.pipe.dis(ctx), + self.num_packets.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -12217,15 +13600,21 @@ impl InstEncoding for OpGroupCommitReadPipe { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpGroupCommitReadPipe{}{}{}{}{}", - self.execution.dis(_ctx), - self.pipe.dis(_ctx), - self.reserve_id.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpGroupCommitReadPipe{}{}{}{}{}", + ctx.id_result_writer(), + self.execution.dis(ctx), + self.pipe.dis(ctx), + self.reserve_id.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -12270,15 +13659,21 @@ impl InstEncoding for OpGroupCommitWritePipe { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpGroupCommitWritePipe{}{}{}{}{}", - self.execution.dis(_ctx), - self.pipe.dis(_ctx), - self.reserve_id.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpGroupCommitWritePipe{}{}{}{}{}", + ctx.id_result_writer(), + self.execution.dis(ctx), + self.pipe.dis(ctx), + self.reserve_id.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -12327,17 +13722,22 @@ impl InstEncoding for OpEnqueueMarker { ret_event: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpEnqueueMarker{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.queue.dis(_ctx), - self.num_events.dis(_ctx), - self.wait_events.dis(_ctx), - self.ret_event.dis(_ctx) + "{}OpEnqueueMarker{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.queue.dis(ctx), + self.num_events.dis(ctx), + self.wait_events.dis(ctx), + self.ret_event.dis(ctx) ) } } @@ -12414,24 +13814,29 @@ impl InstEncoding for OpEnqueueKernel { local_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpEnqueueKernel{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.queue.dis(_ctx), - self.flags.dis(_ctx), - self.nd_range.dis(_ctx), - self.num_events.dis(_ctx), - self.wait_events.dis(_ctx), - self.ret_event.dis(_ctx), - self.invoke.dis(_ctx), - self.param.dis(_ctx), - self.param_size.dis(_ctx), - self.param_align.dis(_ctx), - self.local_size.dis(_ctx) + "{}OpEnqueueKernel{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.queue.dis(ctx), + self.flags.dis(ctx), + self.nd_range.dis(ctx), + self.num_events.dis(ctx), + self.wait_events.dis(ctx), + self.ret_event.dis(ctx), + self.invoke.dis(ctx), + self.param.dis(ctx), + self.param_size.dis(ctx), + self.param_align.dis(ctx), + self.local_size.dis(ctx) ) } } @@ -12484,18 +13889,23 @@ impl InstEncoding for OpGetKernelNDrangeSubGroupCount { param_align: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGetKernelNDrangeSubGroupCount{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.nd_range.dis(_ctx), - self.invoke.dis(_ctx), - self.param.dis(_ctx), - self.param_size.dis(_ctx), - self.param_align.dis(_ctx) + "{}OpGetKernelNDrangeSubGroupCount{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.nd_range.dis(ctx), + self.invoke.dis(ctx), + self.param.dis(ctx), + self.param_size.dis(ctx), + self.param_align.dis(ctx) ) } } @@ -12548,18 +13958,23 @@ impl InstEncoding for OpGetKernelNDrangeMaxSubGroupSize { param_align: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGetKernelNDrangeMaxSubGroupSize{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.nd_range.dis(_ctx), - self.invoke.dis(_ctx), - self.param.dis(_ctx), - self.param_size.dis(_ctx), - self.param_align.dis(_ctx) + "{}OpGetKernelNDrangeMaxSubGroupSize{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.nd_range.dis(ctx), + self.invoke.dis(ctx), + self.param.dis(ctx), + self.param_size.dis(ctx), + self.param_align.dis(ctx) ) } } @@ -12608,17 +14023,22 @@ impl InstEncoding for OpGetKernelWorkGroupSize { param_align: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGetKernelWorkGroupSize{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.invoke.dis(_ctx), - self.param.dis(_ctx), - self.param_size.dis(_ctx), - self.param_align.dis(_ctx) + "{}OpGetKernelWorkGroupSize{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.invoke.dis(ctx), + self.param.dis(ctx), + self.param_size.dis(ctx), + self.param_align.dis(ctx) ) } } @@ -12667,17 +14087,22 @@ impl InstEncoding for OpGetKernelPreferredWorkGroupSizeMultiple { param_align: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGetKernelPreferredWorkGroupSizeMultiple{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.invoke.dis(_ctx), - self.param.dis(_ctx), - self.param_size.dis(_ctx), - self.param_align.dis(_ctx) + "{}OpGetKernelPreferredWorkGroupSizeMultiple{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.invoke.dis(ctx), + self.param.dis(ctx), + self.param_size.dis(ctx), + self.param_align.dis(ctx) ) } } @@ -12705,8 +14130,18 @@ impl InstEncoding for OpRetainEvent { event: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpRetainEvent{}", self.event.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpRetainEvent{}", + ctx.id_result_writer(), + self.event.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -12733,8 +14168,18 @@ impl InstEncoding for OpReleaseEvent { event: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpReleaseEvent{}", self.event.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpReleaseEvent{}", + ctx.id_result_writer(), + self.event.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -12766,13 +14211,18 @@ impl InstEncoding for OpCreateUserEvent { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCreateUserEvent{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpCreateUserEvent{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -12809,14 +14259,19 @@ impl InstEncoding for OpIsValidEvent { event: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIsValidEvent{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.event.dis(_ctx) + "{}OpIsValidEvent{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.event.dis(ctx) ) } } @@ -12848,12 +14303,18 @@ impl InstEncoding for OpSetUserEventStatus { status: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSetUserEventStatus{}{}", - self.event.dis(_ctx), - self.status.dis(_ctx) + "{}OpSetUserEventStatus{}{}", + ctx.id_result_writer(), + self.event.dis(ctx), + self.status.dis(ctx) ) } } @@ -12890,13 +14351,19 @@ impl InstEncoding for OpCaptureEventProfilingInfo { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCaptureEventProfilingInfo{}{}{}", - self.event.dis(_ctx), - self.profiling_info.dis(_ctx), - self.value.dis(_ctx) + "{}OpCaptureEventProfilingInfo{}{}{}", + ctx.id_result_writer(), + self.event.dis(ctx), + self.profiling_info.dis(ctx), + self.value.dis(ctx) ) } } @@ -12929,13 +14396,18 @@ impl InstEncoding for OpGetDefaultQueue { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGetDefaultQueue{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpGetDefaultQueue{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -12980,16 +14452,21 @@ impl InstEncoding for OpBuildNDRange { global_work_offset: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBuildNDRange{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.global_work_size.dis(_ctx), - self.local_work_size.dis(_ctx), - self.global_work_offset.dis(_ctx) + "{}OpBuildNDRange{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.global_work_size.dis(ctx), + self.local_work_size.dis(ctx), + self.global_work_offset.dis(ctx) ) } } @@ -13034,16 +14511,21 @@ impl InstEncoding for OpImageSparseSampleImplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseSampleImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseSampleImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13088,16 +14570,21 @@ impl InstEncoding for OpImageSparseSampleExplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseSampleExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseSampleExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13146,17 +14633,22 @@ impl InstEncoding for OpImageSparseSampleDrefImplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseSampleDrefImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseSampleDrefImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13205,17 +14697,22 @@ impl InstEncoding for OpImageSparseSampleDrefExplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseSampleDrefExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseSampleDrefExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13260,16 +14757,21 @@ impl InstEncoding for OpImageSparseSampleProjImplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseSampleProjImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseSampleProjImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13314,16 +14816,21 @@ impl InstEncoding for OpImageSparseSampleProjExplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseSampleProjExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseSampleProjExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13372,17 +14879,22 @@ impl InstEncoding for OpImageSparseSampleProjDrefImplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseSampleProjDrefImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseSampleProjDrefImplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13431,17 +14943,22 @@ impl InstEncoding for OpImageSparseSampleProjDrefExplicitLod { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseSampleProjDrefExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseSampleProjDrefExplicitLod{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13486,16 +15003,21 @@ impl InstEncoding for OpImageSparseFetch { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseFetch{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseFetch{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13544,17 +15066,22 @@ impl InstEncoding for OpImageSparseGather { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseGather{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.component.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseGather{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.component.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13603,17 +15130,22 @@ impl InstEncoding for OpImageSparseDrefGather { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseDrefGather{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.id_ref.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseDrefGather{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.id_ref.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13650,14 +15182,19 @@ impl InstEncoding for OpImageSparseTexelsResident { resident_code: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseTexelsResident{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.resident_code.dis(_ctx) + "{}OpImageSparseTexelsResident{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.resident_code.dis(ctx) ) } } @@ -13680,8 +15217,13 @@ impl InstEncoding for OpNoLine { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpNoLine") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpNoLine", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -13725,16 +15267,21 @@ impl InstEncoding for OpAtomicFlagTestAndSet { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicFlagTestAndSet{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpAtomicFlagTestAndSet{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -13771,13 +15318,19 @@ impl InstEncoding for OpAtomicFlagClear { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpAtomicFlagClear{}{}{}", - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpAtomicFlagClear{}{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -13822,16 +15375,21 @@ impl InstEncoding for OpImageSparseRead { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSparseRead{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSparseRead{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -13868,14 +15426,19 @@ impl InstEncoding for OpSizeOf { pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSizeOf{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx) + "{}OpSizeOf{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx) ) } } @@ -13903,8 +15466,13 @@ impl InstEncoding for OpTypePipeStorage { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypePipeStorage", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypePipeStorage", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -13948,16 +15516,21 @@ impl InstEncoding for OpConstantPipeStorage { capacity: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstantPipeStorage{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx), - self.capacity.dis(_ctx) + "{}OpConstantPipeStorage{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx), + self.capacity.dis(ctx) ) } } @@ -13994,14 +15567,19 @@ impl InstEncoding for OpCreatePipeFromPipeStorage { pipe_storage: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCreatePipeFromPipeStorage{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pipe_storage.dis(_ctx) + "{}OpCreatePipeFromPipeStorage{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pipe_storage.dis(ctx) ) } } @@ -14054,18 +15632,23 @@ impl InstEncoding for OpGetKernelLocalSizeForSubgroupCount { param_align: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGetKernelLocalSizeForSubgroupCount{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.subgroup_count.dis(_ctx), - self.invoke.dis(_ctx), - self.param.dis(_ctx), - self.param_size.dis(_ctx), - self.param_align.dis(_ctx) + "{}OpGetKernelLocalSizeForSubgroupCount{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.subgroup_count.dis(ctx), + self.invoke.dis(ctx), + self.param.dis(ctx), + self.param_size.dis(ctx), + self.param_align.dis(ctx) ) } } @@ -14114,17 +15697,22 @@ impl InstEncoding for OpGetKernelMaxNumSubgroups { param_align: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGetKernelMaxNumSubgroups{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.invoke.dis(_ctx), - self.param.dis(_ctx), - self.param_size.dis(_ctx), - self.param_align.dis(_ctx) + "{}OpGetKernelMaxNumSubgroups{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.invoke.dis(ctx), + self.param.dis(ctx), + self.param_size.dis(ctx), + self.param_align.dis(ctx) ) } } @@ -14152,8 +15740,13 @@ impl InstEncoding for OpTypeNamedBarrier { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeNamedBarrier", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeNamedBarrier", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -14189,14 +15782,19 @@ impl InstEncoding for OpNamedBarrierInitialize { subgroup_count: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpNamedBarrierInitialize{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.subgroup_count.dis(_ctx) + "{}OpNamedBarrierInitialize{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.subgroup_count.dis(ctx) ) } } @@ -14233,13 +15831,19 @@ impl InstEncoding for OpMemoryNamedBarrier { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpMemoryNamedBarrier{}{}{}", - self.named_barrier.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpMemoryNamedBarrier{}{}{}", + ctx.id_result_writer(), + self.named_barrier.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -14267,8 +15871,18 @@ impl InstEncoding for OpModuleProcessed { process: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpModuleProcessed{}", self.process.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpModuleProcessed{}", + ctx.id_result_writer(), + self.process.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -14300,12 +15914,18 @@ impl InstEncoding for OpExecutionModeId { mode: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpExecutionModeId{}{}", - self.entry_point.dis(_ctx), - self.mode.dis(_ctx) + "{}OpExecutionModeId{}{}", + ctx.id_result_writer(), + self.entry_point.dis(ctx), + self.mode.dis(ctx) ) } } @@ -14338,12 +15958,18 @@ impl InstEncoding for OpDecorateId { decoration: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpDecorateId{}{}", - self.target.dis(_ctx), - self.decoration.dis(_ctx) + "{}OpDecorateId{}{}", + ctx.id_result_writer(), + self.target.dis(ctx), + self.decoration.dis(ctx) ) } } @@ -14380,14 +16006,19 @@ impl InstEncoding for OpGroupNonUniformElect { execution: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformElect{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx) + "{}OpGroupNonUniformElect{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx) ) } } @@ -14428,15 +16059,20 @@ impl InstEncoding for OpGroupNonUniformAll { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformAll{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpGroupNonUniformAll{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -14477,15 +16113,20 @@ impl InstEncoding for OpGroupNonUniformAny { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformAny{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpGroupNonUniformAny{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -14526,15 +16167,20 @@ impl InstEncoding for OpGroupNonUniformAllEqual { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformAllEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx) + "{}OpGroupNonUniformAllEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx) ) } } @@ -14579,16 +16225,21 @@ impl InstEncoding for OpGroupNonUniformBroadcast { invocation_id: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBroadcast{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.invocation_id.dis(_ctx) + "{}OpGroupNonUniformBroadcast{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.invocation_id.dis(ctx) ) } } @@ -14629,15 +16280,20 @@ impl InstEncoding for OpGroupNonUniformBroadcastFirst { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBroadcastFirst{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx) + "{}OpGroupNonUniformBroadcastFirst{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx) ) } } @@ -14678,15 +16334,20 @@ impl InstEncoding for OpGroupNonUniformBallot { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBallot{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpGroupNonUniformBallot{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -14727,15 +16388,20 @@ impl InstEncoding for OpGroupNonUniformInverseBallot { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformInverseBallot{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx) + "{}OpGroupNonUniformInverseBallot{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx) ) } } @@ -14780,16 +16446,21 @@ impl InstEncoding for OpGroupNonUniformBallotBitExtract { index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBallotBitExtract{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.index.dis(_ctx) + "{}OpGroupNonUniformBallotBitExtract{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.index.dis(ctx) ) } } @@ -14834,16 +16505,21 @@ impl InstEncoding for OpGroupNonUniformBallotBitCount { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBallotBitCount{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx) + "{}OpGroupNonUniformBallotBitCount{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx) ) } } @@ -14884,15 +16560,20 @@ impl InstEncoding for OpGroupNonUniformBallotFindLSB { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBallotFindLSB{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx) + "{}OpGroupNonUniformBallotFindLSB{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx) ) } } @@ -14933,15 +16614,20 @@ impl InstEncoding for OpGroupNonUniformBallotFindMSB { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBallotFindMSB{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx) + "{}OpGroupNonUniformBallotFindMSB{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx) ) } } @@ -14986,16 +16672,21 @@ impl InstEncoding for OpGroupNonUniformShuffle { invocation_id: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformShuffle{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.invocation_id.dis(_ctx) + "{}OpGroupNonUniformShuffle{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.invocation_id.dis(ctx) ) } } @@ -15040,16 +16731,21 @@ impl InstEncoding for OpGroupNonUniformShuffleXor { mask: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformShuffleXor{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.mask.dis(_ctx) + "{}OpGroupNonUniformShuffleXor{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.mask.dis(ctx) ) } } @@ -15094,16 +16790,21 @@ impl InstEncoding for OpGroupNonUniformShuffleUp { delta: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformShuffleUp{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.delta.dis(_ctx) + "{}OpGroupNonUniformShuffleUp{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.delta.dis(ctx) ) } } @@ -15148,16 +16849,21 @@ impl InstEncoding for OpGroupNonUniformShuffleDown { delta: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformShuffleDown{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.delta.dis(_ctx) + "{}OpGroupNonUniformShuffleDown{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.delta.dis(ctx) ) } } @@ -15206,17 +16912,22 @@ impl InstEncoding for OpGroupNonUniformIAdd { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformIAdd{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformIAdd{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15265,17 +16976,22 @@ impl InstEncoding for OpGroupNonUniformFAdd { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformFAdd{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformFAdd{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15324,17 +17040,22 @@ impl InstEncoding for OpGroupNonUniformIMul { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformIMul{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformIMul{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15383,17 +17104,22 @@ impl InstEncoding for OpGroupNonUniformFMul { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformFMul{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformFMul{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15442,17 +17168,22 @@ impl InstEncoding for OpGroupNonUniformSMin { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformSMin{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformSMin{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15501,17 +17232,22 @@ impl InstEncoding for OpGroupNonUniformUMin { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformUMin{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformUMin{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15560,17 +17296,22 @@ impl InstEncoding for OpGroupNonUniformFMin { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformFMin{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformFMin{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15619,17 +17360,22 @@ impl InstEncoding for OpGroupNonUniformSMax { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformSMax{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformSMax{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15678,17 +17424,22 @@ impl InstEncoding for OpGroupNonUniformUMax { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformUMax{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformUMax{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15737,17 +17488,22 @@ impl InstEncoding for OpGroupNonUniformFMax { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformFMax{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformFMax{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15796,17 +17552,22 @@ impl InstEncoding for OpGroupNonUniformBitwiseAnd { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBitwiseAnd{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformBitwiseAnd{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15855,17 +17616,22 @@ impl InstEncoding for OpGroupNonUniformBitwiseOr { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBitwiseOr{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformBitwiseOr{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15914,17 +17680,22 @@ impl InstEncoding for OpGroupNonUniformBitwiseXor { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformBitwiseXor{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformBitwiseXor{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -15973,17 +17744,22 @@ impl InstEncoding for OpGroupNonUniformLogicalAnd { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformLogicalAnd{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformLogicalAnd{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -16032,17 +17808,22 @@ impl InstEncoding for OpGroupNonUniformLogicalOr { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformLogicalOr{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformLogicalOr{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -16091,17 +17872,22 @@ impl InstEncoding for OpGroupNonUniformLogicalXor { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformLogicalXor{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.value.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformLogicalXor{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.value.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -16146,16 +17932,21 @@ impl InstEncoding for OpGroupNonUniformQuadBroadcast { index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformQuadBroadcast{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.index.dis(_ctx) + "{}OpGroupNonUniformQuadBroadcast{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.index.dis(ctx) ) } } @@ -16200,16 +17991,21 @@ impl InstEncoding for OpGroupNonUniformQuadSwap { direction: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformQuadSwap{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.direction.dis(_ctx) + "{}OpGroupNonUniformQuadSwap{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.direction.dis(ctx) ) } } @@ -16246,14 +18042,19 @@ impl InstEncoding for OpCopyLogical { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCopyLogical{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpCopyLogical{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -16294,15 +18095,20 @@ impl InstEncoding for OpPtrEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpPtrEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpPtrEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -16343,15 +18149,20 @@ impl InstEncoding for OpPtrNotEqual { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpPtrNotEqual{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpPtrNotEqual{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -16392,15 +18203,20 @@ impl InstEncoding for OpPtrDiff { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpPtrDiff{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpPtrDiff{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -16441,15 +18257,20 @@ impl InstEncoding for OpColorAttachmentReadEXT { sample: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpColorAttachmentReadEXT{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.attachment.dis(_ctx), - self.sample.dis(_ctx) + "{}OpColorAttachmentReadEXT{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.attachment.dis(ctx), + self.sample.dis(ctx) ) } } @@ -16486,14 +18307,19 @@ impl InstEncoding for OpDepthAttachmentReadEXT { sample: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpDepthAttachmentReadEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sample.dis(_ctx) + "{}OpDepthAttachmentReadEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sample.dis(ctx) ) } } @@ -16530,14 +18356,19 @@ impl InstEncoding for OpStencilAttachmentReadEXT { sample: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpStencilAttachmentReadEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sample.dis(_ctx) + "{}OpStencilAttachmentReadEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sample.dis(ctx) ) } } @@ -16578,14 +18409,19 @@ impl InstEncoding for OpTypeTensorARM { shape: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeTensorARM{}{}{}", - self.id_result.dis(_ctx), - self.element_type.dis(_ctx), - self.rank.dis(_ctx), - self.shape.dis(_ctx) + "{}OpTypeTensorARM{}{}{}", + ctx.id_result_writer(), + self.element_type.dis(ctx), + self.rank.dis(ctx), + self.shape.dis(ctx) ) } } @@ -16630,16 +18466,21 @@ impl InstEncoding for OpTensorReadARM { tensor_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorReadARM{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor.dis(_ctx), - self.coordinates.dis(_ctx), - self.tensor_operands.dis(_ctx) + "{}OpTensorReadARM{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor.dis(ctx), + self.coordinates.dis(ctx), + self.tensor_operands.dis(ctx) ) } } @@ -16680,14 +18521,20 @@ impl InstEncoding for OpTensorWriteARM { tensor_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpTensorWriteARM{}{}{}{}", - self.tensor.dis(_ctx), - self.coordinates.dis(_ctx), - self.object.dis(_ctx), - self.tensor_operands.dis(_ctx) + "{}OpTensorWriteARM{}{}{}{}", + ctx.id_result_writer(), + self.tensor.dis(ctx), + self.coordinates.dis(ctx), + self.object.dis(ctx), + self.tensor_operands.dis(ctx) ) } } @@ -16728,15 +18575,20 @@ impl InstEncoding for OpTensorQuerySizeARM { dimension: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorQuerySizeARM{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor.dis(_ctx), - self.dimension.dis(_ctx) + "{}OpTensorQuerySizeARM{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor.dis(ctx), + self.dimension.dis(ctx) ) } } @@ -16773,14 +18625,19 @@ impl InstEncoding for OpGraphConstantARM { graph_constant_id: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGraphConstantARM{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.graph_constant_id.dis(_ctx) + "{}OpGraphConstantARM{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.graph_constant_id.dis(ctx) ) } } @@ -16817,13 +18674,19 @@ impl InstEncoding for OpGraphEntryPointARM { interface: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpGraphEntryPointARM{}{}{}", - self.graph.dis(_ctx), - self.name.dis(_ctx), - self.interface.dis(_ctx) + "{}OpGraphEntryPointARM{}{}{}", + ctx.id_result_writer(), + self.graph.dis(ctx), + self.name.dis(ctx), + self.interface.dis(ctx) ) } } @@ -16856,13 +18719,18 @@ impl InstEncoding for OpGraphARM { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGraphARM{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpGraphARM{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -16903,15 +18771,20 @@ impl InstEncoding for OpGraphInputARM { element_index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGraphInputARM{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input_index.dis(_ctx), - self.element_index.dis(_ctx) + "{}OpGraphInputARM{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input_index.dis(ctx), + self.element_index.dis(ctx) ) } } @@ -16948,13 +18821,19 @@ impl InstEncoding for OpGraphSetOutputARM { element_index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpGraphSetOutputARM{}{}{}", - self.value.dis(_ctx), - self.output_index.dis(_ctx), - self.element_index.dis(_ctx) + "{}OpGraphSetOutputARM{}{}{}", + ctx.id_result_writer(), + self.value.dis(ctx), + self.output_index.dis(ctx), + self.element_index.dis(ctx) ) } } @@ -16977,8 +18856,13 @@ impl InstEncoding for OpGraphEndARM { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpGraphEndARM") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpGraphEndARM", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -17014,13 +18898,18 @@ impl InstEncoding for OpTypeGraphARM { in_out_types: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeGraphARM{}{}", - self.id_result.dis(_ctx), - self.num_inputs.dis(_ctx), - self.in_out_types.dis(_ctx) + "{}OpTypeGraphARM{}{}", + ctx.id_result_writer(), + self.num_inputs.dis(ctx), + self.in_out_types.dis(ctx) ) } } @@ -17043,8 +18932,13 @@ impl InstEncoding for OpTerminateInvocation { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpTerminateInvocation") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTerminateInvocation", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -17076,12 +18970,17 @@ impl InstEncoding for OpTypeUntypedPointerKHR { storage_class: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeUntypedPointerKHR{}", - self.id_result.dis(_ctx), - self.storage_class.dis(_ctx) + "{}OpTypeUntypedPointerKHR{}", + ctx.id_result_writer(), + self.storage_class.dis(ctx) ) } } @@ -17126,16 +19025,21 @@ impl InstEncoding for OpUntypedVariableKHR { initializer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUntypedVariableKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.storage_class.dis(_ctx), - self.data_type.dis(_ctx), - self.initializer.dis(_ctx) + "{}OpUntypedVariableKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.storage_class.dis(ctx), + self.data_type.dis(ctx), + self.initializer.dis(ctx) ) } } @@ -17180,16 +19084,21 @@ impl InstEncoding for OpUntypedAccessChainKHR { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUntypedAccessChainKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base_type.dis(_ctx), - self.base.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpUntypedAccessChainKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base_type.dis(ctx), + self.base.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -17234,16 +19143,21 @@ impl InstEncoding for OpUntypedInBoundsAccessChainKHR { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUntypedInBoundsAccessChainKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base_type.dis(_ctx), - self.base.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpUntypedInBoundsAccessChainKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base_type.dis(ctx), + self.base.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -17280,14 +19194,19 @@ impl InstEncoding for OpSubgroupBallotKHR { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupBallotKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpSubgroupBallotKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -17324,14 +19243,19 @@ impl InstEncoding for OpSubgroupFirstInvocationKHR { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupFirstInvocationKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx) + "{}OpSubgroupFirstInvocationKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx) ) } } @@ -17380,17 +19304,22 @@ impl InstEncoding for OpUntypedPtrAccessChainKHR { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUntypedPtrAccessChainKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base_type.dis(_ctx), - self.base.dis(_ctx), - self.element.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpUntypedPtrAccessChainKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base_type.dis(ctx), + self.base.dis(ctx), + self.element.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -17439,17 +19368,22 @@ impl InstEncoding for OpUntypedInBoundsPtrAccessChainKHR { indexes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUntypedInBoundsPtrAccessChainKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base_type.dis(_ctx), - self.base.dis(_ctx), - self.element.dis(_ctx), - self.indexes.dis(_ctx) + "{}OpUntypedInBoundsPtrAccessChainKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base_type.dis(ctx), + self.base.dis(ctx), + self.element.dis(ctx), + self.indexes.dis(ctx) ) } } @@ -17494,16 +19428,21 @@ impl InstEncoding for OpUntypedArrayLengthKHR { array_member: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUntypedArrayLengthKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.structure.dis(_ctx), - self.pointer.dis(_ctx), - self.array_member.dis(_ctx) + "{}OpUntypedArrayLengthKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.structure.dis(ctx), + self.pointer.dis(ctx), + self.array_member.dis(ctx) ) } } @@ -17548,15 +19487,21 @@ impl InstEncoding for OpUntypedPrefetchKHR { cache_type: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpUntypedPrefetchKHR{}{}{}{}{}", - self.pointer_type.dis(_ctx), - self.num_bytes.dis(_ctx), - self.rw.dis(_ctx), - self.locality.dis(_ctx), - self.cache_type.dis(_ctx) + "{}OpUntypedPrefetchKHR{}{}{}{}{}", + ctx.id_result_writer(), + self.pointer_type.dis(ctx), + self.num_bytes.dis(ctx), + self.rw.dis(ctx), + self.locality.dis(ctx), + self.cache_type.dis(ctx) ) } } @@ -17601,16 +19546,21 @@ impl InstEncoding for OpFmaKHR { operand_3: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFmaKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx), - self.operand_3.dis(_ctx) + "{}OpFmaKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx), + self.operand_3.dis(ctx) ) } } @@ -17647,14 +19597,19 @@ impl InstEncoding for OpSubgroupAllKHR { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAllKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpSubgroupAllKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -17691,14 +19646,19 @@ impl InstEncoding for OpSubgroupAnyKHR { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAnyKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpSubgroupAnyKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -17735,14 +19695,19 @@ impl InstEncoding for OpSubgroupAllEqualKHR { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAllEqualKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpSubgroupAllEqualKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -17791,17 +19756,22 @@ impl InstEncoding for OpGroupNonUniformRotateKHR { cluster_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformRotateKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.value.dis(_ctx), - self.delta.dis(_ctx), - self.cluster_size.dis(_ctx) + "{}OpGroupNonUniformRotateKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.value.dis(ctx), + self.delta.dis(ctx), + self.cluster_size.dis(ctx) ) } } @@ -17842,15 +19812,20 @@ impl InstEncoding for OpSubgroupReadInvocationKHR { index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupReadInvocationKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx), - self.index.dis(_ctx) + "{}OpSubgroupReadInvocationKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx), + self.index.dis(ctx) ) } } @@ -17895,16 +19870,21 @@ impl InstEncoding for OpExtInstWithForwardRefsKHR { id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpExtInstWithForwardRefsKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.set.dis(_ctx), - self.instruction.dis(_ctx), - self.id_ref.dis(_ctx) + "{}OpExtInstWithForwardRefsKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.set.dis(ctx), + self.instruction.dis(ctx), + self.id_ref.dis(ctx) ) } } @@ -17973,22 +19953,27 @@ impl InstEncoding for OpUntypedGroupAsyncCopyKHR { source_memory_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUntypedGroupAsyncCopyKHR{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.destination.dis(_ctx), - self.source.dis(_ctx), - self.element_num_bytes.dis(_ctx), - self.num_elements.dis(_ctx), - self.stride.dis(_ctx), - self.event.dis(_ctx), - self.destination_memory_operands.dis(_ctx), - self.source_memory_operands.dis(_ctx) + "{}OpUntypedGroupAsyncCopyKHR{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.destination.dis(ctx), + self.source.dis(ctx), + self.element_num_bytes.dis(ctx), + self.num_elements.dis(ctx), + self.stride.dis(ctx), + self.event.dis(ctx), + self.destination_memory_operands.dis(ctx), + self.source_memory_operands.dis(ctx) ) } } @@ -18057,21 +20042,27 @@ impl InstEncoding for OpTraceRayKHR { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpTraceRayKHR{}{}{}{}{}{}{}{}{}{}{}", - self.accel.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cull_mask.dis(_ctx), - self.sbt_offset.dis(_ctx), - self.sbt_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx), - self.payload.dis(_ctx) + "{}OpTraceRayKHR{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.accel.dis(ctx), + self.ray_flags.dis(ctx), + self.cull_mask.dis(ctx), + self.sbt_offset.dis(ctx), + self.sbt_stride.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx), + self.payload.dis(ctx) ) } } @@ -18104,12 +20095,18 @@ impl InstEncoding for OpExecuteCallableKHR { callable_data: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpExecuteCallableKHR{}{}", - self.sbt_index.dis(_ctx), - self.callable_data.dis(_ctx) + "{}OpExecuteCallableKHR{}{}", + ctx.id_result_writer(), + self.sbt_index.dis(ctx), + self.callable_data.dis(ctx) ) } } @@ -18146,14 +20143,19 @@ impl InstEncoding for OpConvertUToAccelerationStructureKHR { accel: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertUToAccelerationStructureKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.accel.dis(_ctx) + "{}OpConvertUToAccelerationStructureKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.accel.dis(ctx) ) } } @@ -18176,8 +20178,13 @@ impl InstEncoding for OpIgnoreIntersectionKHR { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpIgnoreIntersectionKHR") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpIgnoreIntersectionKHR", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -18199,8 +20206,13 @@ impl InstEncoding for OpTerminateRayKHR { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpTerminateRayKHR") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTerminateRayKHR", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -18244,16 +20256,21 @@ impl InstEncoding for OpSDot { packed_vector_format: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSDot{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector_1.dis(_ctx), - self.vector_2.dis(_ctx), - self.packed_vector_format.dis(_ctx) + "{}OpSDot{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector_1.dis(ctx), + self.vector_2.dis(ctx), + self.packed_vector_format.dis(ctx) ) } } @@ -18298,16 +20315,21 @@ impl InstEncoding for OpUDot { packed_vector_format: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUDot{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector_1.dis(_ctx), - self.vector_2.dis(_ctx), - self.packed_vector_format.dis(_ctx) + "{}OpUDot{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector_1.dis(ctx), + self.vector_2.dis(ctx), + self.packed_vector_format.dis(ctx) ) } } @@ -18352,16 +20374,21 @@ impl InstEncoding for OpSUDot { packed_vector_format: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSUDot{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector_1.dis(_ctx), - self.vector_2.dis(_ctx), - self.packed_vector_format.dis(_ctx) + "{}OpSUDot{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector_1.dis(ctx), + self.vector_2.dis(ctx), + self.packed_vector_format.dis(ctx) ) } } @@ -18410,17 +20437,22 @@ impl InstEncoding for OpSDotAccSat { packed_vector_format: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSDotAccSat{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector_1.dis(_ctx), - self.vector_2.dis(_ctx), - self.accumulator.dis(_ctx), - self.packed_vector_format.dis(_ctx) + "{}OpSDotAccSat{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector_1.dis(ctx), + self.vector_2.dis(ctx), + self.accumulator.dis(ctx), + self.packed_vector_format.dis(ctx) ) } } @@ -18469,17 +20501,22 @@ impl InstEncoding for OpUDotAccSat { packed_vector_format: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUDotAccSat{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector_1.dis(_ctx), - self.vector_2.dis(_ctx), - self.accumulator.dis(_ctx), - self.packed_vector_format.dis(_ctx) + "{}OpUDotAccSat{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector_1.dis(ctx), + self.vector_2.dis(ctx), + self.accumulator.dis(ctx), + self.packed_vector_format.dis(ctx) ) } } @@ -18528,17 +20565,22 @@ impl InstEncoding for OpSUDotAccSat { packed_vector_format: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSUDotAccSat{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.vector_1.dis(_ctx), - self.vector_2.dis(_ctx), - self.accumulator.dis(_ctx), - self.packed_vector_format.dis(_ctx) + "{}OpSUDotAccSat{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.vector_1.dis(ctx), + self.vector_2.dis(ctx), + self.accumulator.dis(ctx), + self.packed_vector_format.dis(ctx) ) } } @@ -18587,16 +20629,21 @@ impl InstEncoding for OpTypeCooperativeMatrixKHR { usage: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeCooperativeMatrixKHR{}{}{}{}{}", - self.id_result.dis(_ctx), - self.component_type.dis(_ctx), - self.scope.dis(_ctx), - self.rows.dis(_ctx), - self.columns.dis(_ctx), - self.usage.dis(_ctx) + "{}OpTypeCooperativeMatrixKHR{}{}{}{}{}", + ctx.id_result_writer(), + self.component_type.dis(ctx), + self.scope.dis(ctx), + self.rows.dis(ctx), + self.columns.dis(ctx), + self.usage.dis(ctx) ) } } @@ -18645,17 +20692,22 @@ impl InstEncoding for OpCooperativeMatrixLoadKHR { memory_operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixLoadKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory_layout.dis(_ctx), - self.stride.dis(_ctx), - self.memory_operand.dis(_ctx) + "{}OpCooperativeMatrixLoadKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory_layout.dis(ctx), + self.stride.dis(ctx), + self.memory_operand.dis(ctx) ) } } @@ -18700,15 +20752,21 @@ impl InstEncoding for OpCooperativeMatrixStoreKHR { memory_operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCooperativeMatrixStoreKHR{}{}{}{}{}", - self.pointer.dis(_ctx), - self.object.dis(_ctx), - self.memory_layout.dis(_ctx), - self.stride.dis(_ctx), - self.memory_operand.dis(_ctx) + "{}OpCooperativeMatrixStoreKHR{}{}{}{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.object.dis(ctx), + self.memory_layout.dis(ctx), + self.stride.dis(ctx), + self.memory_operand.dis(ctx) ) } } @@ -18757,17 +20815,22 @@ impl InstEncoding for OpCooperativeMatrixMulAddKHR { cooperative_matrix_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixMulAddKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.b.dis(_ctx), - self.c.dis(_ctx), - self.cooperative_matrix_operands.dis(_ctx) + "{}OpCooperativeMatrixMulAddKHR{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.b.dis(ctx), + self.c.dis(ctx), + self.cooperative_matrix_operands.dis(ctx) ) } } @@ -18804,14 +20867,19 @@ impl InstEncoding for OpCooperativeMatrixLengthKHR { ty: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixLengthKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ty.dis(_ctx) + "{}OpCooperativeMatrixLengthKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ty.dis(ctx) ) } } @@ -18848,14 +20916,19 @@ impl InstEncoding for OpConstantCompositeReplicateEXT { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstantCompositeReplicateEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx) + "{}OpConstantCompositeReplicateEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx) ) } } @@ -18892,14 +20965,19 @@ impl InstEncoding for OpSpecConstantCompositeReplicateEXT { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSpecConstantCompositeReplicateEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx) + "{}OpSpecConstantCompositeReplicateEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx) ) } } @@ -18936,14 +21014,19 @@ impl InstEncoding for OpCompositeConstructReplicateEXT { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCompositeConstructReplicateEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx) + "{}OpCompositeConstructReplicateEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx) ) } } @@ -18971,8 +21054,13 @@ impl InstEncoding for OpTypeRayQueryKHR { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeRayQueryKHR", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeRayQueryKHR", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -19028,18 +21116,24 @@ impl InstEncoding for OpRayQueryInitializeKHR { ray_t_max: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpRayQueryInitializeKHR{}{}{}{}{}{}{}{}", - self.ray_query.dis(_ctx), - self.accel.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cull_mask.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_t_min.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_t_max.dis(_ctx) + "{}OpRayQueryInitializeKHR{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.ray_query.dis(ctx), + self.accel.dis(ctx), + self.ray_flags.dis(ctx), + self.cull_mask.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_t_min.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_t_max.dis(ctx) ) } } @@ -19067,8 +21161,18 @@ impl InstEncoding for OpRayQueryTerminateKHR { ray_query: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpRayQueryTerminateKHR{}", self.ray_query.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpRayQueryTerminateKHR{}", + ctx.id_result_writer(), + self.ray_query.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -19099,12 +21203,18 @@ impl InstEncoding for OpRayQueryGenerateIntersectionKHR { hit_t: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpRayQueryGenerateIntersectionKHR{}{}", - self.ray_query.dis(_ctx), - self.hit_t.dis(_ctx) + "{}OpRayQueryGenerateIntersectionKHR{}{}", + ctx.id_result_writer(), + self.ray_query.dis(ctx), + self.hit_t.dis(ctx) ) } } @@ -19132,11 +21242,17 @@ impl InstEncoding for OpRayQueryConfirmIntersectionKHR { ray_query: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpRayQueryConfirmIntersectionKHR{}", - self.ray_query.dis(_ctx) + "{}OpRayQueryConfirmIntersectionKHR{}", + ctx.id_result_writer(), + self.ray_query.dis(ctx) ) } } @@ -19173,14 +21289,19 @@ impl InstEncoding for OpRayQueryProceedKHR { ray_query: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryProceedKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx) + "{}OpRayQueryProceedKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx) ) } } @@ -19221,15 +21342,20 @@ impl InstEncoding for OpRayQueryGetIntersectionTypeKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionTypeKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionTypeKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -19274,16 +21400,21 @@ impl InstEncoding for OpImageSampleWeightedQCOM { weights: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleWeightedQCOM{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.texture.dis(_ctx), - self.coordinates.dis(_ctx), - self.weights.dis(_ctx) + "{}OpImageSampleWeightedQCOM{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.texture.dis(ctx), + self.coordinates.dis(ctx), + self.weights.dis(ctx) ) } } @@ -19328,16 +21459,21 @@ impl InstEncoding for OpImageBoxFilterQCOM { box_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageBoxFilterQCOM{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.texture.dis(_ctx), - self.coordinates.dis(_ctx), - self.box_size.dis(_ctx) + "{}OpImageBoxFilterQCOM{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.texture.dis(ctx), + self.coordinates.dis(ctx), + self.box_size.dis(ctx) ) } } @@ -19390,18 +21526,23 @@ impl InstEncoding for OpImageBlockMatchSSDQCOM { block_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageBlockMatchSSDQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.target.dis(_ctx), - self.target_coordinates.dis(_ctx), - self.reference.dis(_ctx), - self.reference_coordinates.dis(_ctx), - self.block_size.dis(_ctx) + "{}OpImageBlockMatchSSDQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.target.dis(ctx), + self.target_coordinates.dis(ctx), + self.reference.dis(ctx), + self.reference_coordinates.dis(ctx), + self.block_size.dis(ctx) ) } } @@ -19454,18 +21595,23 @@ impl InstEncoding for OpImageBlockMatchSADQCOM { block_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageBlockMatchSADQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.target.dis(_ctx), - self.target_coordinates.dis(_ctx), - self.reference.dis(_ctx), - self.reference_coordinates.dis(_ctx), - self.block_size.dis(_ctx) + "{}OpImageBlockMatchSADQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.target.dis(ctx), + self.target_coordinates.dis(ctx), + self.reference.dis(ctx), + self.reference_coordinates.dis(ctx), + self.block_size.dis(ctx) ) } } @@ -19502,14 +21648,19 @@ impl InstEncoding for OpBitCastArrayQCOM { source_array: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitCastArrayQCOM{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.source_array.dis(_ctx) + "{}OpBitCastArrayQCOM{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.source_array.dis(ctx) ) } } @@ -19562,18 +21713,23 @@ impl InstEncoding for OpImageBlockMatchWindowSSDQCOM { block_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageBlockMatchWindowSSDQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.target_sampled_image.dis(_ctx), - self.target_coordinates.dis(_ctx), - self.reference_sampled_image.dis(_ctx), - self.reference_coordinates.dis(_ctx), - self.block_size.dis(_ctx) + "{}OpImageBlockMatchWindowSSDQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.target_sampled_image.dis(ctx), + self.target_coordinates.dis(ctx), + self.reference_sampled_image.dis(ctx), + self.reference_coordinates.dis(ctx), + self.block_size.dis(ctx) ) } } @@ -19626,18 +21782,23 @@ impl InstEncoding for OpImageBlockMatchWindowSADQCOM { block_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageBlockMatchWindowSADQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.target_sampled_image.dis(_ctx), - self.target_coordinates.dis(_ctx), - self.reference_sampled_image.dis(_ctx), - self.reference_coordinates.dis(_ctx), - self.block_size.dis(_ctx) + "{}OpImageBlockMatchWindowSADQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.target_sampled_image.dis(ctx), + self.target_coordinates.dis(ctx), + self.reference_sampled_image.dis(ctx), + self.reference_coordinates.dis(ctx), + self.block_size.dis(ctx) ) } } @@ -19690,18 +21851,23 @@ impl InstEncoding for OpImageBlockMatchGatherSSDQCOM { block_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageBlockMatchGatherSSDQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.target_sampled_image.dis(_ctx), - self.target_coordinates.dis(_ctx), - self.reference_sampled_image.dis(_ctx), - self.reference_coordinates.dis(_ctx), - self.block_size.dis(_ctx) + "{}OpImageBlockMatchGatherSSDQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.target_sampled_image.dis(ctx), + self.target_coordinates.dis(ctx), + self.reference_sampled_image.dis(ctx), + self.reference_coordinates.dis(ctx), + self.block_size.dis(ctx) ) } } @@ -19754,18 +21920,23 @@ impl InstEncoding for OpImageBlockMatchGatherSADQCOM { block_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageBlockMatchGatherSADQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.target_sampled_image.dis(_ctx), - self.target_coordinates.dis(_ctx), - self.reference_sampled_image.dis(_ctx), - self.reference_coordinates.dis(_ctx), - self.block_size.dis(_ctx) + "{}OpImageBlockMatchGatherSADQCOM{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.target_sampled_image.dis(ctx), + self.target_coordinates.dis(ctx), + self.reference_sampled_image.dis(ctx), + self.reference_coordinates.dis(ctx), + self.block_size.dis(ctx) ) } } @@ -19802,14 +21973,19 @@ impl InstEncoding for OpCompositeConstructCoopMatQCOM { source_array: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCompositeConstructCoopMatQCOM{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.source_array.dis(_ctx) + "{}OpCompositeConstructCoopMatQCOM{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.source_array.dis(ctx) ) } } @@ -19846,14 +22022,19 @@ impl InstEncoding for OpCompositeExtractCoopMatQCOM { source_cooperative_matrix: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCompositeExtractCoopMatQCOM{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.source_cooperative_matrix.dis(_ctx) + "{}OpCompositeExtractCoopMatQCOM{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.source_cooperative_matrix.dis(ctx) ) } } @@ -19894,15 +22075,20 @@ impl InstEncoding for OpExtractSubArrayQCOM { index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpExtractSubArrayQCOM{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.source_array.dis(_ctx), - self.index.dis(_ctx) + "{}OpExtractSubArrayQCOM{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.source_array.dis(ctx), + self.index.dis(ctx) ) } } @@ -19947,16 +22133,21 @@ impl InstEncoding for OpGroupIAddNonUniformAMD { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupIAddNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupIAddNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -20001,16 +22192,21 @@ impl InstEncoding for OpGroupFAddNonUniformAMD { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupFAddNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupFAddNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -20055,16 +22251,21 @@ impl InstEncoding for OpGroupFMinNonUniformAMD { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupFMinNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupFMinNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -20109,16 +22310,21 @@ impl InstEncoding for OpGroupUMinNonUniformAMD { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupUMinNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupUMinNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -20163,16 +22369,21 @@ impl InstEncoding for OpGroupSMinNonUniformAMD { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupSMinNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupSMinNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -20217,16 +22428,21 @@ impl InstEncoding for OpGroupFMaxNonUniformAMD { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupFMaxNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupFMaxNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -20271,16 +22487,21 @@ impl InstEncoding for OpGroupUMaxNonUniformAMD { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupUMaxNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupUMaxNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -20325,16 +22546,21 @@ impl InstEncoding for OpGroupSMaxNonUniformAMD { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupSMaxNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupSMaxNonUniformAMD{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -20375,15 +22601,20 @@ impl InstEncoding for OpFragmentMaskFetchAMD { coordinate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFragmentMaskFetchAMD{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx) + "{}OpFragmentMaskFetchAMD{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx) ) } } @@ -20428,16 +22659,21 @@ impl InstEncoding for OpFragmentFetchAMD { fragment_index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFragmentFetchAMD{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.fragment_index.dis(_ctx) + "{}OpFragmentFetchAMD{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.fragment_index.dis(ctx) ) } } @@ -20474,14 +22710,19 @@ impl InstEncoding for OpReadClockKHR { scope: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpReadClockKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.scope.dis(_ctx) + "{}OpReadClockKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.scope.dis(ctx) ) } } @@ -20526,16 +22767,21 @@ impl InstEncoding for OpAllocateNodePayloadsAMDX { node_index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAllocateNodePayloadsAMDX{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.visibility.dis(_ctx), - self.payload_count.dis(_ctx), - self.node_index.dis(_ctx) + "{}OpAllocateNodePayloadsAMDX{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.visibility.dis(ctx), + self.payload_count.dis(ctx), + self.node_index.dis(ctx) ) } } @@ -20563,11 +22809,17 @@ impl InstEncoding for OpEnqueueNodePayloadsAMDX { payload_array: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpEnqueueNodePayloadsAMDX{}", - self.payload_array.dis(_ctx) + "{}OpEnqueueNodePayloadsAMDX{}", + ctx.id_result_writer(), + self.payload_array.dis(ctx) ) } } @@ -20600,12 +22852,17 @@ impl InstEncoding for OpTypeNodePayloadArrayAMDX { payload_type: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeNodePayloadArrayAMDX{}", - self.id_result.dis(_ctx), - self.payload_type.dis(_ctx) + "{}OpTypeNodePayloadArrayAMDX{}", + ctx.id_result_writer(), + self.payload_type.dis(ctx) ) } } @@ -20642,14 +22899,19 @@ impl InstEncoding for OpFinishWritingNodePayloadAMDX { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFinishWritingNodePayloadAMDX{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpFinishWritingNodePayloadAMDX{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -20686,14 +22948,19 @@ impl InstEncoding for OpNodePayloadArrayLengthAMDX { payload_array: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpNodePayloadArrayLengthAMDX{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload_array.dis(_ctx) + "{}OpNodePayloadArrayLengthAMDX{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload_array.dis(ctx) ) } } @@ -20734,15 +23001,20 @@ impl InstEncoding for OpIsNodePayloadValidAMDX { node_index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIsNodePayloadValidAMDX{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload_type.dis(_ctx), - self.node_index.dis(_ctx) + "{}OpIsNodePayloadValidAMDX{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload_type.dis(ctx), + self.node_index.dis(ctx) ) } } @@ -20775,12 +23047,17 @@ impl InstEncoding for OpConstantStringAMDX { literal_string: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpConstantStringAMDX{}", - self.id_result.dis(_ctx), - self.literal_string.dis(_ctx) + "{}OpConstantStringAMDX{}", + ctx.id_result_writer(), + self.literal_string.dis(ctx) ) } } @@ -20813,12 +23090,17 @@ impl InstEncoding for OpSpecConstantStringAMDX { literal_string: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpSpecConstantStringAMDX{}", - self.id_result.dis(_ctx), - self.literal_string.dis(_ctx) + "{}OpSpecConstantStringAMDX{}", + ctx.id_result_writer(), + self.literal_string.dis(ctx) ) } } @@ -20855,14 +23137,19 @@ impl InstEncoding for OpGroupNonUniformQuadAllKHR { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformQuadAllKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpGroupNonUniformQuadAllKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -20899,14 +23186,19 @@ impl InstEncoding for OpGroupNonUniformQuadAnyKHR { predicate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformQuadAnyKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.predicate.dis(_ctx) + "{}OpGroupNonUniformQuadAnyKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.predicate.dis(ctx) ) } } @@ -20939,12 +23231,17 @@ impl InstEncoding for OpTypeBufferEXT { storage_class: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeBufferEXT{}", - self.id_result.dis(_ctx), - self.storage_class.dis(_ctx) + "{}OpTypeBufferEXT{}", + ctx.id_result_writer(), + self.storage_class.dis(ctx) ) } } @@ -20981,14 +23278,19 @@ impl InstEncoding for OpBufferPointerEXT { buffer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBufferPointerEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.buffer.dis(_ctx) + "{}OpBufferPointerEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.buffer.dis(ctx) ) } } @@ -21037,17 +23339,22 @@ impl InstEncoding for OpUntypedImageTexelPointerEXT { sample: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUntypedImageTexelPointerEXT{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.sample.dis(_ctx) + "{}OpUntypedImageTexelPointerEXT{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.sample.dis(ctx) ) } } @@ -21084,13 +23391,19 @@ impl InstEncoding for OpMemberDecorateIdEXT { decoration: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpMemberDecorateIdEXT{}{}{}", - self.structure_type.dis(_ctx), - self.member.dis(_ctx), - self.decoration.dis(_ctx) + "{}OpMemberDecorateIdEXT{}{}{}", + ctx.id_result_writer(), + self.structure_type.dis(ctx), + self.member.dis(ctx), + self.decoration.dis(ctx) ) } } @@ -21127,14 +23440,19 @@ impl InstEncoding for OpConstantSizeOfEXT { ty: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstantSizeOfEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ty.dis(_ctx) + "{}OpConstantSizeOfEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ty.dis(ctx) ) } } @@ -21215,24 +23533,30 @@ impl InstEncoding for OpHitObjectRecordHitMotionNV { hit_object_attributes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectRecordHitMotionNV{}{}{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.instance_id.dis(_ctx), - self.primitive_id.dis(_ctx), - self.geometry_index.dis(_ctx), - self.hit_kind.dis(_ctx), - self.sbt_record_offset.dis(_ctx), - self.sbt_record_stride.dis(_ctx), - self.origin.dis(_ctx), - self.t_min.dis(_ctx), - self.direction.dis(_ctx), - self.t_max.dis(_ctx), - self.current_time.dis(_ctx), - self.hit_object_attributes.dis(_ctx) + "{}OpHitObjectRecordHitMotionNV{}{}{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.instance_id.dis(ctx), + self.primitive_id.dis(ctx), + self.geometry_index.dis(ctx), + self.hit_kind.dis(ctx), + self.sbt_record_offset.dis(ctx), + self.sbt_record_stride.dis(ctx), + self.origin.dis(ctx), + self.t_min.dis(ctx), + self.direction.dis(ctx), + self.t_max.dis(ctx), + self.current_time.dis(ctx), + self.hit_object_attributes.dis(ctx) ) } } @@ -21309,23 +23633,29 @@ impl InstEncoding for OpHitObjectRecordHitWithIndexMotionNV { hit_object_attributes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectRecordHitWithIndexMotionNV{}{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.instance_id.dis(_ctx), - self.primitive_id.dis(_ctx), - self.geometry_index.dis(_ctx), - self.hit_kind.dis(_ctx), - self.sbt_record_index.dis(_ctx), - self.origin.dis(_ctx), - self.t_min.dis(_ctx), - self.direction.dis(_ctx), - self.t_max.dis(_ctx), - self.current_time.dis(_ctx), - self.hit_object_attributes.dis(_ctx) + "{}OpHitObjectRecordHitWithIndexMotionNV{}{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.instance_id.dis(ctx), + self.primitive_id.dis(ctx), + self.geometry_index.dis(ctx), + self.hit_kind.dis(ctx), + self.sbt_record_index.dis(ctx), + self.origin.dis(ctx), + self.t_min.dis(ctx), + self.direction.dis(ctx), + self.t_max.dis(ctx), + self.current_time.dis(ctx), + self.hit_object_attributes.dis(ctx) ) } } @@ -21378,17 +23708,23 @@ impl InstEncoding for OpHitObjectRecordMissMotionNV { current_time: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectRecordMissMotionNV{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.sbt_index.dis(_ctx), - self.origin.dis(_ctx), - self.t_min.dis(_ctx), - self.direction.dis(_ctx), - self.t_max.dis(_ctx), - self.current_time.dis(_ctx) + "{}OpHitObjectRecordMissMotionNV{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.sbt_index.dis(ctx), + self.origin.dis(ctx), + self.t_min.dis(ctx), + self.direction.dis(ctx), + self.t_max.dis(ctx), + self.current_time.dis(ctx) ) } } @@ -21425,14 +23761,19 @@ impl InstEncoding for OpHitObjectGetWorldToObjectNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetWorldToObjectNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetWorldToObjectNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -21469,14 +23810,19 @@ impl InstEncoding for OpHitObjectGetObjectToWorldNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetObjectToWorldNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetObjectToWorldNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -21513,14 +23859,19 @@ impl InstEncoding for OpHitObjectGetObjectRayDirectionNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetObjectRayDirectionNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetObjectRayDirectionNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -21557,14 +23908,19 @@ impl InstEncoding for OpHitObjectGetObjectRayOriginNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetObjectRayOriginNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetObjectRayOriginNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -21641,23 +23997,29 @@ impl InstEncoding for OpHitObjectTraceRayMotionNV { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectTraceRayMotionNV{}{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cullmask.dis(_ctx), - self.sbt_record_offset.dis(_ctx), - self.sbt_record_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.origin.dis(_ctx), - self.t_min.dis(_ctx), - self.direction.dis(_ctx), - self.t_max.dis(_ctx), - self.time.dis(_ctx), - self.payload.dis(_ctx) + "{}OpHitObjectTraceRayMotionNV{}{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.ray_flags.dis(ctx), + self.cullmask.dis(ctx), + self.sbt_record_offset.dis(ctx), + self.sbt_record_stride.dis(ctx), + self.miss_index.dis(ctx), + self.origin.dis(ctx), + self.t_min.dis(ctx), + self.direction.dis(ctx), + self.t_max.dis(ctx), + self.time.dis(ctx), + self.payload.dis(ctx) ) } } @@ -21694,14 +24056,19 @@ impl InstEncoding for OpHitObjectGetShaderRecordBufferHandleNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetShaderRecordBufferHandleNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetShaderRecordBufferHandleNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -21738,14 +24105,19 @@ impl InstEncoding for OpHitObjectGetShaderBindingTableRecordIndexNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetShaderBindingTableRecordIndexNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetShaderBindingTableRecordIndexNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -21773,8 +24145,18 @@ impl InstEncoding for OpHitObjectRecordEmptyNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpHitObjectRecordEmptyNV{}", self.hit_object.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpHitObjectRecordEmptyNV{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -21846,22 +24228,28 @@ impl InstEncoding for OpHitObjectTraceRayNV { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectTraceRayNV{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cullmask.dis(_ctx), - self.sbt_record_offset.dis(_ctx), - self.sbt_record_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.origin.dis(_ctx), - self.t_min.dis(_ctx), - self.direction.dis(_ctx), - self.t_max.dis(_ctx), - self.payload.dis(_ctx) + "{}OpHitObjectTraceRayNV{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.ray_flags.dis(ctx), + self.cullmask.dis(ctx), + self.sbt_record_offset.dis(ctx), + self.sbt_record_stride.dis(ctx), + self.miss_index.dis(ctx), + self.origin.dis(ctx), + self.t_min.dis(ctx), + self.direction.dis(ctx), + self.t_max.dis(ctx), + self.payload.dis(ctx) ) } } @@ -21938,23 +24326,29 @@ impl InstEncoding for OpHitObjectRecordHitNV { hit_object_attributes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectRecordHitNV{}{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.instance_id.dis(_ctx), - self.primitive_id.dis(_ctx), - self.geometry_index.dis(_ctx), - self.hit_kind.dis(_ctx), - self.sbt_record_offset.dis(_ctx), - self.sbt_record_stride.dis(_ctx), - self.origin.dis(_ctx), - self.t_min.dis(_ctx), - self.direction.dis(_ctx), - self.t_max.dis(_ctx), - self.hit_object_attributes.dis(_ctx) + "{}OpHitObjectRecordHitNV{}{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.instance_id.dis(ctx), + self.primitive_id.dis(ctx), + self.geometry_index.dis(ctx), + self.hit_kind.dis(ctx), + self.sbt_record_offset.dis(ctx), + self.sbt_record_stride.dis(ctx), + self.origin.dis(ctx), + self.t_min.dis(ctx), + self.direction.dis(ctx), + self.t_max.dis(ctx), + self.hit_object_attributes.dis(ctx) ) } } @@ -22027,22 +24421,28 @@ impl InstEncoding for OpHitObjectRecordHitWithIndexNV { hit_object_attributes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectRecordHitWithIndexNV{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.instance_id.dis(_ctx), - self.primitive_id.dis(_ctx), - self.geometry_index.dis(_ctx), - self.hit_kind.dis(_ctx), - self.sbt_record_index.dis(_ctx), - self.origin.dis(_ctx), - self.t_min.dis(_ctx), - self.direction.dis(_ctx), - self.t_max.dis(_ctx), - self.hit_object_attributes.dis(_ctx) + "{}OpHitObjectRecordHitWithIndexNV{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.instance_id.dis(ctx), + self.primitive_id.dis(ctx), + self.geometry_index.dis(ctx), + self.hit_kind.dis(ctx), + self.sbt_record_index.dis(ctx), + self.origin.dis(ctx), + self.t_min.dis(ctx), + self.direction.dis(ctx), + self.t_max.dis(ctx), + self.hit_object_attributes.dis(ctx) ) } } @@ -22091,16 +24491,22 @@ impl InstEncoding for OpHitObjectRecordMissNV { t_max: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectRecordMissNV{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.sbt_index.dis(_ctx), - self.origin.dis(_ctx), - self.t_min.dis(_ctx), - self.direction.dis(_ctx), - self.t_max.dis(_ctx) + "{}OpHitObjectRecordMissNV{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.sbt_index.dis(ctx), + self.origin.dis(ctx), + self.t_min.dis(ctx), + self.direction.dis(ctx), + self.t_max.dis(ctx) ) } } @@ -22133,12 +24539,18 @@ impl InstEncoding for OpHitObjectExecuteShaderNV { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectExecuteShaderNV{}{}", - self.hit_object.dis(_ctx), - self.payload.dis(_ctx) + "{}OpHitObjectExecuteShaderNV{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.payload.dis(ctx) ) } } @@ -22175,14 +24587,19 @@ impl InstEncoding for OpHitObjectGetCurrentTimeNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetCurrentTimeNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetCurrentTimeNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22215,12 +24632,18 @@ impl InstEncoding for OpHitObjectGetAttributesNV { hit_object_attribute: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectGetAttributesNV{}{}", - self.hit_object.dis(_ctx), - self.hit_object_attribute.dis(_ctx) + "{}OpHitObjectGetAttributesNV{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.hit_object_attribute.dis(ctx) ) } } @@ -22257,14 +24680,19 @@ impl InstEncoding for OpHitObjectGetHitKindNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetHitKindNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetHitKindNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22301,14 +24729,19 @@ impl InstEncoding for OpHitObjectGetPrimitiveIndexNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetPrimitiveIndexNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetPrimitiveIndexNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22345,14 +24778,19 @@ impl InstEncoding for OpHitObjectGetGeometryIndexNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetGeometryIndexNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetGeometryIndexNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22389,14 +24827,19 @@ impl InstEncoding for OpHitObjectGetInstanceIdNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetInstanceIdNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetInstanceIdNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22433,14 +24876,19 @@ impl InstEncoding for OpHitObjectGetInstanceCustomIndexNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetInstanceCustomIndexNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetInstanceCustomIndexNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22477,14 +24925,19 @@ impl InstEncoding for OpHitObjectGetWorldRayDirectionNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetWorldRayDirectionNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetWorldRayDirectionNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22521,14 +24974,19 @@ impl InstEncoding for OpHitObjectGetWorldRayOriginNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetWorldRayOriginNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetWorldRayOriginNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22565,14 +25023,19 @@ impl InstEncoding for OpHitObjectGetRayTMaxNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetRayTMaxNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetRayTMaxNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22609,14 +25072,19 @@ impl InstEncoding for OpHitObjectGetRayTMinNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetRayTMinNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetRayTMinNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22653,14 +25121,19 @@ impl InstEncoding for OpHitObjectIsEmptyNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectIsEmptyNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectIsEmptyNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22697,14 +25170,19 @@ impl InstEncoding for OpHitObjectIsHitNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectIsHitNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectIsHitNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22741,14 +25219,19 @@ impl InstEncoding for OpHitObjectIsMissNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectIsMissNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectIsMissNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -22785,13 +25268,19 @@ impl InstEncoding for OpReorderThreadWithHitObjectNV { bits: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpReorderThreadWithHitObjectNV{}{}{}", - self.hit_object.dis(_ctx), - self.hint.dis(_ctx), - self.bits.dis(_ctx) + "{}OpReorderThreadWithHitObjectNV{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.hint.dis(ctx), + self.bits.dis(ctx) ) } } @@ -22822,12 +25311,18 @@ impl InstEncoding for OpReorderThreadWithHintNV { bits: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpReorderThreadWithHintNV{}{}", - self.hint.dis(_ctx), - self.bits.dis(_ctx) + "{}OpReorderThreadWithHintNV{}{}", + ctx.id_result_writer(), + self.hint.dis(ctx), + self.bits.dis(ctx) ) } } @@ -22855,8 +25350,13 @@ impl InstEncoding for OpTypeHitObjectNV { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeHitObjectNV", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeHitObjectNV", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -22908,18 +25408,23 @@ impl InstEncoding for OpImageSampleFootprintNV { image_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpImageSampleFootprintNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sampled_image.dis(_ctx), - self.coordinate.dis(_ctx), - self.granularity.dis(_ctx), - self.coarse.dis(_ctx), - self.image_operands.dis(_ctx) + "{}OpImageSampleFootprintNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sampled_image.dis(ctx), + self.coordinate.dis(ctx), + self.granularity.dis(ctx), + self.coarse.dis(ctx), + self.image_operands.dis(ctx) ) } } @@ -22956,13 +25461,18 @@ impl InstEncoding for OpTypeVectorIdEXT { component_count: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeVectorIdEXT{}{}", - self.id_result.dis(_ctx), - self.component_type.dis(_ctx), - self.component_count.dis(_ctx) + "{}OpTypeVectorIdEXT{}{}", + ctx.id_result_writer(), + self.component_type.dis(ctx), + self.component_count.dis(ctx) ) } } @@ -23039,24 +25549,29 @@ impl InstEncoding for OpCooperativeVectorMatrixMulNV { cooperative_matrix_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeVectorMatrixMulNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.input_interpretation.dis(_ctx), - self.matrix.dis(_ctx), - self.matrix_offset.dis(_ctx), - self.matrix_interpretation.dis(_ctx), - self.m.dis(_ctx), - self.k.dis(_ctx), - self.memory_layout.dis(_ctx), - self.transpose.dis(_ctx), - self.matrix_stride.dis(_ctx), - self.cooperative_matrix_operands.dis(_ctx) + "{}OpCooperativeVectorMatrixMulNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.input_interpretation.dis(ctx), + self.matrix.dis(ctx), + self.matrix_offset.dis(ctx), + self.matrix_interpretation.dis(ctx), + self.m.dis(ctx), + self.k.dis(ctx), + self.memory_layout.dis(ctx), + self.transpose.dis(ctx), + self.matrix_stride.dis(ctx), + self.cooperative_matrix_operands.dis(ctx) ) } } @@ -23109,17 +25624,23 @@ impl InstEncoding for OpCooperativeVectorOuterProductAccumulateNV { matrix_stride: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCooperativeVectorOuterProductAccumulateNV{}{}{}{}{}{}{}", - self.pointer.dis(_ctx), - self.offset.dis(_ctx), - self.a.dis(_ctx), - self.b.dis(_ctx), - self.memory_layout.dis(_ctx), - self.matrix_interpretation.dis(_ctx), - self.matrix_stride.dis(_ctx) + "{}OpCooperativeVectorOuterProductAccumulateNV{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.offset.dis(ctx), + self.a.dis(ctx), + self.b.dis(ctx), + self.memory_layout.dis(ctx), + self.matrix_interpretation.dis(ctx), + self.matrix_stride.dis(ctx) ) } } @@ -23156,13 +25677,19 @@ impl InstEncoding for OpCooperativeVectorReduceSumAccumulateNV { v: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCooperativeVectorReduceSumAccumulateNV{}{}{}", - self.pointer.dis(_ctx), - self.offset.dis(_ctx), - self.v.dis(_ctx) + "{}OpCooperativeVectorReduceSumAccumulateNV{}{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.offset.dis(ctx), + self.v.dis(ctx) ) } } @@ -23251,27 +25778,32 @@ impl InstEncoding for OpCooperativeVectorMatrixMulAddNV { cooperative_matrix_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeVectorMatrixMulAddNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.input_interpretation.dis(_ctx), - self.matrix.dis(_ctx), - self.matrix_offset.dis(_ctx), - self.matrix_interpretation.dis(_ctx), - self.bias.dis(_ctx), - self.bias_offset.dis(_ctx), - self.bias_interpretation.dis(_ctx), - self.m.dis(_ctx), - self.k.dis(_ctx), - self.memory_layout.dis(_ctx), - self.transpose.dis(_ctx), - self.matrix_stride.dis(_ctx), - self.cooperative_matrix_operands.dis(_ctx) + "{}OpCooperativeVectorMatrixMulAddNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.input_interpretation.dis(ctx), + self.matrix.dis(ctx), + self.matrix_offset.dis(ctx), + self.matrix_interpretation.dis(ctx), + self.bias.dis(ctx), + self.bias_offset.dis(ctx), + self.bias_interpretation.dis(ctx), + self.m.dis(ctx), + self.k.dis(ctx), + self.memory_layout.dis(ctx), + self.transpose.dis(ctx), + self.matrix_stride.dis(ctx), + self.cooperative_matrix_operands.dis(ctx) ) } } @@ -23308,14 +25840,19 @@ impl InstEncoding for OpCooperativeMatrixConvertNV { matrix: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixConvertNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.matrix.dis(_ctx) + "{}OpCooperativeMatrixConvertNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.matrix.dis(ctx) ) } } @@ -23356,14 +25893,20 @@ impl InstEncoding for OpEmitMeshTasksEXT { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpEmitMeshTasksEXT{}{}{}{}", - self.group_count_x.dis(_ctx), - self.group_count_y.dis(_ctx), - self.group_count_z.dis(_ctx), - self.payload.dis(_ctx) + "{}OpEmitMeshTasksEXT{}{}{}{}", + ctx.id_result_writer(), + self.group_count_x.dis(ctx), + self.group_count_y.dis(ctx), + self.group_count_z.dis(ctx), + self.payload.dis(ctx) ) } } @@ -23396,12 +25939,18 @@ impl InstEncoding for OpSetMeshOutputsEXT { primitive_count: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSetMeshOutputsEXT{}{}", - self.vertex_count.dis(_ctx), - self.primitive_count.dis(_ctx) + "{}OpSetMeshOutputsEXT{}{}", + ctx.id_result_writer(), + self.vertex_count.dis(ctx), + self.primitive_count.dis(ctx) ) } } @@ -23438,14 +25987,19 @@ impl InstEncoding for OpGroupNonUniformPartitionEXT { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupNonUniformPartitionEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx) + "{}OpGroupNonUniformPartitionEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx) ) } } @@ -23478,12 +26032,18 @@ impl InstEncoding for OpWritePackedPrimitiveIndices4x8NV { packed_indices: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpWritePackedPrimitiveIndices4x8NV{}{}", - self.index_offset.dis(_ctx), - self.packed_indices.dis(_ctx) + "{}OpWritePackedPrimitiveIndices4x8NV{}{}", + ctx.id_result_writer(), + self.index_offset.dis(ctx), + self.packed_indices.dis(ctx) ) } } @@ -23536,18 +26096,23 @@ impl InstEncoding for OpFetchMicroTriangleVertexPositionNV { barycentric: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFetchMicroTriangleVertexPositionNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.accel.dis(_ctx), - self.instance_id.dis(_ctx), - self.geometry_index.dis(_ctx), - self.primitive_index.dis(_ctx), - self.barycentric.dis(_ctx) + "{}OpFetchMicroTriangleVertexPositionNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.accel.dis(ctx), + self.instance_id.dis(ctx), + self.geometry_index.dis(ctx), + self.primitive_index.dis(ctx), + self.barycentric.dis(ctx) ) } } @@ -23600,18 +26165,23 @@ impl InstEncoding for OpFetchMicroTriangleVertexBarycentricNV { barycentric: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFetchMicroTriangleVertexBarycentricNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.accel.dis(_ctx), - self.instance_id.dis(_ctx), - self.geometry_index.dis(_ctx), - self.primitive_index.dis(_ctx), - self.barycentric.dis(_ctx) + "{}OpFetchMicroTriangleVertexBarycentricNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.accel.dis(ctx), + self.instance_id.dis(ctx), + self.geometry_index.dis(ctx), + self.primitive_index.dis(ctx), + self.barycentric.dis(ctx) ) } } @@ -23656,16 +26226,21 @@ impl InstEncoding for OpCooperativeVectorLoadNV { memory_access: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeVectorLoadNV{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.offset.dis(_ctx), - self.memory_access.dis(_ctx) + "{}OpCooperativeVectorLoadNV{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.offset.dis(ctx), + self.memory_access.dis(ctx) ) } } @@ -23706,14 +26281,20 @@ impl InstEncoding for OpCooperativeVectorStoreNV { memory_access: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCooperativeVectorStoreNV{}{}{}{}", - self.pointer.dis(_ctx), - self.offset.dis(_ctx), - self.object.dis(_ctx), - self.memory_access.dis(_ctx) + "{}OpCooperativeVectorStoreNV{}{}{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.offset.dis(ctx), + self.object.dis(ctx), + self.memory_access.dis(ctx) ) } } @@ -23754,14 +26335,20 @@ impl InstEncoding for OpHitObjectRecordFromQueryEXT { hit_object_attributes: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectRecordFromQueryEXT{}{}{}{}", - self.hit_object.dis(_ctx), - self.ray_query.dis(_ctx), - self.sbt_record_index.dis(_ctx), - self.hit_object_attributes.dis(_ctx) + "{}OpHitObjectRecordFromQueryEXT{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.ray_query.dis(ctx), + self.sbt_record_index.dis(ctx), + self.hit_object_attributes.dis(ctx) ) } } @@ -23814,17 +26401,23 @@ impl InstEncoding for OpHitObjectRecordMissEXT { ray_tmax: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectRecordMissEXT{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.ray_flags.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx) + "{}OpHitObjectRecordMissEXT{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.ray_flags.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx) ) } } @@ -23881,18 +26474,24 @@ impl InstEncoding for OpHitObjectRecordMissMotionEXT { current_time: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectRecordMissMotionEXT{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.ray_flags.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx), - self.current_time.dis(_ctx) + "{}OpHitObjectRecordMissMotionEXT{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.ray_flags.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx), + self.current_time.dis(ctx) ) } } @@ -23929,14 +26528,19 @@ impl InstEncoding for OpHitObjectGetIntersectionTriangleVertexPositionsEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetIntersectionTriangleVertexPositionsEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetIntersectionTriangleVertexPositionsEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -23973,14 +26577,19 @@ impl InstEncoding for OpHitObjectGetRayFlagsEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetRayFlagsEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetRayFlagsEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -24013,12 +26622,18 @@ impl InstEncoding for OpHitObjectSetShaderBindingTableRecordIndexEXT { sbt_record_index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectSetShaderBindingTableRecordIndexEXT{}{}", - self.hit_object.dis(_ctx), - self.sbt_record_index.dis(_ctx) + "{}OpHitObjectSetShaderBindingTableRecordIndexEXT{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.sbt_record_index.dis(ctx) ) } } @@ -24059,14 +26674,20 @@ impl InstEncoding for OpHitObjectReorderExecuteShaderEXT { bits: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectReorderExecuteShaderEXT{}{}{}{}", - self.hit_object.dis(_ctx), - self.payload.dis(_ctx), - self.hint.dis(_ctx), - self.bits.dis(_ctx) + "{}OpHitObjectReorderExecuteShaderEXT{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.payload.dis(ctx), + self.hint.dis(ctx), + self.bits.dis(ctx) ) } } @@ -24147,24 +26768,30 @@ impl InstEncoding for OpHitObjectTraceReorderExecuteEXT { bits: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectTraceReorderExecuteEXT{}{}{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cull_mask.dis(_ctx), - self.sbt_offset.dis(_ctx), - self.sbt_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx), - self.payload.dis(_ctx), - self.hint.dis(_ctx), - self.bits.dis(_ctx) + "{}OpHitObjectTraceReorderExecuteEXT{}{}{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.ray_flags.dis(ctx), + self.cull_mask.dis(ctx), + self.sbt_offset.dis(ctx), + self.sbt_stride.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx), + self.payload.dis(ctx), + self.hint.dis(ctx), + self.bits.dis(ctx) ) } } @@ -24249,25 +26876,31 @@ impl InstEncoding for OpHitObjectTraceMotionReorderExecuteEXT { bits: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectTraceMotionReorderExecuteEXT{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cull_mask.dis(_ctx), - self.sbt_offset.dis(_ctx), - self.sbt_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx), - self.current_time.dis(_ctx), - self.payload.dis(_ctx), - self.hint.dis(_ctx), - self.bits.dis(_ctx) + "{}OpHitObjectTraceMotionReorderExecuteEXT{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.ray_flags.dis(ctx), + self.cull_mask.dis(ctx), + self.sbt_offset.dis(ctx), + self.sbt_stride.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx), + self.current_time.dis(ctx), + self.payload.dis(ctx), + self.hint.dis(ctx), + self.bits.dis(ctx) ) } } @@ -24295,8 +26928,13 @@ impl InstEncoding for OpTypeHitObjectEXT { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeHitObjectEXT", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeHitObjectEXT", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -24326,12 +26964,18 @@ impl InstEncoding for OpReorderThreadWithHintEXT { bits: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpReorderThreadWithHintEXT{}{}", - self.hint.dis(_ctx), - self.bits.dis(_ctx) + "{}OpReorderThreadWithHintEXT{}{}", + ctx.id_result_writer(), + self.hint.dis(ctx), + self.bits.dis(ctx) ) } } @@ -24368,13 +27012,19 @@ impl InstEncoding for OpReorderThreadWithHitObjectEXT { bits: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpReorderThreadWithHitObjectEXT{}{}{}", - self.hit_object.dis(_ctx), - self.hint.dis(_ctx), - self.bits.dis(_ctx) + "{}OpReorderThreadWithHitObjectEXT{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.hint.dis(ctx), + self.bits.dis(ctx) ) } } @@ -24447,22 +27097,28 @@ impl InstEncoding for OpHitObjectTraceRayEXT { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectTraceRayEXT{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cull_mask.dis(_ctx), - self.sbt_offset.dis(_ctx), - self.sbt_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx), - self.payload.dis(_ctx) + "{}OpHitObjectTraceRayEXT{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.ray_flags.dis(ctx), + self.cull_mask.dis(ctx), + self.sbt_offset.dis(ctx), + self.sbt_stride.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx), + self.payload.dis(ctx) ) } } @@ -24539,23 +27195,29 @@ impl InstEncoding for OpHitObjectTraceRayMotionEXT { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectTraceRayMotionEXT{}{}{}{}{}{}{}{}{}{}{}{}{}", - self.hit_object.dis(_ctx), - self.acceleration_structure.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cull_mask.dis(_ctx), - self.sbt_offset.dis(_ctx), - self.sbt_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx), - self.current_time.dis(_ctx), - self.payload.dis(_ctx) + "{}OpHitObjectTraceRayMotionEXT{}{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.acceleration_structure.dis(ctx), + self.ray_flags.dis(ctx), + self.cull_mask.dis(ctx), + self.sbt_offset.dis(ctx), + self.sbt_stride.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx), + self.current_time.dis(ctx), + self.payload.dis(ctx) ) } } @@ -24583,8 +27245,18 @@ impl InstEncoding for OpHitObjectRecordEmptyEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpHitObjectRecordEmptyEXT{}", self.hit_object.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpHitObjectRecordEmptyEXT{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -24616,12 +27288,18 @@ impl InstEncoding for OpHitObjectExecuteShaderEXT { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectExecuteShaderEXT{}{}", - self.hit_object.dis(_ctx), - self.payload.dis(_ctx) + "{}OpHitObjectExecuteShaderEXT{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.payload.dis(ctx) ) } } @@ -24658,14 +27336,19 @@ impl InstEncoding for OpHitObjectGetCurrentTimeEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetCurrentTimeEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetCurrentTimeEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -24698,12 +27381,18 @@ impl InstEncoding for OpHitObjectGetAttributesEXT { hit_object_attribute: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpHitObjectGetAttributesEXT{}{}", - self.hit_object.dis(_ctx), - self.hit_object_attribute.dis(_ctx) + "{}OpHitObjectGetAttributesEXT{}{}", + ctx.id_result_writer(), + self.hit_object.dis(ctx), + self.hit_object_attribute.dis(ctx) ) } } @@ -24740,14 +27429,19 @@ impl InstEncoding for OpHitObjectGetHitKindEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetHitKindEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetHitKindEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -24784,14 +27478,19 @@ impl InstEncoding for OpHitObjectGetPrimitiveIndexEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetPrimitiveIndexEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetPrimitiveIndexEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -24828,14 +27527,19 @@ impl InstEncoding for OpHitObjectGetGeometryIndexEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetGeometryIndexEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetGeometryIndexEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -24872,14 +27576,19 @@ impl InstEncoding for OpHitObjectGetInstanceIdEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetInstanceIdEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetInstanceIdEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -24916,14 +27625,19 @@ impl InstEncoding for OpHitObjectGetInstanceCustomIndexEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetInstanceCustomIndexEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetInstanceCustomIndexEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -24960,14 +27674,19 @@ impl InstEncoding for OpHitObjectGetObjectRayOriginEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetObjectRayOriginEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetObjectRayOriginEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25004,14 +27723,19 @@ impl InstEncoding for OpHitObjectGetObjectRayDirectionEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetObjectRayDirectionEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetObjectRayDirectionEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25048,14 +27772,19 @@ impl InstEncoding for OpHitObjectGetWorldRayDirectionEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetWorldRayDirectionEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetWorldRayDirectionEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25092,14 +27821,19 @@ impl InstEncoding for OpHitObjectGetWorldRayOriginEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetWorldRayOriginEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetWorldRayOriginEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25136,14 +27870,19 @@ impl InstEncoding for OpHitObjectGetObjectToWorldEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetObjectToWorldEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetObjectToWorldEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25180,14 +27919,19 @@ impl InstEncoding for OpHitObjectGetWorldToObjectEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetWorldToObjectEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetWorldToObjectEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25224,14 +27968,19 @@ impl InstEncoding for OpHitObjectGetRayTMaxEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetRayTMaxEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetRayTMaxEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25272,15 +28021,20 @@ impl InstEncoding for OpReportIntersectionKHR { hit_kind: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpReportIntersectionKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit.dis(_ctx), - self.hit_kind.dis(_ctx) + "{}OpReportIntersectionKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit.dis(ctx), + self.hit_kind.dis(ctx) ) } } @@ -25303,8 +28057,13 @@ impl InstEncoding for OpIgnoreIntersectionNV { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpIgnoreIntersectionNV") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpIgnoreIntersectionNV", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -25326,8 +28085,13 @@ impl InstEncoding for OpTerminateRayNV { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpTerminateRayNV") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTerminateRayNV", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -25395,21 +28159,27 @@ impl InstEncoding for OpTraceNV { payload_id: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpTraceNV{}{}{}{}{}{}{}{}{}{}{}", - self.accel.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cull_mask.dis(_ctx), - self.sbt_offset.dis(_ctx), - self.sbt_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx), - self.payload_id.dis(_ctx) + "{}OpTraceNV{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.accel.dis(ctx), + self.ray_flags.dis(ctx), + self.cull_mask.dis(ctx), + self.sbt_offset.dis(ctx), + self.sbt_stride.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx), + self.payload_id.dis(ctx) ) } } @@ -25482,22 +28252,28 @@ impl InstEncoding for OpTraceMotionNV { payload_id: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpTraceMotionNV{}{}{}{}{}{}{}{}{}{}{}{}", - self.accel.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cull_mask.dis(_ctx), - self.sbt_offset.dis(_ctx), - self.sbt_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx), - self.time.dis(_ctx), - self.payload_id.dis(_ctx) + "{}OpTraceMotionNV{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.accel.dis(ctx), + self.ray_flags.dis(ctx), + self.cull_mask.dis(ctx), + self.sbt_offset.dis(ctx), + self.sbt_stride.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx), + self.time.dis(ctx), + self.payload_id.dis(ctx) ) } } @@ -25570,22 +28346,28 @@ impl InstEncoding for OpTraceRayMotionNV { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpTraceRayMotionNV{}{}{}{}{}{}{}{}{}{}{}{}", - self.accel.dis(_ctx), - self.ray_flags.dis(_ctx), - self.cull_mask.dis(_ctx), - self.sbt_offset.dis(_ctx), - self.sbt_stride.dis(_ctx), - self.miss_index.dis(_ctx), - self.ray_origin.dis(_ctx), - self.ray_tmin.dis(_ctx), - self.ray_direction.dis(_ctx), - self.ray_tmax.dis(_ctx), - self.time.dis(_ctx), - self.payload.dis(_ctx) + "{}OpTraceRayMotionNV{}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.accel.dis(ctx), + self.ray_flags.dis(ctx), + self.cull_mask.dis(ctx), + self.sbt_offset.dis(ctx), + self.sbt_stride.dis(ctx), + self.miss_index.dis(ctx), + self.ray_origin.dis(ctx), + self.ray_tmin.dis(ctx), + self.ray_direction.dis(ctx), + self.ray_tmax.dis(ctx), + self.time.dis(ctx), + self.payload.dis(ctx) ) } } @@ -25626,15 +28408,20 @@ impl InstEncoding for OpRayQueryGetIntersectionTriangleVertexPositionsKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionTriangleVertexPositionsKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionTriangleVertexPositionsKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -25662,11 +28449,16 @@ impl InstEncoding for OpTypeAccelerationStructureKHR { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeAccelerationStructureKHR", - self.id_result.dis(_ctx) + "{}OpTypeAccelerationStructureKHR", + ctx.id_result_writer() ) } } @@ -25699,12 +28491,18 @@ impl InstEncoding for OpExecuteCallableNV { callable_data_id: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpExecuteCallableNV{}{}", - self.sbt_index.dis(_ctx), - self.callable_data_id.dis(_ctx) + "{}OpExecuteCallableNV{}{}", + ctx.id_result_writer(), + self.sbt_index.dis(ctx), + self.callable_data_id.dis(ctx) ) } } @@ -25745,15 +28543,20 @@ impl InstEncoding for OpRayQueryGetIntersectionClusterIdNV { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionClusterIdNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionClusterIdNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -25790,14 +28593,19 @@ impl InstEncoding for OpHitObjectGetClusterIdNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetClusterIdNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetClusterIdNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25834,14 +28642,19 @@ impl InstEncoding for OpHitObjectGetRayTMinEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetRayTMinEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetRayTMinEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25878,14 +28691,19 @@ impl InstEncoding for OpHitObjectGetShaderBindingTableRecordIndexEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetShaderBindingTableRecordIndexEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetShaderBindingTableRecordIndexEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25922,14 +28740,19 @@ impl InstEncoding for OpHitObjectGetShaderRecordBufferHandleEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetShaderRecordBufferHandleEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetShaderRecordBufferHandleEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -25966,14 +28789,19 @@ impl InstEncoding for OpHitObjectIsEmptyEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectIsEmptyEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectIsEmptyEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -26010,14 +28838,19 @@ impl InstEncoding for OpHitObjectIsHitEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectIsHitEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectIsHitEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -26054,14 +28887,19 @@ impl InstEncoding for OpHitObjectIsMissEXT { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectIsMissEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectIsMissEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -26106,15 +28944,20 @@ impl InstEncoding for OpTypeCooperativeMatrixNV { columns: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeCooperativeMatrixNV{}{}{}{}", - self.id_result.dis(_ctx), - self.component_type.dis(_ctx), - self.execution.dis(_ctx), - self.rows.dis(_ctx), - self.columns.dis(_ctx) + "{}OpTypeCooperativeMatrixNV{}{}{}{}", + ctx.id_result_writer(), + self.component_type.dis(ctx), + self.execution.dis(ctx), + self.rows.dis(ctx), + self.columns.dis(ctx) ) } } @@ -26163,17 +29006,22 @@ impl InstEncoding for OpCooperativeMatrixLoadNV { memory_access: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixLoadNV{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.stride.dis(_ctx), - self.column_major.dis(_ctx), - self.memory_access.dis(_ctx) + "{}OpCooperativeMatrixLoadNV{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.stride.dis(ctx), + self.column_major.dis(ctx), + self.memory_access.dis(ctx) ) } } @@ -26218,15 +29066,21 @@ impl InstEncoding for OpCooperativeMatrixStoreNV { memory_access: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCooperativeMatrixStoreNV{}{}{}{}{}", - self.pointer.dis(_ctx), - self.object.dis(_ctx), - self.stride.dis(_ctx), - self.column_major.dis(_ctx), - self.memory_access.dis(_ctx) + "{}OpCooperativeMatrixStoreNV{}{}{}{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.object.dis(ctx), + self.stride.dis(ctx), + self.column_major.dis(ctx), + self.memory_access.dis(ctx) ) } } @@ -26271,16 +29125,21 @@ impl InstEncoding for OpCooperativeMatrixMulAddNV { c: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixMulAddNV{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.b.dis(_ctx), - self.c.dis(_ctx) + "{}OpCooperativeMatrixMulAddNV{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.b.dis(ctx), + self.c.dis(ctx) ) } } @@ -26317,14 +29176,19 @@ impl InstEncoding for OpCooperativeMatrixLengthNV { ty: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixLengthNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ty.dis(_ctx) + "{}OpCooperativeMatrixLengthNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ty.dis(ctx) ) } } @@ -26347,8 +29211,13 @@ impl InstEncoding for OpBeginInvocationInterlockEXT { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpBeginInvocationInterlockEXT") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpBeginInvocationInterlockEXT", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -26370,8 +29239,13 @@ impl InstEncoding for OpEndInvocationInterlockEXT { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpEndInvocationInterlockEXT") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpEndInvocationInterlockEXT", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -26415,16 +29289,21 @@ impl InstEncoding for OpCooperativeMatrixReduceNV { combine_func: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixReduceNV{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.matrix.dis(_ctx), - self.reduce.dis(_ctx), - self.combine_func.dis(_ctx) + "{}OpCooperativeMatrixReduceNV{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.matrix.dis(ctx), + self.reduce.dis(ctx), + self.combine_func.dis(ctx) ) } } @@ -26477,18 +29356,23 @@ impl InstEncoding for OpCooperativeMatrixLoadTensorNV { tensor_addressing_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixLoadTensorNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.object.dis(_ctx), - self.tensor_layout.dis(_ctx), - self.memory_operand.dis(_ctx), - self.tensor_addressing_operands.dis(_ctx) + "{}OpCooperativeMatrixLoadTensorNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.object.dis(ctx), + self.tensor_layout.dis(ctx), + self.memory_operand.dis(ctx), + self.tensor_addressing_operands.dis(ctx) ) } } @@ -26533,15 +29417,21 @@ impl InstEncoding for OpCooperativeMatrixStoreTensorNV { tensor_addressing_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpCooperativeMatrixStoreTensorNV{}{}{}{}{}", - self.pointer.dis(_ctx), - self.object.dis(_ctx), - self.tensor_layout.dis(_ctx), - self.memory_operand.dis(_ctx), - self.tensor_addressing_operands.dis(_ctx) + "{}OpCooperativeMatrixStoreTensorNV{}{}{}{}{}", + ctx.id_result_writer(), + self.pointer.dis(ctx), + self.object.dis(ctx), + self.tensor_layout.dis(ctx), + self.memory_operand.dis(ctx), + self.tensor_addressing_operands.dis(ctx) ) } } @@ -26586,16 +29476,21 @@ impl InstEncoding for OpCooperativeMatrixPerElementOpNV { operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixPerElementOpNV{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.matrix.dis(_ctx), - self.func.dis(_ctx), - self.operands.dis(_ctx) + "{}OpCooperativeMatrixPerElementOpNV{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.matrix.dis(ctx), + self.func.dis(ctx), + self.operands.dis(ctx) ) } } @@ -26632,13 +29527,18 @@ impl InstEncoding for OpTypeTensorLayoutNV { clamp_mode: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeTensorLayoutNV{}{}", - self.id_result.dis(_ctx), - self.dim.dis(_ctx), - self.clamp_mode.dis(_ctx) + "{}OpTypeTensorLayoutNV{}{}", + ctx.id_result_writer(), + self.dim.dis(ctx), + self.clamp_mode.dis(ctx) ) } } @@ -26679,14 +29579,19 @@ impl InstEncoding for OpTypeTensorViewNV { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeTensorViewNV{}{}{}", - self.id_result.dis(_ctx), - self.dim.dis(_ctx), - self.has_dimensions.dis(_ctx), - self.p.dis(_ctx) + "{}OpTypeTensorViewNV{}{}{}", + ctx.id_result_writer(), + self.dim.dis(ctx), + self.has_dimensions.dis(ctx), + self.p.dis(ctx) ) } } @@ -26719,13 +29624,18 @@ impl InstEncoding for OpCreateTensorLayoutNV { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCreateTensorLayoutNV{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpCreateTensorLayoutNV{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -26766,15 +29676,20 @@ impl InstEncoding for OpTensorLayoutSetDimensionNV { dim: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorLayoutSetDimensionNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor_layout.dis(_ctx), - self.dim.dis(_ctx) + "{}OpTensorLayoutSetDimensionNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor_layout.dis(ctx), + self.dim.dis(ctx) ) } } @@ -26815,15 +29730,20 @@ impl InstEncoding for OpTensorLayoutSetStrideNV { stride: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorLayoutSetStrideNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor_layout.dis(_ctx), - self.stride.dis(_ctx) + "{}OpTensorLayoutSetStrideNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor_layout.dis(ctx), + self.stride.dis(ctx) ) } } @@ -26864,15 +29784,20 @@ impl InstEncoding for OpTensorLayoutSliceNV { operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorLayoutSliceNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor_layout.dis(_ctx), - self.operands.dis(_ctx) + "{}OpTensorLayoutSliceNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor_layout.dis(ctx), + self.operands.dis(ctx) ) } } @@ -26913,15 +29838,20 @@ impl InstEncoding for OpTensorLayoutSetClampValueNV { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorLayoutSetClampValueNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor_layout.dis(_ctx), - self.value.dis(_ctx) + "{}OpTensorLayoutSetClampValueNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor_layout.dis(ctx), + self.value.dis(ctx) ) } } @@ -26954,13 +29884,18 @@ impl InstEncoding for OpCreateTensorViewNV { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCreateTensorViewNV{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpCreateTensorViewNV{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -27001,15 +29936,20 @@ impl InstEncoding for OpTensorViewSetDimensionNV { dim: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorViewSetDimensionNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor_view.dis(_ctx), - self.dim.dis(_ctx) + "{}OpTensorViewSetDimensionNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor_view.dis(ctx), + self.dim.dis(ctx) ) } } @@ -27050,15 +29990,20 @@ impl InstEncoding for OpTensorViewSetStrideNV { stride: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorViewSetStrideNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor_view.dis(_ctx), - self.stride.dis(_ctx) + "{}OpTensorViewSetStrideNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor_view.dis(ctx), + self.stride.dis(ctx) ) } } @@ -27081,8 +30026,13 @@ impl InstEncoding for OpDemoteToHelperInvocation { reader.check_opcode(Self::META)?; Ok(Self {}) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpDemoteToHelperInvocation") + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}OpDemoteToHelperInvocation", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -27114,13 +30064,18 @@ impl InstEncoding for OpIsHelperInvocationEXT { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIsHelperInvocationEXT{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpIsHelperInvocationEXT{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -27173,18 +30128,23 @@ impl InstEncoding for OpTensorViewSetClipNV { clip_col_span: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorViewSetClipNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor_view.dis(_ctx), - self.clip_row_offset.dis(_ctx), - self.clip_row_span.dis(_ctx), - self.clip_col_offset.dis(_ctx), - self.clip_col_span.dis(_ctx) + "{}OpTensorViewSetClipNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor_view.dis(ctx), + self.clip_row_offset.dis(ctx), + self.clip_row_span.dis(ctx), + self.clip_col_offset.dis(ctx), + self.clip_col_span.dis(ctx) ) } } @@ -27225,15 +30185,20 @@ impl InstEncoding for OpTensorLayoutSetBlockSizeNV { block_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTensorLayoutSetBlockSizeNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.tensor_layout.dis(_ctx), - self.block_size.dis(_ctx) + "{}OpTensorLayoutSetBlockSizeNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.tensor_layout.dis(ctx), + self.block_size.dis(ctx) ) } } @@ -27270,14 +30235,19 @@ impl InstEncoding for OpCooperativeMatrixTransposeNV { matrix: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCooperativeMatrixTransposeNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.matrix.dis(_ctx) + "{}OpCooperativeMatrixTransposeNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.matrix.dis(ctx) ) } } @@ -27314,14 +30284,19 @@ impl InstEncoding for OpConvertUToImageNV { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertUToImageNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpConvertUToImageNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -27358,14 +30333,19 @@ impl InstEncoding for OpConvertUToSamplerNV { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertUToSamplerNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpConvertUToSamplerNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -27402,14 +30382,19 @@ impl InstEncoding for OpConvertImageToUNV { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertImageToUNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpConvertImageToUNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -27446,14 +30431,19 @@ impl InstEncoding for OpConvertSamplerToUNV { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertSamplerToUNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpConvertSamplerToUNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -27490,14 +30480,19 @@ impl InstEncoding for OpConvertUToSampledImageNV { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertUToSampledImageNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpConvertUToSampledImageNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -27534,14 +30529,19 @@ impl InstEncoding for OpConvertSampledImageToUNV { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertSampledImageToUNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpConvertSampledImageToUNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -27569,11 +30569,17 @@ impl InstEncoding for OpSamplerImageAddressingModeNV { bit_width: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSamplerImageAddressingModeNV{}", - self.bit_width.dis(_ctx) + "{}OpSamplerImageAddressingModeNV{}", + ctx.id_result_writer(), + self.bit_width.dis(ctx) ) } } @@ -27626,18 +30632,23 @@ impl InstEncoding for OpRawAccessChainNV { raw_access_chain_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRawAccessChainNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.base.dis(_ctx), - self.byte_stride.dis(_ctx), - self.element_index.dis(_ctx), - self.byte_offset.dis(_ctx), - self.raw_access_chain_operands.dis(_ctx) + "{}OpRawAccessChainNV{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.base.dis(ctx), + self.byte_stride.dis(ctx), + self.element_index.dis(ctx), + self.byte_offset.dis(ctx), + self.raw_access_chain_operands.dis(ctx) ) } } @@ -27678,15 +30689,20 @@ impl InstEncoding for OpRayQueryGetIntersectionSpherePositionNV { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionSpherePositionNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionSpherePositionNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -27727,15 +30743,20 @@ impl InstEncoding for OpRayQueryGetIntersectionSphereRadiusNV { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionSphereRadiusNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionSphereRadiusNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -27776,15 +30797,20 @@ impl InstEncoding for OpRayQueryGetIntersectionLSSPositionsNV { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionLSSPositionsNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionLSSPositionsNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -27825,15 +30851,20 @@ impl InstEncoding for OpRayQueryGetIntersectionLSSRadiiNV { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionLSSRadiiNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionLSSRadiiNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -27874,15 +30905,20 @@ impl InstEncoding for OpRayQueryGetIntersectionLSSHitValueNV { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionLSSHitValueNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionLSSHitValueNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -27919,14 +30955,19 @@ impl InstEncoding for OpHitObjectGetSpherePositionNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetSpherePositionNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetSpherePositionNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -27963,14 +31004,19 @@ impl InstEncoding for OpHitObjectGetSphereRadiusNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetSphereRadiusNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetSphereRadiusNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -28007,14 +31053,19 @@ impl InstEncoding for OpHitObjectGetLSSPositionsNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetLSSPositionsNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetLSSPositionsNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -28051,14 +31102,19 @@ impl InstEncoding for OpHitObjectGetLSSRadiiNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectGetLSSRadiiNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectGetLSSRadiiNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -28095,14 +31151,19 @@ impl InstEncoding for OpHitObjectIsSphereHitNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectIsSphereHitNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectIsSphereHitNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -28139,14 +31200,19 @@ impl InstEncoding for OpHitObjectIsLSSHitNV { hit_object: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpHitObjectIsLSSHitNV{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.hit_object.dis(_ctx) + "{}OpHitObjectIsLSSHitNV{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.hit_object.dis(ctx) ) } } @@ -28187,15 +31253,20 @@ impl InstEncoding for OpRayQueryIsSphereHitNV { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryIsSphereHitNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryIsSphereHitNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -28236,15 +31307,20 @@ impl InstEncoding for OpRayQueryIsLSSHitNV { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryIsLSSHitNV{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryIsLSSHitNV{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -28285,15 +31361,20 @@ impl InstEncoding for OpSubgroupShuffleINTEL { invocation_id: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupShuffleINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.data.dis(_ctx), - self.invocation_id.dis(_ctx) + "{}OpSubgroupShuffleINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.data.dis(ctx), + self.invocation_id.dis(ctx) ) } } @@ -28338,16 +31419,21 @@ impl InstEncoding for OpSubgroupShuffleDownINTEL { delta: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupShuffleDownINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.current.dis(_ctx), - self.next.dis(_ctx), - self.delta.dis(_ctx) + "{}OpSubgroupShuffleDownINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.current.dis(ctx), + self.next.dis(ctx), + self.delta.dis(ctx) ) } } @@ -28392,16 +31478,21 @@ impl InstEncoding for OpSubgroupShuffleUpINTEL { delta: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupShuffleUpINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.previous.dis(_ctx), - self.current.dis(_ctx), - self.delta.dis(_ctx) + "{}OpSubgroupShuffleUpINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.previous.dis(ctx), + self.current.dis(ctx), + self.delta.dis(ctx) ) } } @@ -28442,15 +31533,20 @@ impl InstEncoding for OpSubgroupShuffleXorINTEL { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupShuffleXorINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.data.dis(_ctx), - self.value.dis(_ctx) + "{}OpSubgroupShuffleXorINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.data.dis(ctx), + self.value.dis(ctx) ) } } @@ -28487,14 +31583,19 @@ impl InstEncoding for OpSubgroupBlockReadINTEL { ptr: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupBlockReadINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ptr.dis(_ctx) + "{}OpSubgroupBlockReadINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ptr.dis(ctx) ) } } @@ -28525,12 +31626,18 @@ impl InstEncoding for OpSubgroupBlockWriteINTEL { data: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSubgroupBlockWriteINTEL{}{}", - self.ptr.dis(_ctx), - self.data.dis(_ctx) + "{}OpSubgroupBlockWriteINTEL{}{}", + ctx.id_result_writer(), + self.ptr.dis(ctx), + self.data.dis(ctx) ) } } @@ -28571,15 +31678,20 @@ impl InstEncoding for OpSubgroupImageBlockReadINTEL { coordinate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupImageBlockReadINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx) + "{}OpSubgroupImageBlockReadINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx) ) } } @@ -28616,13 +31728,19 @@ impl InstEncoding for OpSubgroupImageBlockWriteINTEL { data: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSubgroupImageBlockWriteINTEL{}{}{}", - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.data.dis(_ctx) + "{}OpSubgroupImageBlockWriteINTEL{}{}{}", + ctx.id_result_writer(), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.data.dis(ctx) ) } } @@ -28671,17 +31789,22 @@ impl InstEncoding for OpSubgroupImageMediaBlockReadINTEL { height: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupImageMediaBlockReadINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.width.dis(_ctx), - self.height.dis(_ctx) + "{}OpSubgroupImageMediaBlockReadINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.width.dis(ctx), + self.height.dis(ctx) ) } } @@ -28726,15 +31849,21 @@ impl InstEncoding for OpSubgroupImageMediaBlockWriteINTEL { data: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSubgroupImageMediaBlockWriteINTEL{}{}{}{}{}", - self.image.dis(_ctx), - self.coordinate.dis(_ctx), - self.width.dis(_ctx), - self.height.dis(_ctx), - self.data.dis(_ctx) + "{}OpSubgroupImageMediaBlockWriteINTEL{}{}{}{}{}", + ctx.id_result_writer(), + self.image.dis(ctx), + self.coordinate.dis(ctx), + self.width.dis(ctx), + self.height.dis(ctx), + self.data.dis(ctx) ) } } @@ -28771,14 +31900,19 @@ impl InstEncoding for OpUCountLeadingZerosINTEL { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUCountLeadingZerosINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpUCountLeadingZerosINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -28815,14 +31949,19 @@ impl InstEncoding for OpUCountTrailingZerosINTEL { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUCountTrailingZerosINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpUCountTrailingZerosINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -28863,15 +32002,20 @@ impl InstEncoding for OpAbsISubINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAbsISubINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpAbsISubINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -28912,15 +32056,20 @@ impl InstEncoding for OpAbsUSubINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAbsUSubINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpAbsUSubINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -28961,15 +32110,20 @@ impl InstEncoding for OpIAddSatINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIAddSatINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpIAddSatINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29010,15 +32164,20 @@ impl InstEncoding for OpUAddSatINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUAddSatINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUAddSatINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29059,15 +32218,20 @@ impl InstEncoding for OpIAverageINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIAverageINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpIAverageINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29108,15 +32272,20 @@ impl InstEncoding for OpUAverageINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUAverageINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUAverageINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29157,15 +32326,20 @@ impl InstEncoding for OpIAverageRoundedINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIAverageRoundedINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpIAverageRoundedINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29206,15 +32380,20 @@ impl InstEncoding for OpUAverageRoundedINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUAverageRoundedINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUAverageRoundedINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29255,15 +32434,20 @@ impl InstEncoding for OpISubSatINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpISubSatINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpISubSatINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29304,15 +32488,20 @@ impl InstEncoding for OpUSubSatINTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUSubSatINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUSubSatINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29353,15 +32542,20 @@ impl InstEncoding for OpIMul32x16INTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpIMul32x16INTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpIMul32x16INTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29402,15 +32596,20 @@ impl InstEncoding for OpUMul32x16INTEL { operand_2: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUMul32x16INTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx), - self.operand_2.dis(_ctx) + "{}OpUMul32x16INTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx), + self.operand_2.dis(ctx) ) } } @@ -29447,14 +32646,19 @@ impl InstEncoding for OpConstantFunctionPointerINTEL { function: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConstantFunctionPointerINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.function.dis(_ctx) + "{}OpConstantFunctionPointerINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.function.dis(ctx) ) } } @@ -29491,14 +32695,19 @@ impl InstEncoding for OpFunctionPointerCallINTEL { operand_1: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFunctionPointerCallINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand_1.dis(_ctx) + "{}OpFunctionPointerCallINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand_1.dis(ctx) ) } } @@ -29531,12 +32740,17 @@ impl InstEncoding for OpAsmTargetINTEL { asm_target: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpAsmTargetINTEL{}", - self.id_result.dis(_ctx), - self.asm_target.dis(_ctx) + "{}OpAsmTargetINTEL{}", + ctx.id_result_writer(), + self.asm_target.dis(ctx) ) } } @@ -29585,17 +32799,22 @@ impl InstEncoding for OpAsmINTEL { constraints: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAsmINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.asm_type.dis(_ctx), - self.target.dis(_ctx), - self.asm_instructions.dis(_ctx), - self.constraints.dis(_ctx) + "{}OpAsmINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.asm_type.dis(ctx), + self.target.dis(ctx), + self.asm_instructions.dis(ctx), + self.constraints.dis(ctx) ) } } @@ -29636,15 +32855,20 @@ impl InstEncoding for OpAsmCallINTEL { argument: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAsmCallINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.asm.dis(_ctx), - self.argument.dis(_ctx) + "{}OpAsmCallINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.asm.dis(ctx), + self.argument.dis(ctx) ) } } @@ -29693,17 +32917,22 @@ impl InstEncoding for OpAtomicFMinEXT { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicFMinEXT{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicFMinEXT{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -29752,17 +32981,22 @@ impl InstEncoding for OpAtomicFMaxEXT { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicFMaxEXT{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicFMaxEXT{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -29790,8 +33024,18 @@ impl InstEncoding for OpAssumeTrueKHR { condition: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpAssumeTrueKHR{}", self.condition.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpAssumeTrueKHR{}", + ctx.id_result_writer(), + self.condition.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -29831,15 +33075,20 @@ impl InstEncoding for OpExpectKHR { expected_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpExpectKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.value.dis(_ctx), - self.expected_value.dis(_ctx) + "{}OpExpectKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.value.dis(ctx), + self.expected_value.dis(ctx) ) } } @@ -29872,12 +33121,18 @@ impl InstEncoding for OpDecorateString { decoration: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpDecorateString{}{}", - self.target.dis(_ctx), - self.decoration.dis(_ctx) + "{}OpDecorateString{}{}", + ctx.id_result_writer(), + self.target.dis(ctx), + self.decoration.dis(ctx) ) } } @@ -29914,13 +33169,19 @@ impl InstEncoding for OpMemberDecorateString { decoration: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpMemberDecorateString{}{}{}", - self.struct_type.dis(_ctx), - self.member.dis(_ctx), - self.decoration.dis(_ctx) + "{}OpMemberDecorateString{}{}{}", + ctx.id_result_writer(), + self.struct_type.dis(ctx), + self.member.dis(ctx), + self.decoration.dis(ctx) ) } } @@ -29961,15 +33222,20 @@ impl InstEncoding for OpVmeImageINTEL { sampler: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpVmeImageINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image_type.dis(_ctx), - self.sampler.dis(_ctx) + "{}OpVmeImageINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image_type.dis(ctx), + self.sampler.dis(ctx) ) } } @@ -30002,12 +33268,17 @@ impl InstEncoding for OpTypeVmeImageINTEL { image_type: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeVmeImageINTEL{}", - self.id_result.dis(_ctx), - self.image_type.dis(_ctx) + "{}OpTypeVmeImageINTEL{}", + ctx.id_result_writer(), + self.image_type.dis(ctx) ) } } @@ -30035,8 +33306,13 @@ impl InstEncoding for OpTypeAvcImePayloadINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeAvcImePayloadINTEL", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeAvcImePayloadINTEL", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -30063,8 +33339,13 @@ impl InstEncoding for OpTypeAvcRefPayloadINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeAvcRefPayloadINTEL", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeAvcRefPayloadINTEL", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -30091,8 +33372,13 @@ impl InstEncoding for OpTypeAvcSicPayloadINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeAvcSicPayloadINTEL", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeAvcSicPayloadINTEL", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -30119,8 +33405,13 @@ impl InstEncoding for OpTypeAvcMcePayloadINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeAvcMcePayloadINTEL", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeAvcMcePayloadINTEL", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -30147,8 +33438,13 @@ impl InstEncoding for OpTypeAvcMceResultINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeAvcMceResultINTEL", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeAvcMceResultINTEL", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -30175,8 +33471,13 @@ impl InstEncoding for OpTypeAvcImeResultINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeAvcImeResultINTEL", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeAvcImeResultINTEL", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -30203,11 +33504,16 @@ impl InstEncoding for OpTypeAvcImeResultSingleReferenceStreamoutINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeAvcImeResultSingleReferenceStreamoutINTEL", - self.id_result.dis(_ctx) + "{}OpTypeAvcImeResultSingleReferenceStreamoutINTEL", + ctx.id_result_writer() ) } } @@ -30235,11 +33541,16 @@ impl InstEncoding for OpTypeAvcImeResultDualReferenceStreamoutINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeAvcImeResultDualReferenceStreamoutINTEL", - self.id_result.dis(_ctx) + "{}OpTypeAvcImeResultDualReferenceStreamoutINTEL", + ctx.id_result_writer() ) } } @@ -30267,11 +33578,16 @@ impl InstEncoding for OpTypeAvcImeSingleReferenceStreaminINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeAvcImeSingleReferenceStreaminINTEL", - self.id_result.dis(_ctx) + "{}OpTypeAvcImeSingleReferenceStreaminINTEL", + ctx.id_result_writer() ) } } @@ -30299,11 +33615,16 @@ impl InstEncoding for OpTypeAvcImeDualReferenceStreaminINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeAvcImeDualReferenceStreaminINTEL", - self.id_result.dis(_ctx) + "{}OpTypeAvcImeDualReferenceStreaminINTEL", + ctx.id_result_writer() ) } } @@ -30331,8 +33652,13 @@ impl InstEncoding for OpTypeAvcRefResultINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeAvcRefResultINTEL", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeAvcRefResultINTEL", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -30359,8 +33685,13 @@ impl InstEncoding for OpTypeAvcSicResultINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeAvcSicResultINTEL", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeAvcSicResultINTEL", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -30401,15 +33732,20 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyIN qp: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.slice_type.dis(_ctx), - self.qp.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.slice_type.dis(ctx), + self.qp.dis(ctx) ) } } @@ -30450,15 +33786,20 @@ impl InstEncoding for OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.reference_base_penalty.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.reference_base_penalty.dis(ctx), + self.payload.dis(ctx) ) } } @@ -30499,15 +33840,20 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL { qp: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.slice_type.dis(_ctx), - self.qp.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.slice_type.dis(ctx), + self.qp.dis(ctx) ) } } @@ -30548,15 +33894,20 @@ impl InstEncoding for OpSubgroupAvcMceSetInterShapePenaltyINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceSetInterShapePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.packed_shape_penalty.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceSetInterShapePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.packed_shape_penalty.dis(ctx), + self.payload.dis(ctx) ) } } @@ -30597,15 +33948,20 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL { qp: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.slice_type.dis(_ctx), - self.qp.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.slice_type.dis(ctx), + self.qp.dis(ctx) ) } } @@ -30646,15 +34002,20 @@ impl InstEncoding for OpSubgroupAvcMceSetInterDirectionPenaltyINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceSetInterDirectionPenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.direction_cost.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceSetInterDirectionPenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.direction_cost.dis(ctx), + self.payload.dis(ctx) ) } } @@ -30695,15 +34056,20 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL { qp: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.slice_type.dis(_ctx), - self.qp.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.slice_type.dis(ctx), + self.qp.dis(ctx) ) } } @@ -30744,15 +34110,20 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL qp: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.slice_type.dis(_ctx), - self.qp.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.slice_type.dis(ctx), + self.qp.dis(ctx) ) } } @@ -30785,13 +34156,18 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -30824,13 +34200,18 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -30863,13 +34244,18 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -30918,17 +34304,22 @@ impl InstEncoding for OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.packed_cost_center_delta.dis(_ctx), - self.packed_cost_table.dis(_ctx), - self.cost_precision.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.packed_cost_center_delta.dis(ctx), + self.packed_cost_table.dis(ctx), + self.cost_precision.dis(ctx), + self.payload.dis(ctx) ) } } @@ -30969,15 +34360,20 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL { qp: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.slice_type.dis(_ctx), - self.qp.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.slice_type.dis(ctx), + self.qp.dis(ctx) ) } } @@ -31010,13 +34406,18 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -31049,13 +34450,18 @@ impl InstEncoding for OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -31092,14 +34498,19 @@ impl InstEncoding for OpSubgroupAvcMceSetAcOnlyHaarINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceSetAcOnlyHaarINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceSetAcOnlyHaarINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31140,15 +34551,20 @@ impl InstEncoding for OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.source_field_polarity.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.source_field_polarity.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31190,15 +34606,20 @@ impl InstEncoding for OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityI payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.reference_field_polarity.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.reference_field_polarity.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31244,16 +34665,21 @@ impl InstEncoding for OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesI payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.forward_reference_field_polarity.dis(_ctx), - self.backward_reference_field_polarity.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.forward_reference_field_polarity.dis(ctx), + self.backward_reference_field_polarity.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31290,14 +34716,19 @@ impl InstEncoding for OpSubgroupAvcMceConvertToImePayloadINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceConvertToImePayloadINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceConvertToImePayloadINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31334,14 +34765,19 @@ impl InstEncoding for OpSubgroupAvcMceConvertToImeResultINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceConvertToImeResultINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceConvertToImeResultINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31378,14 +34814,19 @@ impl InstEncoding for OpSubgroupAvcMceConvertToRefPayloadINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceConvertToRefPayloadINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceConvertToRefPayloadINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31422,14 +34863,19 @@ impl InstEncoding for OpSubgroupAvcMceConvertToRefResultINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceConvertToRefResultINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceConvertToRefResultINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31466,14 +34912,19 @@ impl InstEncoding for OpSubgroupAvcMceConvertToSicPayloadINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceConvertToSicPayloadINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceConvertToSicPayloadINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31510,14 +34961,19 @@ impl InstEncoding for OpSubgroupAvcMceConvertToSicResultINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceConvertToSicResultINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceConvertToSicResultINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31554,14 +35010,19 @@ impl InstEncoding for OpSubgroupAvcMceGetMotionVectorsINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetMotionVectorsINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceGetMotionVectorsINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31598,14 +35059,19 @@ impl InstEncoding for OpSubgroupAvcMceGetInterDistortionsINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetInterDistortionsINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceGetInterDistortionsINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31642,14 +35108,19 @@ impl InstEncoding for OpSubgroupAvcMceGetBestInterDistortionsINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetBestInterDistortionsINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceGetBestInterDistortionsINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31686,14 +35157,19 @@ impl InstEncoding for OpSubgroupAvcMceGetInterMajorShapeINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetInterMajorShapeINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceGetInterMajorShapeINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31730,14 +35206,19 @@ impl InstEncoding for OpSubgroupAvcMceGetInterMinorShapeINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetInterMinorShapeINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceGetInterMinorShapeINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31774,14 +35255,19 @@ impl InstEncoding for OpSubgroupAvcMceGetInterDirectionsINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetInterDirectionsINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceGetInterDirectionsINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31818,14 +35304,19 @@ impl InstEncoding for OpSubgroupAvcMceGetInterMotionVectorCountINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetInterMotionVectorCountINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceGetInterMotionVectorCountINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31862,14 +35353,19 @@ impl InstEncoding for OpSubgroupAvcMceGetInterReferenceIdsINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetInterReferenceIdsINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceGetInterReferenceIdsINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31918,16 +35414,21 @@ impl InstEncoding for OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolarities payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.packed_reference_ids.dis(_ctx), - self.packed_reference_parameter_field_polarities.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.packed_reference_ids.dis(ctx), + self.packed_reference_parameter_field_polarities.dis(ctx), + self.payload.dis(ctx) ) } } @@ -31972,16 +35473,21 @@ impl InstEncoding for OpSubgroupAvcImeInitializeINTEL { sad_adjustment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeInitializeINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_coord.dis(_ctx), - self.partition_mask.dis(_ctx), - self.sad_adjustment.dis(_ctx) + "{}OpSubgroupAvcImeInitializeINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_coord.dis(ctx), + self.partition_mask.dis(ctx), + self.sad_adjustment.dis(ctx) ) } } @@ -32026,16 +35532,21 @@ impl InstEncoding for OpSubgroupAvcImeSetSingleReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeSetSingleReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ref_offset.dis(_ctx), - self.search_window_config.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeSetSingleReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ref_offset.dis(ctx), + self.search_window_config.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32084,17 +35595,22 @@ impl InstEncoding for OpSubgroupAvcImeSetDualReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeSetDualReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.fwd_ref_offset.dis(_ctx), - self.bwd_ref_offset.dis(_ctx), - self.search_window_config.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeSetDualReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.fwd_ref_offset.dis(ctx), + self.bwd_ref_offset.dis(ctx), + self.search_window_config.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32135,15 +35651,20 @@ impl InstEncoding for OpSubgroupAvcImeRefWindowSizeINTEL { dual_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeRefWindowSizeINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.search_window_config.dis(_ctx), - self.dual_ref.dis(_ctx) + "{}OpSubgroupAvcImeRefWindowSizeINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.search_window_config.dis(ctx), + self.dual_ref.dis(ctx) ) } } @@ -32192,17 +35713,22 @@ impl InstEncoding for OpSubgroupAvcImeAdjustRefOffsetINTEL { image_size: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeAdjustRefOffsetINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ref_offset.dis(_ctx), - self.src_coord.dis(_ctx), - self.ref_window_size.dis(_ctx), - self.image_size.dis(_ctx) + "{}OpSubgroupAvcImeAdjustRefOffsetINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ref_offset.dis(ctx), + self.src_coord.dis(ctx), + self.ref_window_size.dis(ctx), + self.image_size.dis(ctx) ) } } @@ -32239,14 +35765,19 @@ impl InstEncoding for OpSubgroupAvcImeConvertToMcePayloadINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeConvertToMcePayloadINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeConvertToMcePayloadINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32287,15 +35818,20 @@ impl InstEncoding for OpSubgroupAvcImeSetMaxMotionVectorCountINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeSetMaxMotionVectorCountINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.max_motion_vector_count.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeSetMaxMotionVectorCountINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.max_motion_vector_count.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32332,14 +35868,19 @@ impl InstEncoding for OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32380,15 +35921,20 @@ impl InstEncoding for OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.threshold.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.threshold.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32429,15 +35975,20 @@ impl InstEncoding for OpSubgroupAvcImeSetWeightedSadINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeSetWeightedSadINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.packed_sad_weights.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeSetWeightedSadINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.packed_sad_weights.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32482,16 +36033,21 @@ impl InstEncoding for OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.ref_image.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.ref_image.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32540,17 +36096,22 @@ impl InstEncoding for OpSubgroupAvcImeEvaluateWithDualReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeEvaluateWithDualReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.fwd_ref_image.dis(_ctx), - self.bwd_ref_image.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeEvaluateWithDualReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.fwd_ref_image.dis(ctx), + self.bwd_ref_image.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32599,17 +36160,22 @@ impl InstEncoding for OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL { streamin_components: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.ref_image.dis(_ctx), - self.payload.dis(_ctx), - self.streamin_components.dis(_ctx) + "{}OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.ref_image.dis(ctx), + self.payload.dis(ctx), + self.streamin_components.dis(ctx) ) } } @@ -32662,18 +36228,23 @@ impl InstEncoding for OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL { streamin_components: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.fwd_ref_image.dis(_ctx), - self.bwd_ref_image.dis(_ctx), - self.payload.dis(_ctx), - self.streamin_components.dis(_ctx) + "{}OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.fwd_ref_image.dis(ctx), + self.bwd_ref_image.dis(ctx), + self.payload.dis(ctx), + self.streamin_components.dis(ctx) ) } } @@ -32718,16 +36289,21 @@ impl InstEncoding for OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.ref_image.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.ref_image.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32776,17 +36352,22 @@ impl InstEncoding for OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.fwd_ref_image.dis(_ctx), - self.bwd_ref_image.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.fwd_ref_image.dis(ctx), + self.bwd_ref_image.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32835,17 +36416,22 @@ impl InstEncoding for OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTE streamin_components: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.ref_image.dis(_ctx), - self.payload.dis(_ctx), - self.streamin_components.dis(_ctx) + "{}OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.ref_image.dis(ctx), + self.payload.dis(ctx), + self.streamin_components.dis(ctx) ) } } @@ -32898,18 +36484,23 @@ impl InstEncoding for OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL streamin_components: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.fwd_ref_image.dis(_ctx), - self.bwd_ref_image.dis(_ctx), - self.payload.dis(_ctx), - self.streamin_components.dis(_ctx) + "{}OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.fwd_ref_image.dis(ctx), + self.bwd_ref_image.dis(ctx), + self.payload.dis(ctx), + self.streamin_components.dis(ctx) ) } } @@ -32946,14 +36537,19 @@ impl InstEncoding for OpSubgroupAvcImeConvertToMceResultINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeConvertToMceResultINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeConvertToMceResultINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -32990,14 +36586,19 @@ impl InstEncoding for OpSubgroupAvcImeGetSingleReferenceStreaminINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetSingleReferenceStreaminINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeGetSingleReferenceStreaminINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33034,14 +36635,19 @@ impl InstEncoding for OpSubgroupAvcImeGetDualReferenceStreaminINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetDualReferenceStreaminINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeGetDualReferenceStreaminINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33078,14 +36684,19 @@ impl InstEncoding for OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33122,14 +36733,19 @@ impl InstEncoding for OpSubgroupAvcImeStripDualReferenceStreamoutINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeStripDualReferenceStreamoutINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeStripDualReferenceStreamoutINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33171,15 +36787,20 @@ impl InstEncoding for OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotio major_shape: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx), - self.major_shape.dis(_ctx) + "{}OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx), + self.major_shape.dis(ctx) ) } } @@ -33221,15 +36842,20 @@ impl InstEncoding for OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDisto major_shape: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx), - self.major_shape.dis(_ctx) + "{}OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx), + self.major_shape.dis(ctx) ) } } @@ -33271,15 +36897,20 @@ impl InstEncoding for OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeRefer major_shape: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx), - self.major_shape.dis(_ctx) + "{}OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx), + self.major_shape.dis(ctx) ) } } @@ -33325,16 +36956,21 @@ impl InstEncoding for OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionV direction: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx), - self.major_shape.dis(_ctx), - self.direction.dis(_ctx) + "{}OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx), + self.major_shape.dis(ctx), + self.direction.dis(ctx) ) } } @@ -33380,16 +37016,21 @@ impl InstEncoding for OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistort direction: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx), - self.major_shape.dis(_ctx), - self.direction.dis(_ctx) + "{}OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx), + self.major_shape.dis(ctx), + self.direction.dis(ctx) ) } } @@ -33435,16 +37076,21 @@ impl InstEncoding for OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferen direction: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx), - self.major_shape.dis(_ctx), - self.direction.dis(_ctx) + "{}OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx), + self.major_shape.dis(ctx), + self.direction.dis(ctx) ) } } @@ -33485,15 +37131,20 @@ impl InstEncoding for OpSubgroupAvcImeGetBorderReachedINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetBorderReachedINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.image_select.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeGetBorderReachedINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.image_select.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33530,14 +37181,19 @@ impl InstEncoding for OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33574,14 +37230,19 @@ impl InstEncoding for OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINT payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33618,14 +37279,19 @@ impl InstEncoding for OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTE payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33662,14 +37328,19 @@ impl InstEncoding for OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33730,20 +37401,25 @@ impl InstEncoding for OpSubgroupAvcFmeInitializeINTEL { sad_adjustment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcFmeInitializeINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_coord.dis(_ctx), - self.motion_vectors.dis(_ctx), - self.major_shapes.dis(_ctx), - self.minor_shapes.dis(_ctx), - self.direction.dis(_ctx), - self.pixel_resolution.dis(_ctx), - self.sad_adjustment.dis(_ctx) + "{}OpSubgroupAvcFmeInitializeINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_coord.dis(ctx), + self.motion_vectors.dis(ctx), + self.major_shapes.dis(ctx), + self.minor_shapes.dis(ctx), + self.direction.dis(ctx), + self.pixel_resolution.dis(ctx), + self.sad_adjustment.dis(ctx) ) } } @@ -33808,21 +37484,26 @@ impl InstEncoding for OpSubgroupAvcBmeInitializeINTEL { sad_adjustment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcBmeInitializeINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_coord.dis(_ctx), - self.motion_vectors.dis(_ctx), - self.major_shapes.dis(_ctx), - self.minor_shapes.dis(_ctx), - self.direction.dis(_ctx), - self.pixel_resolution.dis(_ctx), - self.bidirectional_weight.dis(_ctx), - self.sad_adjustment.dis(_ctx) + "{}OpSubgroupAvcBmeInitializeINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_coord.dis(ctx), + self.motion_vectors.dis(ctx), + self.major_shapes.dis(ctx), + self.minor_shapes.dis(ctx), + self.direction.dis(ctx), + self.pixel_resolution.dis(ctx), + self.bidirectional_weight.dis(ctx), + self.sad_adjustment.dis(ctx) ) } } @@ -33859,14 +37540,19 @@ impl InstEncoding for OpSubgroupAvcRefConvertToMcePayloadINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcRefConvertToMcePayloadINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcRefConvertToMcePayloadINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33903,14 +37589,19 @@ impl InstEncoding for OpSubgroupAvcRefSetBidirectionalMixDisableINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcRefSetBidirectionalMixDisableINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcRefSetBidirectionalMixDisableINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33947,14 +37638,19 @@ impl InstEncoding for OpSubgroupAvcRefSetBilinearFilterEnableINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcRefSetBilinearFilterEnableINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcRefSetBilinearFilterEnableINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -33999,16 +37695,21 @@ impl InstEncoding for OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.ref_image.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.ref_image.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34057,17 +37758,22 @@ impl InstEncoding for OpSubgroupAvcRefEvaluateWithDualReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcRefEvaluateWithDualReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.fwd_ref_image.dis(_ctx), - self.bwd_ref_image.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcRefEvaluateWithDualReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.fwd_ref_image.dis(ctx), + self.bwd_ref_image.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34112,16 +37818,21 @@ impl InstEncoding for OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.packed_reference_ids.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.packed_reference_ids.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34170,17 +37881,22 @@ impl InstEncoding for OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.packed_reference_ids.dis(_ctx), - self.packed_reference_field_polarities.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.packed_reference_ids.dis(ctx), + self.packed_reference_field_polarities.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34217,14 +37933,19 @@ impl InstEncoding for OpSubgroupAvcRefConvertToMceResultINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcRefConvertToMceResultINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcRefConvertToMceResultINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34261,14 +37982,19 @@ impl InstEncoding for OpSubgroupAvcSicInitializeINTEL { src_coord: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicInitializeINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_coord.dis(_ctx) + "{}OpSubgroupAvcSicInitializeINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_coord.dis(ctx) ) } } @@ -34325,19 +38051,24 @@ impl InstEncoding for OpSubgroupAvcSicConfigureSkcINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicConfigureSkcINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.skip_block_partition_type.dis(_ctx), - self.skip_motion_vector_mask.dis(_ctx), - self.motion_vectors.dis(_ctx), - self.bidirectional_weight.dis(_ctx), - self.sad_adjustment.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicConfigureSkcINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.skip_block_partition_type.dis(ctx), + self.skip_motion_vector_mask.dis(ctx), + self.motion_vectors.dis(ctx), + self.bidirectional_weight.dis(ctx), + self.sad_adjustment.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34402,21 +38133,26 @@ impl InstEncoding for OpSubgroupAvcSicConfigureIpeLumaINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicConfigureIpeLumaINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.luma_intra_partition_mask.dis(_ctx), - self.intra_neighbour_availabilty.dis(_ctx), - self.left_edge_luma_pixels.dis(_ctx), - self.upper_left_corner_luma_pixel.dis(_ctx), - self.upper_edge_luma_pixels.dis(_ctx), - self.upper_right_edge_luma_pixels.dis(_ctx), - self.sad_adjustment.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicConfigureIpeLumaINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.luma_intra_partition_mask.dis(ctx), + self.intra_neighbour_availabilty.dis(ctx), + self.left_edge_luma_pixels.dis(ctx), + self.upper_left_corner_luma_pixel.dis(ctx), + self.upper_edge_luma_pixels.dis(ctx), + self.upper_right_edge_luma_pixels.dis(ctx), + self.sad_adjustment.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34493,24 +38229,29 @@ impl InstEncoding for OpSubgroupAvcSicConfigureIpeLumaChromaINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicConfigureIpeLumaChromaINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.luma_intra_partition_mask.dis(_ctx), - self.intra_neighbour_availabilty.dis(_ctx), - self.left_edge_luma_pixels.dis(_ctx), - self.upper_left_corner_luma_pixel.dis(_ctx), - self.upper_edge_luma_pixels.dis(_ctx), - self.upper_right_edge_luma_pixels.dis(_ctx), - self.left_edge_chroma_pixels.dis(_ctx), - self.upper_left_corner_chroma_pixel.dis(_ctx), - self.upper_edge_chroma_pixels.dis(_ctx), - self.sad_adjustment.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicConfigureIpeLumaChromaINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.luma_intra_partition_mask.dis(ctx), + self.intra_neighbour_availabilty.dis(ctx), + self.left_edge_luma_pixels.dis(ctx), + self.upper_left_corner_luma_pixel.dis(ctx), + self.upper_edge_luma_pixels.dis(ctx), + self.upper_right_edge_luma_pixels.dis(ctx), + self.left_edge_chroma_pixels.dis(ctx), + self.upper_left_corner_chroma_pixel.dis(ctx), + self.upper_edge_chroma_pixels.dis(ctx), + self.sad_adjustment.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34551,15 +38292,20 @@ impl InstEncoding for OpSubgroupAvcSicGetMotionVectorMaskINTEL { direction: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicGetMotionVectorMaskINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.skip_block_partition_type.dis(_ctx), - self.direction.dis(_ctx) + "{}OpSubgroupAvcSicGetMotionVectorMaskINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.skip_block_partition_type.dis(ctx), + self.direction.dis(ctx) ) } } @@ -34596,14 +38342,19 @@ impl InstEncoding for OpSubgroupAvcSicConvertToMcePayloadINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicConvertToMcePayloadINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicConvertToMcePayloadINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34644,15 +38395,20 @@ impl InstEncoding for OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.packed_shape_penalty.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.packed_shape_penalty.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34701,17 +38457,22 @@ impl InstEncoding for OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.luma_mode_penalty.dis(_ctx), - self.luma_packed_neighbor_modes.dis(_ctx), - self.luma_packed_non_dc_penalty.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.luma_mode_penalty.dis(ctx), + self.luma_packed_neighbor_modes.dis(ctx), + self.luma_packed_non_dc_penalty.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34752,15 +38513,20 @@ impl InstEncoding for OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.chroma_mode_base_penalty.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.chroma_mode_base_penalty.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34797,14 +38563,19 @@ impl InstEncoding for OpSubgroupAvcSicSetBilinearFilterEnableINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicSetBilinearFilterEnableINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicSetBilinearFilterEnableINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34845,15 +38616,20 @@ impl InstEncoding for OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.packed_sad_coefficients.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.packed_sad_coefficients.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34894,15 +38670,20 @@ impl InstEncoding for OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.block_based_skip_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.block_based_skip_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34943,15 +38724,20 @@ impl InstEncoding for OpSubgroupAvcSicEvaluateIpeINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicEvaluateIpeINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicEvaluateIpeINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.payload.dis(ctx) ) } } @@ -34996,16 +38782,21 @@ impl InstEncoding for OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.ref_image.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.ref_image.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35054,17 +38845,22 @@ impl InstEncoding for OpSubgroupAvcSicEvaluateWithDualReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicEvaluateWithDualReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.fwd_ref_image.dis(_ctx), - self.bwd_ref_image.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicEvaluateWithDualReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.fwd_ref_image.dis(ctx), + self.bwd_ref_image.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35109,16 +38905,21 @@ impl InstEncoding for OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.packed_reference_ids.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.packed_reference_ids.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35167,17 +38968,22 @@ impl InstEncoding for OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.src_image.dis(_ctx), - self.packed_reference_ids.dis(_ctx), - self.packed_reference_field_polarities.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.src_image.dis(ctx), + self.packed_reference_ids.dis(ctx), + self.packed_reference_field_polarities.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35214,14 +39020,19 @@ impl InstEncoding for OpSubgroupAvcSicConvertToMceResultINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicConvertToMceResultINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicConvertToMceResultINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35258,14 +39069,19 @@ impl InstEncoding for OpSubgroupAvcSicGetIpeLumaShapeINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicGetIpeLumaShapeINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicGetIpeLumaShapeINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35302,14 +39118,19 @@ impl InstEncoding for OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35346,14 +39167,19 @@ impl InstEncoding for OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35390,14 +39216,19 @@ impl InstEncoding for OpSubgroupAvcSicGetPackedIpeLumaModesINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicGetPackedIpeLumaModesINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicGetPackedIpeLumaModesINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35434,14 +39265,19 @@ impl InstEncoding for OpSubgroupAvcSicGetIpeChromaModeINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicGetIpeChromaModeINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicGetIpeChromaModeINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35478,14 +39314,19 @@ impl InstEncoding for OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35522,14 +39363,19 @@ impl InstEncoding for OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35566,14 +39412,19 @@ impl InstEncoding for OpSubgroupAvcSicGetInterRawSadsINTEL { payload: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupAvcSicGetInterRawSadsINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.payload.dis(_ctx) + "{}OpSubgroupAvcSicGetInterRawSadsINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.payload.dis(ctx) ) } } @@ -35610,14 +39461,19 @@ impl InstEncoding for OpVariableLengthArrayINTEL { length: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpVariableLengthArrayINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.length.dis(_ctx) + "{}OpVariableLengthArrayINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.length.dis(ctx) ) } } @@ -35650,13 +39506,18 @@ impl InstEncoding for OpSaveMemoryINTEL { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSaveMemoryINTEL{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx) + "{}OpSaveMemoryINTEL{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx) ) } } @@ -35684,8 +39545,18 @@ impl InstEncoding for OpRestoreMemoryINTEL { ptr: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpRestoreMemoryINTEL{}", self.ptr.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpRestoreMemoryINTEL{}", + ctx.id_result_writer(), + self.ptr.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -35741,19 +39612,24 @@ impl InstEncoding for OpArbitraryFloatSinCosPiALTERA { rounding_accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatSinCosPiALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.m_result.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.rounding_accuracy.dis(_ctx) + "{}OpArbitraryFloatSinCosPiALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.m_result.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.rounding_accuracy.dis(ctx) ) } } @@ -35810,19 +39686,24 @@ impl InstEncoding for OpArbitraryFloatCastALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatCastALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatCastALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -35879,19 +39760,24 @@ impl InstEncoding for OpArbitraryFloatCastFromIntALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatCastFromIntALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.mresult.dis(_ctx), - self.from_sign.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatCastFromIntALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.mresult.dis(ctx), + self.from_sign.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -35948,19 +39834,24 @@ impl InstEncoding for OpArbitraryFloatCastToIntALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatCastToIntALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.to_sign.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatCastToIntALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.to_sign.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36025,21 +39916,26 @@ impl InstEncoding for OpArbitraryFloatAddALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatAddALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx), - self.m_result.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatAddALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx), + self.m_result.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36104,21 +40000,26 @@ impl InstEncoding for OpArbitraryFloatSubALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatSubALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatSubALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36183,21 +40084,26 @@ impl InstEncoding for OpArbitraryFloatMulALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatMulALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatMulALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36262,21 +40168,26 @@ impl InstEncoding for OpArbitraryFloatDivALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatDivALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatDivALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36325,17 +40236,22 @@ impl InstEncoding for OpArbitraryFloatGTALTERA { mb: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatGTALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx) + "{}OpArbitraryFloatGTALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx) ) } } @@ -36384,17 +40300,22 @@ impl InstEncoding for OpArbitraryFloatGEALTERA { mb: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatGEALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx) + "{}OpArbitraryFloatGEALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx) ) } } @@ -36443,17 +40364,22 @@ impl InstEncoding for OpArbitraryFloatLTALTERA { mb: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatLTALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx) + "{}OpArbitraryFloatLTALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx) ) } } @@ -36502,17 +40428,22 @@ impl InstEncoding for OpArbitraryFloatLEALTERA { mb: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatLEALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx) + "{}OpArbitraryFloatLEALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx) ) } } @@ -36561,17 +40492,22 @@ impl InstEncoding for OpArbitraryFloatEQALTERA { mb: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatEQALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx) + "{}OpArbitraryFloatEQALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx) ) } } @@ -36628,19 +40564,24 @@ impl InstEncoding for OpArbitraryFloatRecipALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatRecipALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatRecipALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36697,19 +40638,24 @@ impl InstEncoding for OpArbitraryFloatRSqrtALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatRSqrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatRSqrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36766,19 +40712,24 @@ impl InstEncoding for OpArbitraryFloatCbrtALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatCbrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatCbrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36843,21 +40794,26 @@ impl InstEncoding for OpArbitraryFloatHypotALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatHypotALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatHypotALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36914,19 +40870,24 @@ impl InstEncoding for OpArbitraryFloatSqrtALTERA { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatSqrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatSqrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -36983,19 +40944,24 @@ impl InstEncoding for OpArbitraryFloatLogINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatLogINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatLogINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37052,19 +41018,24 @@ impl InstEncoding for OpArbitraryFloatLog2INTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatLog2INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatLog2INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37121,19 +41092,24 @@ impl InstEncoding for OpArbitraryFloatLog10INTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatLog10INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatLog10INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37190,19 +41166,24 @@ impl InstEncoding for OpArbitraryFloatLog1pINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatLog1pINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatLog1pINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37259,19 +41240,24 @@ impl InstEncoding for OpArbitraryFloatExpINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatExpINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatExpINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37328,19 +41314,24 @@ impl InstEncoding for OpArbitraryFloatExp2INTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatExp2INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatExp2INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37397,19 +41388,24 @@ impl InstEncoding for OpArbitraryFloatExp10INTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatExp10INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatExp10INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37466,19 +41462,24 @@ impl InstEncoding for OpArbitraryFloatExpm1INTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatExpm1INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatExpm1INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37535,19 +41536,24 @@ impl InstEncoding for OpArbitraryFloatSinINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatSinINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatSinINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37604,19 +41610,24 @@ impl InstEncoding for OpArbitraryFloatCosINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatCosINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatCosINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37673,19 +41684,24 @@ impl InstEncoding for OpArbitraryFloatSinCosINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatSinCosINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatSinCosINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37742,19 +41758,24 @@ impl InstEncoding for OpArbitraryFloatSinPiINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatSinPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatSinPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37811,19 +41832,24 @@ impl InstEncoding for OpArbitraryFloatCosPiINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatCosPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatCosPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37880,19 +41906,24 @@ impl InstEncoding for OpArbitraryFloatASinINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatASinINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatASinINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -37949,19 +41980,24 @@ impl InstEncoding for OpArbitraryFloatASinPiINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatASinPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatASinPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -38018,19 +42054,24 @@ impl InstEncoding for OpArbitraryFloatACosINTEL { rounding_accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatACosINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.m_1.dis(_ctx), - self.mout.dis(_ctx), - self.enable_subnormals.dis(_ctx), - self.rounding_mode.dis(_ctx), - self.rounding_accuracy.dis(_ctx) + "{}OpArbitraryFloatACosINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.m_1.dis(ctx), + self.mout.dis(ctx), + self.enable_subnormals.dis(ctx), + self.rounding_mode.dis(ctx), + self.rounding_accuracy.dis(ctx) ) } } @@ -38087,19 +42128,24 @@ impl InstEncoding for OpArbitraryFloatACosPiINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatACosPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatACosPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -38156,19 +42202,24 @@ impl InstEncoding for OpArbitraryFloatATanINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatATanINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatATanINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -38225,19 +42276,24 @@ impl InstEncoding for OpArbitraryFloatATanPiINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatATanPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatATanPiINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -38302,21 +42358,26 @@ impl InstEncoding for OpArbitraryFloatATan2INTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatATan2INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatATan2INTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -38381,21 +42442,26 @@ impl InstEncoding for OpArbitraryFloatPowINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatPowINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatPowINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -38460,21 +42526,26 @@ impl InstEncoding for OpArbitraryFloatPowRINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatPowRINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.mb.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatPowRINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.mb.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -38539,21 +42610,26 @@ impl InstEncoding for OpArbitraryFloatPowNINTEL { accuracy: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArbitraryFloatPowNINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.ma.dis(_ctx), - self.b.dis(_ctx), - self.sign_of_b.dis(_ctx), - self.mresult.dis(_ctx), - self.subnormal.dis(_ctx), - self.rounding.dis(_ctx), - self.accuracy.dis(_ctx) + "{}OpArbitraryFloatPowNINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.ma.dis(ctx), + self.b.dis(ctx), + self.sign_of_b.dis(ctx), + self.mresult.dis(ctx), + self.subnormal.dis(ctx), + self.rounding.dis(ctx), + self.accuracy.dis(ctx) ) } } @@ -38581,11 +42657,17 @@ impl InstEncoding for OpLoopControlINTEL { loop_control_parameters: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpLoopControlINTEL{}", - self.loop_control_parameters.dis(_ctx) + "{}OpLoopControlINTEL{}", + ctx.id_result_writer(), + self.loop_control_parameters.dis(ctx) ) } } @@ -38617,12 +42699,17 @@ impl InstEncoding for OpAliasDomainDeclINTEL { name: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpAliasDomainDeclINTEL{}", - self.id_result.dis(_ctx), - self.name.dis(_ctx) + "{}OpAliasDomainDeclINTEL{}", + ctx.id_result_writer(), + self.name.dis(ctx) ) } } @@ -38659,13 +42746,18 @@ impl InstEncoding for OpAliasScopeDeclINTEL { name: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpAliasScopeDeclINTEL{}{}", - self.id_result.dis(_ctx), - self.alias_domain.dis(_ctx), - self.name.dis(_ctx) + "{}OpAliasScopeDeclINTEL{}{}", + ctx.id_result_writer(), + self.alias_domain.dis(ctx), + self.name.dis(ctx) ) } } @@ -38698,12 +42790,17 @@ impl InstEncoding for OpAliasScopeListDeclINTEL { id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpAliasScopeListDeclINTEL{}", - self.id_result.dis(_ctx), - self.id_ref.dis(_ctx) + "{}OpAliasScopeListDeclINTEL{}", + ctx.id_result_writer(), + self.id_ref.dis(ctx) ) } } @@ -38760,19 +42857,24 @@ impl InstEncoding for OpFixedSqrtALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedSqrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedSqrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -38829,19 +42931,24 @@ impl InstEncoding for OpFixedRecipALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedRecipALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedRecipALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -38898,19 +43005,24 @@ impl InstEncoding for OpFixedRsqrtALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedRsqrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedRsqrtALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -38967,19 +43079,24 @@ impl InstEncoding for OpFixedSinALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedSinALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedSinALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -39036,19 +43153,24 @@ impl InstEncoding for OpFixedCosALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedCosALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedCosALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -39105,19 +43227,24 @@ impl InstEncoding for OpFixedSinCosALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedSinCosALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedSinCosALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -39174,19 +43301,24 @@ impl InstEncoding for OpFixedSinPiALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedSinPiALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedSinPiALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -39243,19 +43375,24 @@ impl InstEncoding for OpFixedCosPiALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedCosPiALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedCosPiALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -39312,19 +43449,24 @@ impl InstEncoding for OpFixedSinCosPiALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedSinCosPiALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedSinCosPiALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -39381,19 +43523,24 @@ impl InstEncoding for OpFixedLogALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedLogALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedLogALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -39450,19 +43597,24 @@ impl InstEncoding for OpFixedExpALTERA { o: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFixedExpALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx), - self.s.dis(_ctx), - self.i.dis(_ctx), - self.r_i.dis(_ctx), - self.q.dis(_ctx), - self.o.dis(_ctx) + "{}OpFixedExpALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx), + self.s.dis(ctx), + self.i.dis(ctx), + self.r_i.dis(ctx), + self.q.dis(ctx), + self.o.dis(ctx) ) } } @@ -39499,14 +43651,19 @@ impl InstEncoding for OpPtrCastToCrossWorkgroupALTERA { pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpPtrCastToCrossWorkgroupALTERA{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx) + "{}OpPtrCastToCrossWorkgroupALTERA{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx) ) } } @@ -39543,14 +43700,19 @@ impl InstEncoding for OpCrossWorkgroupCastToPtrALTERA { pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCrossWorkgroupCastToPtrALTERA{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx) + "{}OpCrossWorkgroupCastToPtrALTERA{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx) ) } } @@ -39591,15 +43753,20 @@ impl InstEncoding for OpReadPipeBlockingALTERA { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpReadPipeBlockingALTERA{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpReadPipeBlockingALTERA{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -39640,15 +43807,20 @@ impl InstEncoding for OpWritePipeBlockingALTERA { packet_alignment: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpWritePipeBlockingALTERA{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.packet_size.dis(_ctx), - self.packet_alignment.dis(_ctx) + "{}OpWritePipeBlockingALTERA{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.packet_size.dis(ctx), + self.packet_alignment.dis(ctx) ) } } @@ -39685,14 +43857,19 @@ impl InstEncoding for OpFPGARegALTERA { input: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpFPGARegALTERA{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.input.dis(_ctx) + "{}OpFPGARegALTERA{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.input.dis(ctx) ) } } @@ -39729,14 +43906,19 @@ impl InstEncoding for OpRayQueryGetRayTMinKHR { ray_query: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetRayTMinKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx) + "{}OpRayQueryGetRayTMinKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx) ) } } @@ -39773,14 +43955,19 @@ impl InstEncoding for OpRayQueryGetRayFlagsKHR { ray_query: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetRayFlagsKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx) + "{}OpRayQueryGetRayFlagsKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx) ) } } @@ -39821,15 +44008,20 @@ impl InstEncoding for OpRayQueryGetIntersectionTKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionTKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionTKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -39870,15 +44062,20 @@ impl InstEncoding for OpRayQueryGetIntersectionInstanceCustomIndexKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionInstanceCustomIndexKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionInstanceCustomIndexKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -39919,15 +44116,20 @@ impl InstEncoding for OpRayQueryGetIntersectionInstanceIdKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionInstanceIdKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionInstanceIdKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -39969,15 +44171,20 @@ impl InstEncoding for OpRayQueryGetIntersectionInstanceShaderBindingTableRecordO intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -40018,15 +44225,20 @@ impl InstEncoding for OpRayQueryGetIntersectionGeometryIndexKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionGeometryIndexKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionGeometryIndexKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -40067,15 +44279,20 @@ impl InstEncoding for OpRayQueryGetIntersectionPrimitiveIndexKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionPrimitiveIndexKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionPrimitiveIndexKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -40116,15 +44333,20 @@ impl InstEncoding for OpRayQueryGetIntersectionBarycentricsKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionBarycentricsKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionBarycentricsKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -40165,15 +44387,20 @@ impl InstEncoding for OpRayQueryGetIntersectionFrontFaceKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionFrontFaceKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionFrontFaceKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -40210,14 +44437,19 @@ impl InstEncoding for OpRayQueryGetIntersectionCandidateAABBOpaqueKHR { ray_query: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionCandidateAABBOpaqueKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx) + "{}OpRayQueryGetIntersectionCandidateAABBOpaqueKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx) ) } } @@ -40258,15 +44490,20 @@ impl InstEncoding for OpRayQueryGetIntersectionObjectRayDirectionKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionObjectRayDirectionKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionObjectRayDirectionKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -40307,15 +44544,20 @@ impl InstEncoding for OpRayQueryGetIntersectionObjectRayOriginKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionObjectRayOriginKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionObjectRayOriginKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -40352,14 +44594,19 @@ impl InstEncoding for OpRayQueryGetWorldRayDirectionKHR { ray_query: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetWorldRayDirectionKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx) + "{}OpRayQueryGetWorldRayDirectionKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx) ) } } @@ -40396,14 +44643,19 @@ impl InstEncoding for OpRayQueryGetWorldRayOriginKHR { ray_query: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetWorldRayOriginKHR{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx) + "{}OpRayQueryGetWorldRayOriginKHR{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx) ) } } @@ -40444,15 +44696,20 @@ impl InstEncoding for OpRayQueryGetIntersectionObjectToWorldKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionObjectToWorldKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionObjectToWorldKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -40493,15 +44750,20 @@ impl InstEncoding for OpRayQueryGetIntersectionWorldToObjectKHR { intersection: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRayQueryGetIntersectionWorldToObjectKHR{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ray_query.dis(_ctx), - self.intersection.dis(_ctx) + "{}OpRayQueryGetIntersectionWorldToObjectKHR{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ray_query.dis(ctx), + self.intersection.dis(ctx) ) } } @@ -40550,17 +44812,22 @@ impl InstEncoding for OpAtomicFAddEXT { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpAtomicFAddEXT{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.pointer.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx), - self.value.dis(_ctx) + "{}OpAtomicFAddEXT{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.pointer.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx), + self.value.dis(ctx) ) } } @@ -40593,12 +44860,17 @@ impl InstEncoding for OpTypeBufferSurfaceINTEL { access_qualifier: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; write!( f, - "{} = OpTypeBufferSurfaceINTEL{}", - self.id_result.dis(_ctx), - self.access_qualifier.dis(_ctx) + "{}OpTypeBufferSurfaceINTEL{}", + ctx.id_result_writer(), + self.access_qualifier.dis(ctx) ) } } @@ -40626,8 +44898,18 @@ impl InstEncoding for OpTypeStructContinuedINTEL { id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpTypeStructContinuedINTEL{}", self.id_ref.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpTypeStructContinuedINTEL{}", + ctx.id_result_writer(), + self.id_ref.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -40654,11 +44936,17 @@ impl InstEncoding for OpConstantCompositeContinuedINTEL { constituents: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpConstantCompositeContinuedINTEL{}", - self.constituents.dis(_ctx) + "{}OpConstantCompositeContinuedINTEL{}", + ctx.id_result_writer(), + self.constituents.dis(ctx) ) } } @@ -40686,11 +44974,17 @@ impl InstEncoding for OpSpecConstantCompositeContinuedINTEL { constituents: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSpecConstantCompositeContinuedINTEL{}", - self.constituents.dis(_ctx) + "{}OpSpecConstantCompositeContinuedINTEL{}", + ctx.id_result_writer(), + self.constituents.dis(ctx) ) } } @@ -40727,14 +45021,19 @@ impl InstEncoding for OpCompositeConstructContinuedINTEL { constituents: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpCompositeConstructContinuedINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.constituents.dis(_ctx) + "{}OpCompositeConstructContinuedINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.constituents.dis(ctx) ) } } @@ -40771,14 +45070,19 @@ impl InstEncoding for OpConvertFToBF16INTEL { float_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertFToBF16INTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.float_value.dis(_ctx) + "{}OpConvertFToBF16INTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.float_value.dis(ctx) ) } } @@ -40815,14 +45119,19 @@ impl InstEncoding for OpConvertBF16ToFINTEL { b_float_16_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertBF16ToFINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.b_float_16_value.dis(_ctx) + "{}OpConvertBF16ToFINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.b_float_16_value.dis(ctx) ) } } @@ -40859,13 +45168,19 @@ impl InstEncoding for OpControlBarrierArriveINTEL { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpControlBarrierArriveINTEL{}{}{}", - self.execution.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpControlBarrierArriveINTEL{}{}{}", + ctx.id_result_writer(), + self.execution.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -40902,13 +45217,19 @@ impl InstEncoding for OpControlBarrierWaitINTEL { semantics: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpControlBarrierWaitINTEL{}{}{}", - self.execution.dis(_ctx), - self.memory.dis(_ctx), - self.semantics.dis(_ctx) + "{}OpControlBarrierWaitINTEL{}{}{}", + ctx.id_result_writer(), + self.execution.dis(ctx), + self.memory.dis(ctx), + self.semantics.dis(ctx) ) } } @@ -40945,14 +45266,19 @@ impl InstEncoding for OpArithmeticFenceEXT { target: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpArithmeticFenceEXT{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.target.dis(_ctx) + "{}OpArithmeticFenceEXT{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.target.dis(ctx) ) } } @@ -41005,18 +45331,23 @@ impl InstEncoding for OpTaskSequenceCreateALTERA { async_capacity: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTaskSequenceCreateALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.function.dis(_ctx), - self.pipelined.dis(_ctx), - self.use_stall_enable_clusters.dis(_ctx), - self.get_capacity.dis(_ctx), - self.async_capacity.dis(_ctx) + "{}OpTaskSequenceCreateALTERA{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.function.dis(ctx), + self.pipelined.dis(ctx), + self.use_stall_enable_clusters.dis(ctx), + self.get_capacity.dis(ctx), + self.async_capacity.dis(ctx) ) } } @@ -41049,12 +45380,18 @@ impl InstEncoding for OpTaskSequenceAsyncALTERA { arguments: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpTaskSequenceAsyncALTERA{}{}", - self.sequence.dis(_ctx), - self.arguments.dis(_ctx) + "{}OpTaskSequenceAsyncALTERA{}{}", + ctx.id_result_writer(), + self.sequence.dis(ctx), + self.arguments.dis(ctx) ) } } @@ -41091,14 +45428,19 @@ impl InstEncoding for OpTaskSequenceGetALTERA { sequence: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpTaskSequenceGetALTERA{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.sequence.dis(_ctx) + "{}OpTaskSequenceGetALTERA{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.sequence.dis(ctx) ) } } @@ -41126,8 +45468,18 @@ impl InstEncoding for OpTaskSequenceReleaseALTERA { sequence: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "OpTaskSequenceReleaseALTERA{}", self.sequence.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}OpTaskSequenceReleaseALTERA{}", + ctx.id_result_writer(), + self.sequence.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -41154,8 +45506,13 @@ impl InstEncoding for OpTypeTaskSequenceALTERA { id_result: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "{} = OpTypeTaskSequenceALTERA", self.id_result.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: None, + ctx, + }; + write!(f, "{}OpTypeTaskSequenceALTERA", ctx.id_result_writer()) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -41191,13 +45548,19 @@ impl InstEncoding for OpSubgroupBlockPrefetchINTEL { memory_access: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSubgroupBlockPrefetchINTEL{}{}{}", - self.ptr.dis(_ctx), - self.num_bytes.dis(_ctx), - self.memory_access.dis(_ctx) + "{}OpSubgroupBlockPrefetchINTEL{}{}{}", + ctx.id_result_writer(), + self.ptr.dis(ctx), + self.num_bytes.dis(ctx), + self.memory_access.dis(ctx) ) } } @@ -41262,20 +45625,26 @@ impl InstEncoding for OpSubgroup2DBlockLoadINTEL { dst_pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSubgroup2DBlockLoadINTEL{}{}{}{}{}{}{}{}{}{}", - self.element_size.dis(_ctx), - self.block_width.dis(_ctx), - self.block_height.dis(_ctx), - self.block_count.dis(_ctx), - self.src_base_pointer.dis(_ctx), - self.memory_width.dis(_ctx), - self.memory_height.dis(_ctx), - self.memory_pitch.dis(_ctx), - self.coordinate.dis(_ctx), - self.dst_pointer.dis(_ctx) + "{}OpSubgroup2DBlockLoadINTEL{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.element_size.dis(ctx), + self.block_width.dis(ctx), + self.block_height.dis(ctx), + self.block_count.dis(ctx), + self.src_base_pointer.dis(ctx), + self.memory_width.dis(ctx), + self.memory_height.dis(ctx), + self.memory_pitch.dis(ctx), + self.coordinate.dis(ctx), + self.dst_pointer.dis(ctx) ) } } @@ -41340,20 +45709,26 @@ impl InstEncoding for OpSubgroup2DBlockLoadTransformINTEL { dst_pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSubgroup2DBlockLoadTransformINTEL{}{}{}{}{}{}{}{}{}{}", - self.element_size.dis(_ctx), - self.block_width.dis(_ctx), - self.block_height.dis(_ctx), - self.block_count.dis(_ctx), - self.src_base_pointer.dis(_ctx), - self.memory_width.dis(_ctx), - self.memory_height.dis(_ctx), - self.memory_pitch.dis(_ctx), - self.coordinate.dis(_ctx), - self.dst_pointer.dis(_ctx) + "{}OpSubgroup2DBlockLoadTransformINTEL{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.element_size.dis(ctx), + self.block_width.dis(ctx), + self.block_height.dis(ctx), + self.block_count.dis(ctx), + self.src_base_pointer.dis(ctx), + self.memory_width.dis(ctx), + self.memory_height.dis(ctx), + self.memory_pitch.dis(ctx), + self.coordinate.dis(ctx), + self.dst_pointer.dis(ctx) ) } } @@ -41418,20 +45793,26 @@ impl InstEncoding for OpSubgroup2DBlockLoadTransposeINTEL { dst_pointer: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSubgroup2DBlockLoadTransposeINTEL{}{}{}{}{}{}{}{}{}{}", - self.element_size.dis(_ctx), - self.block_width.dis(_ctx), - self.block_height.dis(_ctx), - self.block_count.dis(_ctx), - self.src_base_pointer.dis(_ctx), - self.memory_width.dis(_ctx), - self.memory_height.dis(_ctx), - self.memory_pitch.dis(_ctx), - self.coordinate.dis(_ctx), - self.dst_pointer.dis(_ctx) + "{}OpSubgroup2DBlockLoadTransposeINTEL{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.element_size.dis(ctx), + self.block_width.dis(ctx), + self.block_height.dis(ctx), + self.block_count.dis(ctx), + self.src_base_pointer.dis(ctx), + self.memory_width.dis(ctx), + self.memory_height.dis(ctx), + self.memory_pitch.dis(ctx), + self.coordinate.dis(ctx), + self.dst_pointer.dis(ctx) ) } } @@ -41492,19 +45873,25 @@ impl InstEncoding for OpSubgroup2DBlockPrefetchINTEL { coordinate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSubgroup2DBlockPrefetchINTEL{}{}{}{}{}{}{}{}{}", - self.element_size.dis(_ctx), - self.block_width.dis(_ctx), - self.block_height.dis(_ctx), - self.block_count.dis(_ctx), - self.src_base_pointer.dis(_ctx), - self.memory_width.dis(_ctx), - self.memory_height.dis(_ctx), - self.memory_pitch.dis(_ctx), - self.coordinate.dis(_ctx) + "{}OpSubgroup2DBlockPrefetchINTEL{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.element_size.dis(ctx), + self.block_width.dis(ctx), + self.block_height.dis(ctx), + self.block_count.dis(ctx), + self.src_base_pointer.dis(ctx), + self.memory_width.dis(ctx), + self.memory_height.dis(ctx), + self.memory_pitch.dis(ctx), + self.coordinate.dis(ctx) ) } } @@ -41569,20 +45956,26 @@ impl InstEncoding for OpSubgroup2DBlockStoreINTEL { coordinate: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpSubgroup2DBlockStoreINTEL{}{}{}{}{}{}{}{}{}{}", - self.element_size.dis(_ctx), - self.block_width.dis(_ctx), - self.block_height.dis(_ctx), - self.block_count.dis(_ctx), - self.src_pointer.dis(_ctx), - self.dst_base_pointer.dis(_ctx), - self.memory_width.dis(_ctx), - self.memory_height.dis(_ctx), - self.memory_pitch.dis(_ctx), - self.coordinate.dis(_ctx) + "{}OpSubgroup2DBlockStoreINTEL{}{}{}{}{}{}{}{}{}{}", + ctx.id_result_writer(), + self.element_size.dis(ctx), + self.block_width.dis(ctx), + self.block_height.dis(ctx), + self.block_count.dis(ctx), + self.src_pointer.dis(ctx), + self.dst_base_pointer.dis(ctx), + self.memory_width.dis(ctx), + self.memory_height.dis(ctx), + self.memory_pitch.dis(ctx), + self.coordinate.dis(ctx) ) } } @@ -41635,18 +46028,23 @@ impl InstEncoding for OpSubgroupMatrixMultiplyAccumulateINTEL { matrix_multiply_accumulate_operands: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSubgroupMatrixMultiplyAccumulateINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.k_dim.dis(_ctx), - self.matrix_a.dis(_ctx), - self.matrix_b.dis(_ctx), - self.matrix_c.dis(_ctx), - self.matrix_multiply_accumulate_operands.dis(_ctx) + "{}OpSubgroupMatrixMultiplyAccumulateINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.k_dim.dis(ctx), + self.matrix_a.dis(ctx), + self.matrix_b.dis(ctx), + self.matrix_c.dis(ctx), + self.matrix_multiply_accumulate_operands.dis(ctx) ) } } @@ -41695,17 +46093,22 @@ impl InstEncoding for OpBitwiseFunctionINTEL { lut_index: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpBitwiseFunctionINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.a.dis(_ctx), - self.b.dis(_ctx), - self.c.dis(_ctx), - self.lut_index.dis(_ctx) + "{}OpBitwiseFunctionINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.a.dis(ctx), + self.b.dis(ctx), + self.c.dis(ctx), + self.lut_index.dis(ctx) ) } } @@ -41746,15 +46149,20 @@ impl InstEncoding for OpUntypedVariableLengthArrayINTEL { length: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpUntypedVariableLengthArrayINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.element_type.dis(_ctx), - self.length.dis(_ctx) + "{}OpUntypedVariableLengthArrayINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.element_type.dis(ctx), + self.length.dis(ctx) ) } } @@ -41786,12 +46194,18 @@ impl InstEncoding for OpConditionalExtensionINTEL { name: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpConditionalExtensionINTEL{}{}", - self.condition.dis(_ctx), - self.name.dis(_ctx) + "{}OpConditionalExtensionINTEL{}{}", + ctx.id_result_writer(), + self.condition.dis(ctx), + self.name.dis(ctx) ) } } @@ -41836,15 +46250,21 @@ impl InstEncoding for OpConditionalEntryPointINTEL { interface: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpConditionalEntryPointINTEL{}{}{}{}{}", - self.condition.dis(_ctx), - self.execution_model.dis(_ctx), - self.entry_point.dis(_ctx), - self.name.dis(_ctx), - self.interface.dis(_ctx) + "{}OpConditionalEntryPointINTEL{}{}{}{}{}", + ctx.id_result_writer(), + self.condition.dis(ctx), + self.execution_model.dis(ctx), + self.entry_point.dis(ctx), + self.name.dis(ctx), + self.interface.dis(ctx) ) } } @@ -41877,12 +46297,18 @@ impl InstEncoding for OpConditionalCapabilityINTEL { capability: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpConditionalCapabilityINTEL{}{}", - self.condition.dis(_ctx), - self.capability.dis(_ctx) + "{}OpConditionalCapabilityINTEL{}{}", + ctx.id_result_writer(), + self.condition.dis(ctx), + self.capability.dis(ctx) ) } } @@ -41923,15 +46349,20 @@ impl InstEncoding for OpSpecConstantTargetINTEL { features: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSpecConstantTargetINTEL{rspirv_space}{}{rspirv_space}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.target.dis(_ctx), - self.features.dis(_ctx) + "{}OpSpecConstantTargetINTEL{rspirv_space}{}{rspirv_space}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.target.dis(ctx), + self.features.dis(ctx) ) } } @@ -41980,17 +46411,22 @@ impl InstEncoding for OpSpecConstantArchitectureINTEL { architecture: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSpecConstantArchitectureINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.category.dis(_ctx), - self.family.dis(_ctx), - self.opcode.dis(_ctx), - self.architecture.dis(_ctx) + "{}OpSpecConstantArchitectureINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.category.dis(ctx), + self.family.dis(ctx), + self.opcode.dis(ctx), + self.architecture.dis(ctx) ) } } @@ -42027,14 +46463,19 @@ impl InstEncoding for OpSpecConstantCapabilitiesINTEL { capabilities: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpSpecConstantCapabilitiesINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.capabilities.dis(_ctx) + "{}OpSpecConstantCapabilitiesINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.capabilities.dis(ctx) ) } } @@ -42071,14 +46512,19 @@ impl InstEncoding for OpConditionalCopyObjectINTEL { id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConditionalCopyObjectINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.id_ref.dis(_ctx) + "{}OpConditionalCopyObjectINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.id_ref.dis(ctx) ) } } @@ -42123,16 +46569,21 @@ impl InstEncoding for OpGroupIMulKHR { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupIMulKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupIMulKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -42177,16 +46628,21 @@ impl InstEncoding for OpGroupFMulKHR { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupFMulKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupFMulKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -42231,16 +46687,21 @@ impl InstEncoding for OpGroupBitwiseAndKHR { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupBitwiseAndKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupBitwiseAndKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -42285,16 +46746,21 @@ impl InstEncoding for OpGroupBitwiseOrKHR { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupBitwiseOrKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupBitwiseOrKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -42339,16 +46805,21 @@ impl InstEncoding for OpGroupBitwiseXorKHR { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupBitwiseXorKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupBitwiseXorKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -42393,16 +46864,21 @@ impl InstEncoding for OpGroupLogicalAndKHR { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupLogicalAndKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupLogicalAndKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -42447,16 +46923,21 @@ impl InstEncoding for OpGroupLogicalOrKHR { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupLogicalOrKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupLogicalOrKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -42501,16 +46982,21 @@ impl InstEncoding for OpGroupLogicalXorKHR { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpGroupLogicalXorKHR{rspirv_space}{}{rspirv_space}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.execution.dis(_ctx), - self.operation.dis(_ctx), - self.x.dis(_ctx) + "{}OpGroupLogicalXorKHR{rspirv_space}{}{rspirv_space}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.execution.dis(ctx), + self.operation.dis(ctx), + self.x.dis(ctx) ) } } @@ -42547,14 +47033,19 @@ impl InstEncoding for OpRoundFToTF32INTEL { float_value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpRoundFToTF32INTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.float_value.dis(_ctx) + "{}OpRoundFToTF32INTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.float_value.dis(ctx) ) } } @@ -42603,17 +47094,22 @@ impl InstEncoding for OpMaskedGatherINTEL { fill_empty: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpMaskedGatherINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.ptr_vector.dis(_ctx), - self.alignment.dis(_ctx), - self.mask.dis(_ctx), - self.fill_empty.dis(_ctx) + "{}OpMaskedGatherINTEL{rspirv_space}{}{rspirv_space}{}{}{}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.ptr_vector.dis(ctx), + self.alignment.dis(ctx), + self.mask.dis(ctx), + self.fill_empty.dis(ctx) ) } } @@ -42654,14 +47150,20 @@ impl InstEncoding for OpMaskedScatterINTEL { mask: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "OpMaskedScatterINTEL{}{}{}{}", - self.input_vector.dis(_ctx), - self.ptr_vector.dis(_ctx), - self.alignment.dis(_ctx), - self.mask.dis(_ctx) + "{}OpMaskedScatterINTEL{}{}{}{}", + ctx.id_result_writer(), + self.input_vector.dis(ctx), + self.ptr_vector.dis(ctx), + self.alignment.dis(ctx), + self.mask.dis(ctx) ) } } @@ -42698,14 +47200,19 @@ impl InstEncoding for OpConvertHandleToImageINTEL { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertHandleToImageINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpConvertHandleToImageINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -42742,14 +47249,19 @@ impl InstEncoding for OpConvertHandleToSamplerINTEL { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertHandleToSamplerINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpConvertHandleToSamplerINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } @@ -42786,14 +47298,19 @@ impl InstEncoding for OpConvertHandleToSampledImageINTEL { operand: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - let rspirv_space = _ctx.rspirv_space(); + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + ctx, + }; + let rspirv_space = ctx.rspirv_space(); write!( f, - "{} = OpConvertHandleToSampledImageINTEL{rspirv_space}{}{rspirv_space}{}", - self.id_result.dis(_ctx), - self.id_result_type.dis(_ctx), - self.operand.dis(_ctx) + "{}OpConvertHandleToSampledImageINTEL{rspirv_space}{}{rspirv_space}{}", + ctx.id_result_writer(), + self.id_result_type.dis(ctx), + self.operand.dis(ctx) ) } } diff --git a/crates/rspirv2/src/core/inst_set.rs b/crates/rspirv2/src/core/inst_set.rs index 6600b06a..2853ce60 100644 --- a/crates/rspirv2/src/core/inst_set.rs +++ b/crates/rspirv2/src/core/inst_set.rs @@ -6170,9 +6170,12 @@ impl InstEncoding for CoreInstSet { ) } _ => { - return Err(DecodeError::UnknownOpCode { - opcode, - }); + return Err( + DecodeErrorKind::UnknownOpCode { + opcode, + } + .into(), + ); } }, ) diff --git a/crates/rspirv2/src/core/operands.rs b/crates/rspirv2/src/core/operands.rs index 506eebaf..d4578be1 100644 --- a/crates/rspirv2/src/core/operands.rs +++ b/crates/rspirv2/src/core/operands.rs @@ -27,7 +27,7 @@ unsafe impl OperandEncoding for ImageOperands { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -108,7 +108,7 @@ unsafe impl OperandEncoding for FPFastMathMode { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -163,7 +163,7 @@ unsafe impl OperandEncoding for SelectionControl { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -211,7 +211,7 @@ unsafe impl OperandEncoding for LoopControl { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -300,7 +300,7 @@ unsafe impl OperandEncoding for FunctionControl { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -352,7 +352,7 @@ unsafe impl OperandEncoding for MemorySemantics { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -429,7 +429,7 @@ unsafe impl OperandEncoding for MemoryAccess { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -484,7 +484,7 @@ unsafe impl OperandEncoding for KernelProfilingInfo { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -522,7 +522,7 @@ unsafe impl OperandEncoding for RayFlags { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -587,7 +587,7 @@ unsafe impl OperandEncoding for FragmentShadingRate { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -631,7 +631,7 @@ unsafe impl OperandEncoding for RawAccessChainOperands { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -696,15 +696,16 @@ unsafe impl OperandEncoding for SourceLanguage { 12u32 => Self::Zig, 13u32 => Self::Rust, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(SourceLanguage), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Unknown => write!(f, " Unknown"), Self::ESSL => write!(f, " ESSL"), @@ -778,15 +779,16 @@ unsafe impl OperandEncoding for ExecutionModel { 5364u32 => Self::TaskEXT, 5365u32 => Self::MeshEXT, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(ExecutionModel), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Vertex => write!(f, " Vertex"), Self::TessellationControl => write!(f, " TessellationControl"), @@ -838,15 +840,16 @@ unsafe impl OperandEncoding for AddressingModel { 2u32 => Self::Physical64, 5348u32 => Self::PhysicalStorageBuffer64, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(AddressingModel), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Logical => write!(f, " Logical"), Self::Physical32 => write!(f, " Physical32"), @@ -885,15 +888,16 @@ unsafe impl OperandEncoding for MemoryModel { 2u32 => Self::OpenCL, 3u32 => Self::Vulkan, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(MemoryModel), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Simple => write!(f, " Simple"), Self::GLSL450 => write!(f, " GLSL450"), @@ -1548,15 +1552,16 @@ unsafe impl OperandEncoding for ExecutionMode { 6462u32 => Self::MaximumRegistersIdINTEL(OperandEncoding::decode(&mut *reader)?), 6463u32 => Self::NamedMaximumRegistersINTEL(OperandEncoding::decode(&mut *reader)?), _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(ExecutionMode), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Invocations(p0) => write!(f, " Invocations{}", p0.dis(_ctx)), Self::SpacingEqual => write!(f, " SpacingEqual"), @@ -1866,15 +1871,16 @@ unsafe impl OperandEncoding for StorageClass { 5936u32 => Self::DeviceOnlyALTERA, 5937u32 => Self::HostOnlyALTERA, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(StorageClass), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::UniformConstant => write!(f, " UniformConstant"), Self::Input => write!(f, " Input"), @@ -1945,15 +1951,16 @@ unsafe impl OperandEncoding for Dim { 6u32 => Self::SubpassData, 4173u32 => Self::TileImageDataEXT, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(Dim), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Dim1D => write!(f, " 1D"), Self::Dim2D => write!(f, " 2D"), @@ -1997,15 +2004,16 @@ unsafe impl OperandEncoding for SamplerAddressingMode { 3u32 => Self::Repeat, 4u32 => Self::RepeatMirrored, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(SamplerAddressingMode), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::None => write!(f, " None"), Self::ClampToEdge => write!(f, " ClampToEdge"), @@ -2040,15 +2048,16 @@ unsafe impl OperandEncoding for SamplerFilterMode { 0u32 => Self::Nearest, 1u32 => Self::Linear, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(SamplerFilterMode), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Nearest => write!(f, " Nearest"), Self::Linear => write!(f, " Linear"), @@ -2160,15 +2169,16 @@ unsafe impl OperandEncoding for ImageFormat { 40u32 => Self::R64ui, 41u32 => Self::R64i, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(ImageFormat), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Unknown => write!(f, " Unknown"), Self::Rgba32f => write!(f, " Rgba32f"), @@ -2276,15 +2286,16 @@ unsafe impl OperandEncoding for ImageChannelOrder { 18u32 => Self::sBGRA, 19u32 => Self::ABGR, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(ImageChannelOrder), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::R => write!(f, " R"), Self::A => write!(f, " A"), @@ -2382,15 +2393,16 @@ unsafe impl OperandEncoding for ImageChannelDataType { 25u32 => Self::UnormInt12X4EXT, 26u32 => Self::UnormInt14X2EXT, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(ImageChannelDataType), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::SnormInt8 => write!(f, " SnormInt8"), Self::SnormInt16 => write!(f, " SnormInt16"), @@ -2450,15 +2462,16 @@ unsafe impl OperandEncoding for FPRoundingMode { 2u32 => Self::RTP, 3u32 => Self::RTN, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(FPRoundingMode), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::RTE => write!(f, " RTE"), Self::RTZ => write!(f, " RTZ"), @@ -2492,15 +2505,16 @@ unsafe impl OperandEncoding for FPDenormMode { 0u32 => Self::Preserve, 1u32 => Self::FlushToZero, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(FPDenormMode), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Preserve => write!(f, " Preserve"), Self::FlushToZero => write!(f, " FlushToZero"), @@ -2544,15 +2558,16 @@ unsafe impl OperandEncoding for QuantizationModes { 6u32 => Self::RND_CONV, 7u32 => Self::RND_CONV_ODD, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(QuantizationModes), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::TRN => write!(f, " TRN"), Self::TRN_ZERO => write!(f, " TRN_ZERO"), @@ -2590,15 +2605,16 @@ unsafe impl OperandEncoding for FPOperationMode { 0u32 => Self::IEEE, 1u32 => Self::ALT, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(FPOperationMode), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::IEEE => write!(f, " IEEE"), Self::ALT => write!(f, " ALT"), @@ -2634,15 +2650,16 @@ unsafe impl OperandEncoding for OverflowModes { 2u32 => Self::SAT_ZERO, 3u32 => Self::SAT_SYM, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(OverflowModes), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::WRAP => write!(f, " WRAP"), Self::SAT => write!(f, " SAT"), @@ -2678,15 +2695,16 @@ unsafe impl OperandEncoding for LinkageType { 1u32 => Self::Import, 2u32 => Self::LinkOnceODR, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(LinkageType), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Export => write!(f, " Export"), Self::Import => write!(f, " Import"), @@ -2721,15 +2739,16 @@ unsafe impl OperandEncoding for AccessQualifier { 1u32 => Self::WriteOnly, 2u32 => Self::ReadWrite, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(AccessQualifier), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::ReadOnly => write!(f, " ReadOnly"), Self::WriteOnly => write!(f, " WriteOnly"), @@ -2766,15 +2785,16 @@ unsafe impl OperandEncoding for HostAccessQualifier { 2u32 => Self::WriteINTEL, 3u32 => Self::ReadWriteINTEL, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(HostAccessQualifier), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::NoneINTEL => write!(f, " NoneINTEL"), Self::ReadINTEL => write!(f, " ReadINTEL"), @@ -2822,15 +2842,16 @@ unsafe impl OperandEncoding for FunctionParameterAttribute { 7u32 => Self::NoReadWrite, 5940u32 => Self::RuntimeAlignedALTERA, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(FunctionParameterAttribute), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Zext => write!(f, " Zext"), Self::Sext => write!(f, " Sext"), @@ -3858,15 +3879,16 @@ unsafe impl OperandEncoding for Decoration { OperandEncoding::decode(&mut *reader)?, ), _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(Decoration), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::RelaxedPrecision => write!(f, " RelaxedPrecision"), Self::SpecId(p0) => write!(f, " SpecId{}", p0.dis(_ctx)), @@ -4416,15 +4438,16 @@ unsafe impl OperandEncoding for BuiltIn { 5436u32 => Self::ClusterIDNV, 6021u32 => Self::CullMaskKHR, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(BuiltIn), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Position => write!(f, " Position"), Self::PointSize => write!(f, " PointSize"), @@ -4609,15 +4632,16 @@ unsafe impl OperandEncoding for Scope { 5u32 => Self::QueueFamily, 6u32 => Self::ShaderCallKHR, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(Scope), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::CrossDevice => write!(f, " CrossDevice"), Self::Device => write!(f, " Device"), @@ -4665,15 +4689,16 @@ unsafe impl OperandEncoding for GroupOperation { 7u32 => Self::PartitionedInclusiveScanEXT, 8u32 => Self::PartitionedExclusiveScanEXT, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(GroupOperation), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Reduce => write!(f, " Reduce"), Self::InclusiveScan => write!(f, " InclusiveScan"), @@ -4716,15 +4741,16 @@ unsafe impl OperandEncoding for KernelEnqueueFlags { 1u32 => Self::WaitKernel, 2u32 => Self::WaitWorkGroup, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(KernelEnqueueFlags), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::NoWait => write!(f, " NoWait"), Self::WaitKernel => write!(f, " WaitKernel"), @@ -5364,15 +5390,16 @@ unsafe impl OperandEncoding for Capability { 6460u32 => Self::RegisterLimitsINTEL, 6528u32 => Self::BindlessImagesINTEL, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(Capability), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Matrix => write!(f, " Matrix"), Self::Shader => write!(f, " Shader"), @@ -5840,15 +5867,16 @@ unsafe impl OperandEncoding for RayQueryIntersection { 0u32 => Self::RayQueryCandidateIntersectionKHR, 1u32 => Self::RayQueryCommittedIntersectionKHR, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(RayQueryIntersection), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::RayQueryCandidateIntersectionKHR => { write!(f, " RayQueryCandidateIntersectionKHR") @@ -5886,15 +5914,16 @@ unsafe impl OperandEncoding for RayQueryCommittedIntersectionType { 1u32 => Self::RayQueryCommittedIntersectionTriangleKHR, 2u32 => Self::RayQueryCommittedIntersectionGeneratedKHR, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(RayQueryCommittedIntersectionType), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::RayQueryCommittedIntersectionNoneKHR => { write!(f, " RayQueryCommittedIntersectionNoneKHR") @@ -5933,15 +5962,16 @@ unsafe impl OperandEncoding for RayQueryCandidateIntersectionType { 0u32 => Self::RayQueryCandidateIntersectionTriangleKHR, 1u32 => Self::RayQueryCandidateIntersectionAABBKHR, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(RayQueryCandidateIntersectionType), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::RayQueryCandidateIntersectionTriangleKHR => { write!(f, " RayQueryCandidateIntersectionTriangleKHR") @@ -5976,15 +6006,16 @@ unsafe impl OperandEncoding for PackedVectorFormat { Ok(match variant { 0u32 => Self::PackedVectorFormat4x8Bit, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(PackedVectorFormat), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::PackedVectorFormat4x8Bit => write!(f, " PackedVectorFormat4x8Bit"), } @@ -6014,7 +6045,7 @@ unsafe impl OperandEncoding for CooperativeMatrixOperands { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -6068,15 +6099,16 @@ unsafe impl OperandEncoding for CooperativeMatrixLayout { 4202u32 => Self::RowBlockedInterleavedARM, 4203u32 => Self::ColumnBlockedInterleavedARM, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(CooperativeMatrixLayout), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::RowMajorKHR => write!(f, " RowMajorKHR"), Self::ColumnMajorKHR => write!(f, " ColumnMajorKHR"), @@ -6114,15 +6146,16 @@ unsafe impl OperandEncoding for CooperativeMatrixUse { 1u32 => Self::MatrixBKHR, 2u32 => Self::MatrixAccumulatorKHR, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(CooperativeMatrixUse), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::MatrixAKHR => write!(f, " MatrixAKHR"), Self::MatrixBKHR => write!(f, " MatrixBKHR"), @@ -6151,7 +6184,7 @@ unsafe impl OperandEncoding for CooperativeMatrixReduce { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -6201,15 +6234,16 @@ unsafe impl OperandEncoding for TensorClampMode { 3u32 => Self::Repeat, 4u32 => Self::RepeatMirrored, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(TensorClampMode), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Undefined => write!(f, " Undefined"), Self::Constant => write!(f, " Constant"), @@ -6241,7 +6275,7 @@ unsafe impl OperandEncoding for TensorAddressingOperands { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -6282,15 +6316,16 @@ unsafe impl OperandEncoding for InitializationModeQualifier { 0u32 => Self::InitOnDeviceReprogramALTERA, 1u32 => Self::InitOnDeviceResetALTERA, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(InitializationModeQualifier), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::InitOnDeviceReprogramALTERA => { write!(f, " InitOnDeviceReprogramALTERA") @@ -6330,15 +6365,16 @@ unsafe impl OperandEncoding for LoadCacheControl { 3u32 => Self::InvalidateAfterReadINTEL, 4u32 => Self::ConstCachedINTEL, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(LoadCacheControl), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::UncachedINTEL => write!(f, " UncachedINTEL"), Self::CachedINTEL => write!(f, " CachedINTEL"), @@ -6377,15 +6413,16 @@ unsafe impl OperandEncoding for StoreCacheControl { 2u32 => Self::WriteBackINTEL, 3u32 => Self::StreamingINTEL, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(StoreCacheControl), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::UncachedINTEL => write!(f, " UncachedINTEL"), Self::WriteThroughINTEL => write!(f, " WriteThroughINTEL"), @@ -6417,15 +6454,16 @@ unsafe impl OperandEncoding for NamedMaximumNumberOfRegisters { Ok(match variant { 0u32 => Self::AutoINTEL, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(NamedMaximumNumberOfRegisters), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::AutoINTEL => write!(f, " AutoINTEL"), } @@ -6458,7 +6496,7 @@ unsafe impl OperandEncoding for MatrixMultiplyAccumulateOperands { >(stringify!(MatrixMultiplyAccumulateOperands), bits)) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { @@ -6537,15 +6575,16 @@ unsafe impl OperandEncoding for FPEncoding { 4214u32 => Self::Float8E4M3EXT, 4215u32 => Self::Float8E5M2EXT, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(FPEncoding), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::BFloat16KHR => write!(f, " BFloat16KHR"), Self::Float8E4M3EXT => write!(f, " Float8E4M3EXT"), @@ -6582,15 +6621,16 @@ unsafe impl OperandEncoding for CooperativeVectorMatrixLayout { 2u32 => Self::InferencingOptimalNV, 3u32 => Self::TrainingOptimalNV, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(CooperativeVectorMatrixLayout), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::RowMajorNV => write!(f, " RowMajorNV"), Self::ColumnMajorNV => write!(f, " ColumnMajorNV"), @@ -6650,15 +6690,16 @@ unsafe impl OperandEncoding for ComponentType { 1000491002u32 => Self::FloatE4M3NV, 1000491003u32 => Self::FloatE5M2NV, _ => { - return Err(DecodeError::UnknownEnumVariant { + return Err(DecodeErrorKind::UnknownEnumVariant { name: stringify!(ComponentType), variant, - }); + } + .into()); } }) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { match self { Self::Float16NV => write!(f, " Float16NV"), Self::Float32NV => write!(f, " Float32NV"), @@ -6700,10 +6741,10 @@ unsafe impl OperandEncoding for PairLiteralIntegerIdRef { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { write!( f, - " {} {}", + "{}{}", OperandEncoding::dis(&self.0, ctx), OperandEncoding::dis(&self.1, ctx) ) @@ -6731,10 +6772,10 @@ unsafe impl OperandEncoding for PairIdRefLiteralInteger { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { write!( f, - " {} {}", + "{}{}", OperandEncoding::dis(&self.0, ctx), OperandEncoding::dis(&self.1, ctx) ) @@ -6762,10 +6803,10 @@ unsafe impl OperandEncoding for PairIdRefIdRef { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &OperandDisContext<'_>) -> std::fmt::Result { write!( f, - " {} {}", + "{}{}", OperandEncoding::dis(&self.0, ctx), OperandEncoding::dis(&self.1, ctx) ) @@ -6794,7 +6835,7 @@ unsafe impl OperandEncoding for TensorOperands { )) } #[inline] - fn dis_fmt(&self, f: &mut Formatter<'_>, _: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, _: &OperandDisContext<'_>) -> std::fmt::Result { if self.is_empty() { write!(f, " None") } else { diff --git a/crates/rspirv2/src/debug_printf/inst.rs b/crates/rspirv2/src/debug_printf/inst.rs index d96590dd..080277e2 100644 --- a/crates/rspirv2/src/debug_printf/inst.rs +++ b/crates/rspirv2/src/debug_printf/inst.rs @@ -27,12 +27,18 @@ impl InstEncoding for DebugPrintf { id_ref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "DebugPrintf{}{}", - self.format.dis(_ctx), - self.id_ref.dis(_ctx) + "{}DebugPrintf{}{}", + ctx.id_result_writer(), + self.format.dis(ctx), + self.id_ref.dis(ctx) ) } } diff --git a/crates/rspirv2/src/debug_printf/inst_set.rs b/crates/rspirv2/src/debug_printf/inst_set.rs index 970770bd..4025445e 100644 --- a/crates/rspirv2/src/debug_printf/inst_set.rs +++ b/crates/rspirv2/src/debug_printf/inst_set.rs @@ -17,7 +17,7 @@ impl InstEncoding for DebugPrintfInstSet { Ok(match opcode { 1u16 => Self::DebugPrintf(::decode(reader)?), _ => { - return Err(DecodeError::UnknownOpCode { opcode }); + return Err(DecodeErrorKind::UnknownOpCode { opcode }.into()); } }) } diff --git a/crates/rspirv2/src/dis.rs b/crates/rspirv2/src/dis.rs new file mode 100644 index 00000000..43f0fe5d --- /dev/null +++ b/crates/rspirv2/src/dis.rs @@ -0,0 +1,196 @@ +use crate::core::inst::{ + OpConstant, OpConstantFalse, OpConstantNull, OpConstantTrue, OpTypeBool, OpTypeFloat, + OpTypeInt, OpTypePointer, OpTypeStruct, OpTypeVector, OpTypeVoid, +}; +use crate::core::inst_set::CoreInstSet; +use crate::core::preamble::OpTypeRuntimeArray; +pub use rspirv2_types::dis::*; +use rspirv2_types::operand::{ConstFmt, OperandDisContext}; +use rspirv2_types::slice::{RawInstSlice, SkipDecodeErrorIteratorExt, TryDecodeIteratorExt}; + +impl InstSetDisCtx for CoreInstSet { + fn add_context(slice: &RawInstSlice, ctx: &mut DisContext) { + for inst in slice.iter().try_decode::().skip_errors() { + match inst { + Self::Name(inst) => { + if let Some(name) = escape_id_name(&inst.name.0) { + ctx.add_id_to_name(inst.target.0, IdName::ExplicitName(name)); + } + } + Self::TypeVoid(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + Self::TypeBool(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + Self::TypeFloat(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + ctx.id_to_const_fmt.insert(def, ConstFmt::Float); + } + Self::TypeInt(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + ctx.id_to_const_fmt.insert( + def, + if inst.signedness.to_bool() { + ConstFmt::Signed + } else { + ConstFmt::Unsigned + }, + ); + } + Self::TypeVector(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + Self::TypeRuntimeArray(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + Self::TypePointer(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + Self::TypeStruct(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + Self::Constant(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + Self::ConstantNull(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + Self::ConstantFalse(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + Self::ConstantTrue(inst) => { + let def = inst.id_result.unwrap(); + ctx.add_id_to_name(def, inst.derive_name(ctx)); + } + _ => {} + } + } + } +} + +impl OpTypeVoid { + pub fn derive_name(&self, _ctx: &DisContext) -> IdName { + IdName::DerivedName("void".to_string()) + } +} + +impl OpTypeBool { + pub fn derive_name(&self, _ctx: &DisContext) -> IdName { + IdName::DerivedName("bool".to_string()) + } +} + +impl OpTypeInt { + pub fn derive_name(&self, ctx: &DisContext) -> IdName { + let signed = self.signedness.to_bool(); + let width = self.width.to_u32(); + IdName::DerivedName(match ctx.type_naming { + TypeNaming::Rust => { + format!("{}{width}", if signed { "i" } else { "u" }) + } + TypeNaming::C => match (signed, width) { + (false, 32) => "uint".to_string(), + (true, 32) => "int".to_string(), + (false, _) => format!("uint{width}_t"), + (true, _) => format!("int{width}_t"), + }, + }) + } +} + +impl OpTypeFloat { + pub fn derive_name(&self, ctx: &DisContext) -> IdName { + let width = self.width.to_u32(); + IdName::DerivedName(match ctx.type_naming { + TypeNaming::Rust => { + format!("f{width}") + } + TypeNaming::C => match width { + 32 => "float".to_string(), + 64 => "double".to_string(), + _ => format!("float{width}_t"), + }, + }) + } +} + +impl OpTypeVector { + pub fn derive_name(&self, ctx: &DisContext) -> IdName { + let ty_name = ctx.id_to_name(self.component_type.0); + let count = self.component_count.to_u32(); + IdName::DerivedName(format!("v{count}{ty_name}")) + } +} + +impl OpTypeRuntimeArray { + pub fn derive_name(&self, ctx: &DisContext) -> IdName { + let ty_name = ctx.id_to_name(self.element_type.0); + IdName::DerivedName(format!("_runtimearr_{ty_name}")) + } +} + +impl OpTypePointer { + pub fn derive_name(&self, ctx: &DisContext) -> IdName { + let ty_name = ctx.id_to_name(self.ty.0); + let storage_class = self.storage_class; + IdName::DerivedName(format!("_ptr_{storage_class:?}_{ty_name}")) + } +} + +impl OpTypeStruct { + pub fn derive_name(&self, _ctx: &DisContext) -> IdName { + IdName::DerivedName(format!("_struct_{}", self.id_result.unwrap().0.0)) + } +} + +impl OpConstant { + pub fn derive_name(&self, ctx: &DisContext) -> IdName { + let ty_name = ctx.id_to_name(self.id_result_type.0); + let operand_ctx = OperandDisContext { + ctx, + id_result: self.id_result, + id_result_type: Some(self.id_result_type), + }; + let value = self.value.fmt_value(&operand_ctx).to_string(); + let value = value + .chars() + .map(|c| match c { + '0'..='9' => c, + '-' => 'n', + _ => '_', + }) + .collect::(); + IdName::DerivedName(format!("{ty_name}_{value}")) + } +} + +impl OpConstantNull { + pub fn derive_name(&self, ctx: &DisContext) -> IdName { + let ty_name = ctx.id_to_name(self.id_result_type.0); + IdName::DerivedName(format!("{ty_name}_0")) + } +} + +impl OpConstantFalse { + pub fn derive_name(&self, _ctx: &DisContext) -> IdName { + IdName::DerivedName("bool_false".to_string()) + } +} + +impl OpConstantTrue { + pub fn derive_name(&self, _ctx: &DisContext) -> IdName { + IdName::DerivedName("bool_true".to_string()) + } +} diff --git a/crates/rspirv2/src/glsl_std_450/inst.rs b/crates/rspirv2/src/glsl_std_450/inst.rs index a9b1439e..3d0b74c7 100644 --- a/crates/rspirv2/src/glsl_std_450/inst.rs +++ b/crates/rspirv2/src/glsl_std_450/inst.rs @@ -23,8 +23,13 @@ impl InstEncoding for Round { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Round{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Round{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -51,8 +56,13 @@ impl InstEncoding for RoundEven { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "RoundEven{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}RoundEven{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -79,8 +89,13 @@ impl InstEncoding for Trunc { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Trunc{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Trunc{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -107,8 +122,13 @@ impl InstEncoding for FAbs { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "FAbs{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}FAbs{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -135,8 +155,13 @@ impl InstEncoding for SAbs { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "SAbs{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}SAbs{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -163,8 +188,13 @@ impl InstEncoding for FSign { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "FSign{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}FSign{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -191,8 +221,13 @@ impl InstEncoding for SSign { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "SSign{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}SSign{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -219,8 +254,13 @@ impl InstEncoding for Floor { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Floor{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Floor{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -247,8 +287,13 @@ impl InstEncoding for Ceil { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Ceil{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Ceil{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -275,8 +320,13 @@ impl InstEncoding for Fract { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Fract{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Fract{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -303,8 +353,18 @@ impl InstEncoding for Radians { degrees: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Radians{}", self.degrees.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Radians{}", + ctx.id_result_writer(), + self.degrees.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -331,8 +391,18 @@ impl InstEncoding for Degrees { radians: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Degrees{}", self.radians.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Degrees{}", + ctx.id_result_writer(), + self.radians.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -359,8 +429,13 @@ impl InstEncoding for Sin { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Sin{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Sin{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -387,8 +462,13 @@ impl InstEncoding for Cos { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Cos{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Cos{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -415,8 +495,13 @@ impl InstEncoding for Tan { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Tan{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Tan{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -443,8 +528,13 @@ impl InstEncoding for Asin { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Asin{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Asin{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -471,8 +561,13 @@ impl InstEncoding for Acos { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Acos{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Acos{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -499,8 +594,18 @@ impl InstEncoding for Atan { y_over_x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Atan{}", self.y_over_x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Atan{}", + ctx.id_result_writer(), + self.y_over_x.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -527,8 +632,13 @@ impl InstEncoding for Sinh { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Sinh{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Sinh{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -555,8 +665,13 @@ impl InstEncoding for Cosh { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Cosh{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Cosh{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -583,8 +698,13 @@ impl InstEncoding for Tanh { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Tanh{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Tanh{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -611,8 +731,13 @@ impl InstEncoding for Asinh { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Asinh{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Asinh{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -639,8 +764,13 @@ impl InstEncoding for Acosh { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Acosh{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Acosh{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -667,8 +797,13 @@ impl InstEncoding for Atanh { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Atanh{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Atanh{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -698,8 +833,19 @@ impl InstEncoding for Atan2 { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Atan2{}{}", self.y.dis(_ctx), self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Atan2{}{}", + ctx.id_result_writer(), + self.y.dis(ctx), + self.x.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -729,8 +875,19 @@ impl InstEncoding for Pow { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Pow{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Pow{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -757,8 +914,13 @@ impl InstEncoding for Exp { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Exp{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Exp{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -785,8 +947,13 @@ impl InstEncoding for Log { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Log{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Log{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -813,8 +980,13 @@ impl InstEncoding for Exp2 { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Exp2{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Exp2{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -841,8 +1013,13 @@ impl InstEncoding for Log2 { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Log2{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Log2{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -869,8 +1046,13 @@ impl InstEncoding for Sqrt { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Sqrt{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Sqrt{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -897,8 +1079,18 @@ impl InstEncoding for InverseSqrt { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "InverseSqrt{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}InverseSqrt{}", + ctx.id_result_writer(), + self.x.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -925,8 +1117,18 @@ impl InstEncoding for Determinant { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Determinant{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Determinant{}", + ctx.id_result_writer(), + self.x.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -953,8 +1155,18 @@ impl InstEncoding for MatrixInverse { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "MatrixInverse{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}MatrixInverse{}", + ctx.id_result_writer(), + self.x.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -984,8 +1196,19 @@ impl InstEncoding for Modf { i: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Modf{}{}", self.x.dis(_ctx), self.i.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Modf{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.i.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1012,8 +1235,13 @@ impl InstEncoding for ModfStruct { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "ModfStruct{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}ModfStruct{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1043,8 +1271,19 @@ impl InstEncoding for FMin { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "FMin{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}FMin{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1074,8 +1313,19 @@ impl InstEncoding for UMin { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "UMin{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}UMin{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1105,8 +1355,19 @@ impl InstEncoding for SMin { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "SMin{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}SMin{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1136,8 +1397,19 @@ impl InstEncoding for FMax { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "FMax{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}FMax{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1167,8 +1439,19 @@ impl InstEncoding for UMax { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "UMax{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}UMax{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1198,8 +1481,19 @@ impl InstEncoding for SMax { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "SMax{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}SMax{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1235,13 +1529,19 @@ impl InstEncoding for FClamp { max_val: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "FClamp{}{}{}", - self.x.dis(_ctx), - self.min_val.dis(_ctx), - self.max_val.dis(_ctx) + "{}FClamp{}{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.min_val.dis(ctx), + self.max_val.dis(ctx) ) } } @@ -1278,13 +1578,19 @@ impl InstEncoding for UClamp { max_val: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "UClamp{}{}{}", - self.x.dis(_ctx), - self.min_val.dis(_ctx), - self.max_val.dis(_ctx) + "{}UClamp{}{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.min_val.dis(ctx), + self.max_val.dis(ctx) ) } } @@ -1321,13 +1627,19 @@ impl InstEncoding for SClamp { max_val: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "SClamp{}{}{}", - self.x.dis(_ctx), - self.min_val.dis(_ctx), - self.max_val.dis(_ctx) + "{}SClamp{}{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.min_val.dis(ctx), + self.max_val.dis(ctx) ) } } @@ -1364,13 +1676,19 @@ impl InstEncoding for FMix { a: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "FMix{}{}{}", - self.x.dis(_ctx), - self.y.dis(_ctx), - self.a.dis(_ctx) + "{}FMix{}{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx), + self.a.dis(ctx) ) } } @@ -1407,13 +1725,19 @@ impl InstEncoding for IMix { a: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "IMix{}{}{}", - self.x.dis(_ctx), - self.y.dis(_ctx), - self.a.dis(_ctx) + "{}IMix{}{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx), + self.a.dis(ctx) ) } } @@ -1444,8 +1768,19 @@ impl InstEncoding for Step { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Step{}{}", self.edge.dis(_ctx), self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Step{}{}", + ctx.id_result_writer(), + self.edge.dis(ctx), + self.x.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1481,13 +1816,19 @@ impl InstEncoding for SmoothStep { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "SmoothStep{}{}{}", - self.edge_0.dis(_ctx), - self.edge_1.dis(_ctx), - self.x.dis(_ctx) + "{}SmoothStep{}{}{}", + ctx.id_result_writer(), + self.edge_0.dis(ctx), + self.edge_1.dis(ctx), + self.x.dis(ctx) ) } } @@ -1524,13 +1865,19 @@ impl InstEncoding for Fma { c: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "Fma{}{}{}", - self.a.dis(_ctx), - self.b.dis(_ctx), - self.c.dis(_ctx) + "{}Fma{}{}{}", + ctx.id_result_writer(), + self.a.dis(ctx), + self.b.dis(ctx), + self.c.dis(ctx) ) } } @@ -1561,8 +1908,19 @@ impl InstEncoding for Frexp { exp: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Frexp{}{}", self.x.dis(_ctx), self.exp.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Frexp{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.exp.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1589,8 +1947,18 @@ impl InstEncoding for FrexpStruct { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "FrexpStruct{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}FrexpStruct{}", + ctx.id_result_writer(), + self.x.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1620,8 +1988,19 @@ impl InstEncoding for Ldexp { exp: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Ldexp{}{}", self.x.dis(_ctx), self.exp.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Ldexp{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.exp.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1648,8 +2027,18 @@ impl InstEncoding for PackSnorm4x8 { v: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "PackSnorm4x8{}", self.v.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}PackSnorm4x8{}", + ctx.id_result_writer(), + self.v.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1676,8 +2065,18 @@ impl InstEncoding for PackUnorm4x8 { v: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "PackUnorm4x8{}", self.v.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}PackUnorm4x8{}", + ctx.id_result_writer(), + self.v.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1704,8 +2103,18 @@ impl InstEncoding for PackSnorm2x16 { v: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "PackSnorm2x16{}", self.v.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}PackSnorm2x16{}", + ctx.id_result_writer(), + self.v.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1732,8 +2141,18 @@ impl InstEncoding for PackUnorm2x16 { v: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "PackUnorm2x16{}", self.v.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}PackUnorm2x16{}", + ctx.id_result_writer(), + self.v.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1760,8 +2179,18 @@ impl InstEncoding for PackHalf2x16 { v: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "PackHalf2x16{}", self.v.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}PackHalf2x16{}", + ctx.id_result_writer(), + self.v.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1788,8 +2217,18 @@ impl InstEncoding for PackDouble2x32 { v: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "PackDouble2x32{}", self.v.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}PackDouble2x32{}", + ctx.id_result_writer(), + self.v.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1816,8 +2255,18 @@ impl InstEncoding for UnpackSnorm2x16 { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "UnpackSnorm2x16{}", self.p.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}UnpackSnorm2x16{}", + ctx.id_result_writer(), + self.p.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1844,8 +2293,18 @@ impl InstEncoding for UnpackUnorm2x16 { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "UnpackUnorm2x16{}", self.p.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}UnpackUnorm2x16{}", + ctx.id_result_writer(), + self.p.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1872,8 +2331,18 @@ impl InstEncoding for UnpackHalf2x16 { v: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "UnpackHalf2x16{}", self.v.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}UnpackHalf2x16{}", + ctx.id_result_writer(), + self.v.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1900,8 +2369,18 @@ impl InstEncoding for UnpackSnorm4x8 { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "UnpackSnorm4x8{}", self.p.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}UnpackSnorm4x8{}", + ctx.id_result_writer(), + self.p.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1928,8 +2407,18 @@ impl InstEncoding for UnpackUnorm4x8 { p: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "UnpackUnorm4x8{}", self.p.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}UnpackUnorm4x8{}", + ctx.id_result_writer(), + self.p.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1956,8 +2445,18 @@ impl InstEncoding for UnpackDouble2x32 { v: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "UnpackDouble2x32{}", self.v.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}UnpackDouble2x32{}", + ctx.id_result_writer(), + self.v.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -1984,8 +2483,13 @@ impl InstEncoding for Length { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Length{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Length{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2015,8 +2519,19 @@ impl InstEncoding for Distance { p_1: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Distance{}{}", self.p_0.dis(_ctx), self.p_1.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Distance{}{}", + ctx.id_result_writer(), + self.p_0.dis(ctx), + self.p_1.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2046,8 +2561,19 @@ impl InstEncoding for Cross { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Cross{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Cross{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2074,8 +2600,13 @@ impl InstEncoding for Normalize { x: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Normalize{}", self.x.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!(f, "{}Normalize{}", ctx.id_result_writer(), self.x.dis(ctx)) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2111,13 +2642,19 @@ impl InstEncoding for FaceForward { nref: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "FaceForward{}{}{}", - self.n.dis(_ctx), - self.i.dis(_ctx), - self.nref.dis(_ctx) + "{}FaceForward{}{}{}", + ctx.id_result_writer(), + self.n.dis(ctx), + self.i.dis(ctx), + self.nref.dis(ctx) ) } } @@ -2148,8 +2685,19 @@ impl InstEncoding for Reflect { n: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "Reflect{}{}", self.i.dis(_ctx), self.n.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}Reflect{}{}", + ctx.id_result_writer(), + self.i.dis(ctx), + self.n.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2185,13 +2733,19 @@ impl InstEncoding for Refract { eta: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "Refract{}{}{}", - self.i.dis(_ctx), - self.n.dis(_ctx), - self.eta.dis(_ctx) + "{}Refract{}{}{}", + ctx.id_result_writer(), + self.i.dis(ctx), + self.n.dis(ctx), + self.eta.dis(ctx) ) } } @@ -2219,8 +2773,18 @@ impl InstEncoding for FindILsb { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "FindILsb{}", self.value.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}FindILsb{}", + ctx.id_result_writer(), + self.value.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2247,8 +2811,18 @@ impl InstEncoding for FindSMsb { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "FindSMsb{}", self.value.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}FindSMsb{}", + ctx.id_result_writer(), + self.value.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2275,8 +2849,18 @@ impl InstEncoding for FindUMsb { value: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "FindUMsb{}", self.value.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}FindUMsb{}", + ctx.id_result_writer(), + self.value.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2303,8 +2887,18 @@ impl InstEncoding for InterpolateAtCentroid { interpolant: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "InterpolateAtCentroid{}", self.interpolant.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}InterpolateAtCentroid{}", + ctx.id_result_writer(), + self.interpolant.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2336,12 +2930,18 @@ impl InstEncoding for InterpolateAtSample { sample: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "InterpolateAtSample{}{}", - self.interpolant.dis(_ctx), - self.sample.dis(_ctx) + "{}InterpolateAtSample{}{}", + ctx.id_result_writer(), + self.interpolant.dis(ctx), + self.sample.dis(ctx) ) } } @@ -2374,12 +2974,18 @@ impl InstEncoding for InterpolateAtOffset { offset: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "InterpolateAtOffset{}{}", - self.interpolant.dis(_ctx), - self.offset.dis(_ctx) + "{}InterpolateAtOffset{}{}", + ctx.id_result_writer(), + self.interpolant.dis(ctx), + self.offset.dis(ctx) ) } } @@ -2410,8 +3016,19 @@ impl InstEncoding for NMin { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "NMin{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}NMin{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2441,8 +3058,19 @@ impl InstEncoding for NMax { y: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { - write!(f, "NMax{}{}", self.x.dis(_ctx), self.y.dis(_ctx)) + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; + write!( + f, + "{}NMax{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.y.dis(ctx) + ) } } #[derive(Clone, Debug, Eq, PartialEq, Hash)] @@ -2478,13 +3106,19 @@ impl InstEncoding for NClamp { max_val: OperandEncoding::decode_last(&mut op_reader)?, }) } - fn dis_fmt(&self, f: &mut Formatter<'_>, _ctx: &DisContext) -> std::fmt::Result { + fn dis_fmt(&self, f: &mut Formatter<'_>, ctx: &DisContext) -> std::fmt::Result { + let ctx = &OperandDisContext { + id_result: None, + id_result_type: None, + ctx, + }; write!( f, - "NClamp{}{}{}", - self.x.dis(_ctx), - self.min_val.dis(_ctx), - self.max_val.dis(_ctx) + "{}NClamp{}{}{}", + ctx.id_result_writer(), + self.x.dis(ctx), + self.min_val.dis(ctx), + self.max_val.dis(ctx) ) } } diff --git a/crates/rspirv2/src/glsl_std_450/inst_set.rs b/crates/rspirv2/src/glsl_std_450/inst_set.rs index 9c423e0f..60af70b6 100644 --- a/crates/rspirv2/src/glsl_std_450/inst_set.rs +++ b/crates/rspirv2/src/glsl_std_450/inst_set.rs @@ -263,7 +263,7 @@ impl InstEncoding for GlslInstSet { 80u16 => Self::NMax(::decode(reader)?), 81u16 => Self::NClamp(::decode(reader)?), _ => { - return Err(DecodeError::UnknownOpCode { opcode }); + return Err(DecodeErrorKind::UnknownOpCode { opcode }.into()); } }) } diff --git a/crates/rspirv2/src/lib.rs b/crates/rspirv2/src/lib.rs index 050f981b..8264d44f 100644 --- a/crates/rspirv2/src/lib.rs +++ b/crates/rspirv2/src/lib.rs @@ -2,6 +2,7 @@ pub mod core; pub mod debug_printf; +pub mod dis; pub mod glsl_std_450; pub use rspirv2_types::*; diff --git a/crates/rspirv2/tests/dis.rs b/crates/rspirv2/tests/dis.rs index 24d7879c..1dbcec8a 100644 --- a/crates/rspirv2/tests/dis.rs +++ b/crates/rspirv2/tests/dis.rs @@ -1,40 +1,69 @@ -use rspirv2::core::inst::{OpLoad, OpTypeFloat}; -use rspirv2::core::operands::{CooperativeMatrixReduce, Dim}; +use expect_test::expect; +use rspirv2::core::inst::{OpLoad, OpPhi, OpSwitch, OpTypeFloat}; +use rspirv2::core::operands::{ + CooperativeMatrixReduce, Dim, PairIdRefIdRef, PairLiteralIntegerIdRef, +}; use rspirv2_types::binary::{IdResultAlloc, IdResultAllocator}; use rspirv2_types::dis::{DisContext, DisOptions}; use rspirv2_types::inst::InstEncoding; -use rspirv2_types::operand::{IdRef, IdResultType, LiteralInteger, OperandEncoding}; +use rspirv2_types::operand::{ + IdRef, IdResultType, LiteralInteger, OperandDisContext, OperandEncoding, +}; +use smallvec::SmallVec; #[test] pub fn test_dis_optional_operand() -> anyhow::Result<()> { - let ctx = DisContext::new(DisOptions::simple()); + let ctx = DisContext::no_context(DisOptions::simple()); let mut alloc = IdResultAllocator::default(); let float = OpTypeFloat { id_result: Some(alloc.alloc_id()?), width: LiteralInteger::new(32), floating_point_encoding: None, }; - assert_eq!("%0 = OpTypeFloat 32", float.dis(&ctx).to_string()); - let float = OpLoad { + expect!["%0 = OpTypeFloat 32"].assert_eq(&float.dis(&ctx).to_string()); + let load = OpLoad { id_result_type: IdResultType(float.id_result.unwrap()), id_result: Some(alloc.alloc_id()?), pointer: IdRef(alloc.alloc_id()?), memory_access: None, }; - assert_eq!("%1 = OpLoad %0 %2", float.dis(&ctx).to_string()); + expect!["%1 = OpLoad %0 %2"].assert_eq(&load.dis(&ctx).to_string()); + Ok(()) +} + +#[test] +pub fn test_dis_composite_types() -> anyhow::Result<()> { + let ctx = DisContext::no_context(DisOptions::simple()); + let mut alloc = IdResultAllocator::default(); + let switch = OpSwitch { + selector: IdRef(alloc.alloc_id()?), + default: IdRef(alloc.alloc_id()?), + target: SmallVec::from_iter([ + PairLiteralIntegerIdRef(LiteralInteger::new(42), IdRef(alloc.alloc_id()?)), + PairLiteralIntegerIdRef(LiteralInteger::new(69), IdRef(alloc.alloc_id()?)), + ]), + }; + expect!["OpSwitch %0 %1 42 %2 69 %3"].assert_eq(&switch.dis(&ctx).to_string()); + let phi = OpPhi { + id_result_type: IdResultType(alloc.alloc_id()?), + id_result: Some(alloc.alloc_id()?), + pair_id_ref_id_ref: SmallVec::from_iter([ + PairIdRefIdRef(IdRef(alloc.alloc_id()?), IdRef(alloc.alloc_id()?)), + PairIdRefIdRef(IdRef(alloc.alloc_id()?), IdRef(alloc.alloc_id()?)), + ]), + }; + expect!["%5 = OpPhi %4 %6 %7 %8 %9"].assert_eq(&phi.dis(&ctx).to_string()); Ok(()) } /// Symbols that have been renamed in `Enumerant::variant_ident` to be valid rust idents #[test] pub fn test_dis_renamed_symbols() -> anyhow::Result<()> { - let ctx = DisContext::new(DisOptions::simple()); - assert_eq!(" 1D", Dim::Dim1D.dis(&ctx).to_string()); - assert_eq!(" 2D", Dim::Dim2D.dis(&ctx).to_string()); - assert_eq!(" 3D", Dim::Dim3D.dis(&ctx).to_string()); - assert_eq!( - " 2x2", - CooperativeMatrixReduce::TwoByTwo.dis(&ctx).to_string() - ); + let ctx = DisContext::no_context(DisOptions::simple()); + let ctx = OperandDisContext::new(&ctx); + expect!(" 1D").assert_eq(&Dim::Dim1D.dis(&ctx).to_string()); + expect!(" 2D").assert_eq(&Dim::Dim2D.dis(&ctx).to_string()); + expect!(" 3D").assert_eq(&Dim::Dim3D.dis(&ctx).to_string()); + expect!(" 2x2").assert_eq(&CooperativeMatrixReduce::TwoByTwo.dis(&ctx).to_string()); Ok(()) } diff --git a/crates/rspirv2/tests/dis_color.rs b/crates/rspirv2/tests/dis_color.rs index 4a38db84..c2b5f2f3 100644 --- a/crates/rspirv2/tests/dis_color.rs +++ b/crates/rspirv2/tests/dis_color.rs @@ -16,7 +16,7 @@ pub fn test_disabled_color() -> anyhow::Result<()> { module.dis(DisOptions { color: true, ..Default::default() - })? + }) )?; let mut color_disabled = Vec::new(); @@ -26,7 +26,7 @@ pub fn test_disabled_color() -> anyhow::Result<()> { module.dis(DisOptions { color: false, ..Default::default() - })? + }) )?; assert_eq!( diff --git a/crates/rspirv2/tests/dis_invalid_inst.rs b/crates/rspirv2/tests/dis_invalid_inst.rs new file mode 100644 index 00000000..65c3ed66 --- /dev/null +++ b/crates/rspirv2/tests/dis_invalid_inst.rs @@ -0,0 +1,152 @@ +use expect_test::expect; +use rspirv2::core::inst::{OpName, OpNop, OpTypeInt, OpVariable}; +use rspirv2::core::inst_set::CoreInstSet; +use rspirv2::core::operands::StorageClass; +use rspirv2_types::Word; +use rspirv2_types::dis::{DisInstSlice, DisOptions}; +use rspirv2_types::inst::Inst; +use rspirv2_types::operand::{IdRef, IdResult, IdResultType, LiteralInteger, LiteralString}; +use rspirv2_types::slice::RawInstSlice; +use rspirv2_types::vec::InstVec; + +fn dis(raw: &RawInstSlice) -> String { + DisInstSlice::::new_no_context(raw, DisOptions::simple()).to_string() +} + +fn record_inst() -> InstVec { + let mut vec = InstVec::new(); + let id_u32 = IdResult(Word(42)); + let id_var = IdResult(Word(69)); + vec.push(OpTypeInt { + id_result: Some(id_u32), + width: LiteralInteger::new(32), + signedness: LiteralInteger::new(0), + }); + vec.push(OpName { + target: IdRef(id_var), + name: LiteralString::new("abcdef".to_string()), + }); + vec.push(OpVariable { + id_result_type: IdResultType(id_u32), + id_result: Some(id_var), + storage_class: StorageClass::StorageBuffer, + initializer: None, + }); + vec +} + +fn op_name_str_offset(words: &[Word]) -> usize { + words + .iter() + .enumerate() + .find(|(_, w)| **w == Word::from_le_bytes([b'a', b'b', b'c', b'd'])) + .unwrap() + .0 +} + +/// baseline is valid +#[test] +fn test_valid_dis() { + let words = record_inst().into_vec(); + expect![[r#" + %42 = OpTypeInt 32 0 + OpName %69 "abcdef" + %69 = OpVariable %42 StorageBuffer + "#]] + .assert_eq(&dis(RawInstSlice::from_words(&words))); +} + +/// even if one op fails to decode, as long as `op_len` is fine, we can jump over it and try to continue decoding +#[test] +fn test_no_null_term() { + let mut words = record_inst().into_vec(); + let str_offset = op_name_str_offset(&words); + words[str_offset + 1] = Word::from_le_bytes([b'e', b'f', b'g', b'h']); + expect![[r#" + %42 = OpTypeInt 32 0 + Error: String is not null-terminated. + %69 = OpVariable %42 StorageBuffer + "#]] + .assert_eq(&dis(RawInstSlice::from_words(&words))); +} + +/// even if one op fails to decode, as long as `op_len` is fine, we can jump over it and try to continue decoding +#[test] +fn test_shorter_str() { + let mut words = record_inst().into_vec(); + let str_offset = op_name_str_offset(&words); + words[str_offset] = Word::from_le_bytes([b'a', b'b', b'c', 0]); + words[str_offset + 1] = Word(0); + expect![[r#" + %42 = OpTypeInt 32 0 + Error: The fixed-size Instruction with 3 param words has 1 Words left over after decoding. + %69 = OpVariable %42 StorageBuffer + "#]] + .assert_eq(&dis(RawInstSlice::from_words(&words))); +} + +/// zero len op, no way to jump over inst, so stop the disassembly +#[test] +fn test_zero_len_op() { + let mut words = record_inst().into_vec(); + let str_offset = op_name_str_offset(&words); + words[str_offset - 2] = Word::new_op(OpName::META.opcode, 3).unwrap(); + words[str_offset] = Word::from_le_bytes([b'a', b'b', b'c', 0]); + words[str_offset + 1] = Word(0); + expect![[r#" + %42 = OpTypeInt 32 0 + OpName %69 "abc" + Error: Instruction at offset 7: Instruction has an invalid length of 0, must be least 1 word as it includes the opcode itself. + "#]] + .assert_eq(&dis(RawInstSlice::from_words(&words))); +} + +/// replacing with `OpNop` is not zeroing out the word, but replacing it with `0x10000` +#[test] +fn test_replace_nop() { + let mut words = record_inst().into_vec(); + let str_offset = op_name_str_offset(&words); + words[str_offset - 2] = Word::new_op(OpName::META.opcode, 3).unwrap(); + words[str_offset] = Word::from_le_bytes([b'a', b'b', b'c', 0]); + words[str_offset + 1] = Word::new_op(OpNop::META.opcode, 1).unwrap(); + expect![[r#" + %42 = OpTypeInt 32 0 + OpName %69 "abc" + OpNop + %69 = OpVariable %42 StorageBuffer + "#]] + .assert_eq(&dis(RawInstSlice::from_words(&words))); +} + +/// op longer than remaining words, no way to jump over inst, so stop the disassembly +#[test] +fn test_too_long_op() { + let mut words = record_inst().into_vec(); + let str_offset = op_name_str_offset(&words); + words[str_offset - 2] = Word::new_op(OpName::META.opcode, 0xDEAD).unwrap(); + expect![[r#" + %42 = OpTypeInt 32 0 + Error: Instruction at offset 4: Instruction has a supposed length of 57005 but the module only has 8 words remaining. + "#]] + .assert_eq(&dis(RawInstSlice::from_words(&words))); +} + +/// the string is longer than the instruction length: +/// * first string fails to decode +/// * then the remaining string is interpreted as a garbage opcode word, manipulated here to be of length 2, +/// fails due to unknown opcode +/// * jumps to `OpVariable + 1` and reinterprets the `IdResult` into a garbage opcode word of 0 length +#[test] +fn test_op_shorter_than_string() { + let mut words = record_inst().into_vec(); + let str_offset = op_name_str_offset(&words); + words[str_offset - 2] = Word::new_op(OpName::META.opcode, 3).unwrap(); + words[str_offset + 1] = Word::from_le_bytes([b'e', b'f', 2, 0]); + expect![[r#" + %42 = OpTypeInt 32 0 + Error: String is not null-terminated. + Error: Instruction Set couldn't decode instruction with unknown opcode 26213 + Error: Instruction at offset 9: Instruction has an invalid length of 0, must be least 1 word as it includes the opcode itself. + "#]] + .assert_eq(&dis(RawInstSlice::from_words(&words))); +} diff --git a/crates/tools-gen/src/dis.rs b/crates/tools-gen/src/dis.rs index f41e8303..8277aa60 100644 --- a/crates/tools-gen/src/dis.rs +++ b/crates/tools-gen/src/dis.rs @@ -1,8 +1,7 @@ use clap::{Parser, ValueEnum}; -use rspirv2::dis::DisOptions; -use rspirv2::inst::InstEncoding; +use rspirv2::dis::{DisOptions, InstSetDisCtx}; use rspirv2::module::Module; -use std::io::Write; +use std::io::{BufWriter, Write}; use std::path::PathBuf; #[derive(Clone, Debug, Default, Parser)] @@ -10,41 +9,79 @@ pub struct Args { /// path to SPIR-V file path: PathBuf, /// Emit disassembly like as if it was emitted by this tool - #[clap(short, long)] - like: Like, + #[arg(short, long, default_value_t)] + profile: Profile, + /// color + #[clap(long, default_value_t)] + color: clap::ColorChoice, /// Swap bytes of the SPIR-V module before parsing, for testing #[clap(skip)] module_swap_bytes: bool, } #[derive(Clone, Debug, Default, ValueEnum)] -pub enum Like { +pub enum Profile { #[default] Default, Rspirv, SpirvTools, } +impl std::fmt::Display for Profile { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + self.to_possible_value() + .expect("no values are skipped") + .get_name() + .fmt(f) + } +} + +impl Args { + pub fn resolve_auto_color(&mut self, stream: &impl anstream::stream::RawStream) { + if self.color == clap::ColorChoice::Auto { + self.color = match anstream::AutoStream::choice(stream) { + anstream::ColorChoice::Auto => unreachable!(), + anstream::ColorChoice::AlwaysAnsi | anstream::ColorChoice::Always => { + clap::ColorChoice::Always + } + anstream::ColorChoice::Never => clap::ColorChoice::Never, + } + } + } +} + impl Args { - pub fn run(&self, stdout: &mut impl Write) -> anyhow::Result<()> { - let mut slice = std::fs::read(&self.path)?; + pub fn run( + &mut self, + stdout: &mut impl anstream::stream::RawStream, + ) -> anyhow::Result<()> { + self.resolve_auto_color(&*stdout); + let mut writer = BufWriter::new(stdout); + self.run_inner::(&mut writer) + } + + pub fn run_inner(&self, stdout: &mut impl Write) -> anyhow::Result<()> { + let mut bytes = std::fs::read(&self.path)?; if self.module_swap_bytes { - for chunk in slice.as_chunks_mut::<4>().0.iter_mut() { + for chunk in bytes.as_chunks_mut::<4>().0.iter_mut() { *chunk = u32::from_ne_bytes(*chunk).swap_bytes().to_ne_bytes(); } } - let module = Module::::from_bytes(slice.as_slice())?; - write!(stdout, "{}", module.dis(self.to_dis_opts()?)?)?; + let module = Module::::from_bytes_unchecked(bytes.as_slice())?; + drop(bytes); + let dis = module.inst.as_raw_slice().dis::(self.to_dis_opts()?); + write!(stdout, "{}", dis)?; Ok(()) } pub fn to_dis_opts(&self) -> anyhow::Result { - let opt = match self.like { - Like::Default => DisOptions::default(), - Like::Rspirv => DisOptions::like_rspirv(), - Like::SpirvTools => DisOptions::like_spirv_tools(), + let mut opt = match self.profile { + Profile::Default => DisOptions::default(), + Profile::Rspirv => DisOptions::like_rspirv(), + Profile::SpirvTools => DisOptions::like_spirv_tools(), }; + opt.color = matches!(self.color, clap::ColorChoice::Always); Ok(opt) } } @@ -70,7 +107,7 @@ pub mod test { fn test_dis_reference_default() -> anyhow::Result<()> { test_dis_reference( expect_file!["../../../spv/dis_reference.rspirv2"], - Like::Default, + Profile::Default, false, ) } @@ -79,7 +116,7 @@ pub mod test { fn test_dis_reference_default_be() -> anyhow::Result<()> { test_dis_reference( expect_file!["../../../spv/dis_reference.rspirv2"], - Like::Default, + Profile::Default, true, ) } @@ -88,7 +125,7 @@ pub mod test { fn test_dis_reference_rspirv() -> anyhow::Result<()> { test_dis_reference( expect_file!["../../../spv/dis_reference.rspirv_like"], - Like::Rspirv, + Profile::Rspirv, false, ) } @@ -97,7 +134,7 @@ pub mod test { fn test_dis_reference_rspirv_be() -> anyhow::Result<()> { test_dis_reference( expect_file!["../../../spv/dis_reference.rspirv_like"], - Like::Rspirv, + Profile::Rspirv, true, ) } @@ -106,7 +143,7 @@ pub mod test { fn test_dis_reference_spirv_tools() -> anyhow::Result<()> { test_dis_reference( expect_file!["../../../spv/dis_reference.spirv_tools_like"], - Like::SpirvTools, + Profile::SpirvTools, false, ) } @@ -115,23 +152,24 @@ pub mod test { fn test_dis_reference_spirv_tools_be() -> anyhow::Result<()> { test_dis_reference( expect_file!["../../../spv/dis_reference.spirv_tools_like"], - Like::SpirvTools, + Profile::SpirvTools, true, ) } fn test_dis_reference( expect: ExpectFile, - like: Like, + profile: Profile, module_swap_bytes: bool, ) -> anyhow::Result<()> { let args = Args { path: spv("dis_reference"), - like, + profile, module_swap_bytes, + color: clap::ColorChoice::Never, }; let mut stdout = Vec::new(); - args.run::(&mut anstream::AutoStream::never(&mut stdout))?; + args.run_inner::(&mut stdout)?; let stdout = String::from_utf8(stdout)?; expect.assert_eq(&stdout); Ok(()) diff --git a/crates/tools/src/bin/dis.rs b/crates/tools/src/bin/dis.rs index 30d7cc1e..26202b85 100644 --- a/crates/tools/src/bin/dis.rs +++ b/crates/tools/src/bin/dis.rs @@ -2,5 +2,5 @@ use clap::Parser; use rspirv2_tools::ToolsISA; pub fn main() -> anyhow::Result<()> { - rspirv2_tools_gen::dis::Args::parse().run::(&mut anstream::stdout().lock()) + rspirv2_tools_gen::dis::Args::parse().run::(&mut std::io::stdout().lock()) } diff --git a/spv/dis_reference.rspirv2 b/spv/dis_reference.rspirv2 index 5964e2dd..36bbf3bc 100644 --- a/spv/dis_reference.rspirv2 +++ b/spv/dis_reference.rspirv2 @@ -1,11 +1,11 @@ -OpCapability Shader -OpCapability StorageImageWriteWithoutFormat -OpCapability VulkanMemoryModel -OpMemoryModel Logical Vulkan -OpEntryPoint GLCompute %1 "main" %2 %3 %4 -OpExecutionMode %1 LocalSize 32 1 1 -%5 = OpString "ui/dis_reference.rs" -OpSource Unknown 0 %5 "// compile-flags: -C target-feature=+StorageImageWriteWithoutFormat + OpCapability Shader + OpCapability StorageImageWriteWithoutFormat + OpCapability VulkanMemoryModel + OpMemoryModel Logical Vulkan + OpEntryPoint GLCompute %1 "main" %tid %offset_buffer %output_buffer + OpExecutionMode %1 LocalSize 32 1 1 + %5 = OpString "ui/dis_reference.rs" + OpSource Unknown 0 %5 "// compile-flags: -C target-feature=+StorageImageWriteWithoutFormat // compile-flags: -C llvm-args=--disassemble // normalize-stderr-test \"OpSource .*\\n\" -> \"\" // normalize-stderr-test \"OpLine .*\\n\" -> \"\" @@ -75,94 +75,94 @@ pub unsafe fn atomic_i_add( } } " -OpName %2 "tid" -OpName %3 "offset_buffer" -OpName %4 "output_buffer" -OpName %6 "dis_reference::compute_offset" -OpDecorate %7 ArrayStride 4 -OpDecorate %8 Block -OpMemberDecorate %8 0 Offset 0 -OpDecorate %9 Block -OpMemberDecorate %9 0 Offset 0 -OpDecorate %2 BuiltIn LocalInvocationId -OpDecorate %3 NonWritable -OpDecorate %3 Binding 42 -OpDecorate %3 DescriptorSet 0 -OpDecorate %4 Binding 69 -OpDecorate %4 DescriptorSet 1 -%10 = OpTypeInt 32 0 -%11 = OpTypeVector %10 3 -%12 = OpTypePointer Input %11 -%7 = OpTypeRuntimeArray %10 -%8 = OpTypeStruct %7 -%13 = OpTypePointer StorageBuffer %8 -%9 = OpTypeStruct %10 -%14 = OpTypePointer StorageBuffer %9 -%15 = OpTypeFloat 32 -%16 = OpTypeVoid -%17 = OpTypeFunction %16 -%2 = OpVariable %12 Input -%18 = OpTypePointer StorageBuffer %7 -%3 = OpVariable %13 StorageBuffer -%19 = OpConstant %10 0 -%20 = OpTypePointer StorageBuffer %10 -%4 = OpVariable %14 StorageBuffer -%21 = OpTypeFunction %10 %10 -%22 = OpConstant %10 1 -%23 = OpTypeBool -%24 = OpConstant %15 1071225242 -%25 = OpConstant %10 1333788671 -%26 = OpConstant %10 4294967295 -%27 = OpConstant %10 5 -%28 = OpConstant %10 25096 -%1 = OpFunction %16 None %17 -%29 = OpLabel -OpLine %5 24 4 -%30 = OpLoad %11 %2 -OpLine %5 25 4 -%31 = OpInBoundsAccessChain %18 %3 %19 -%32 = OpArrayLength %10 %3 0 -OpLine %5 26 4 -%33 = OpInBoundsAccessChain %20 %4 %19 -OpLine %5 30 36 -%34 = OpCompositeExtract %10 %30 0 -OpLine %5 30 21 -%35 = OpFunctionCall %10 %6 %34 -OpLine %5 31 26 -%36 = OpULessThan %23 %35 %32 -OpNoLine -OpSelectionMerge %37 None -OpBranchConditional %36 %38 %39 -%38 = OpLabel -OpBranch %37 -%39 = OpLabel -OpReturn -%37 = OpLabel -OpLine %5 31 26 -%40 = OpIAdd %10 %19 %35 -%41 = OpInBoundsAccessChain %20 %31 %40 -%42 = OpLoad %10 %41 -OpLine %5 32 21 -%43 = OpConvertUToF %15 %42 -OpLine %5 32 20 -%44 = OpFMul %15 %43 %24 -%45 = OpBitcast %15 %19 -%46 = OpBitcast %15 %25 -%47 = OpConvertFToU %10 %44 -%48 = OpFUnordLessThan %23 %44 %45 -%49 = OpFOrdGreaterThan %23 %44 %46 -%50 = OpSelect %10 %48 %19 %47 -%51 = OpSelect %10 %49 %26 %50 -OpLine %5 59 13 -%52 = OpAtomicIAdd %10 %33 %27 %28 %51 -OpNoLine -OpReturn -OpFunctionEnd -%6 = OpFunction %10 DontInline|Const %21 -%53 = OpFunctionParameter %10 -%54 = OpLabel -OpLine %5 43 4 -%55 = OpIAdd %10 %22 %53 -OpNoLine -OpReturnValue %55 -OpFunctionEnd + OpName %tid "tid" + OpName %offset_buffer "offset_buffer" + OpName %output_buffer "output_buffer" + OpName %dis_reference__compute_offset "dis_reference::compute_offset" + OpDecorate %_runtimearr_u32 ArrayStride 4 + OpDecorate %_struct_8 Block + OpMemberDecorate %_struct_8 0 Offset 0 + OpDecorate %_struct_9 Block + OpMemberDecorate %_struct_9 0 Offset 0 + OpDecorate %tid BuiltIn LocalInvocationId + OpDecorate %offset_buffer NonWritable + OpDecorate %offset_buffer Binding 42 + OpDecorate %offset_buffer DescriptorSet 0 + OpDecorate %output_buffer Binding 69 + OpDecorate %output_buffer DescriptorSet 1 + %u32 = OpTypeInt 32 0 + %v3u32 = OpTypeVector %u32 3 +%_ptr_Input_v3u32 = OpTypePointer Input %v3u32 +%_runtimearr_u32 = OpTypeRuntimeArray %u32 + %_struct_8 = OpTypeStruct %_runtimearr_u32 +%_ptr_StorageBuffer__struct_8 = OpTypePointer StorageBuffer %_struct_8 + %_struct_9 = OpTypeStruct %u32 +%_ptr_StorageBuffer__struct_9 = OpTypePointer StorageBuffer %_struct_9 + %f32 = OpTypeFloat 32 + %void = OpTypeVoid + %17 = OpTypeFunction %void + %tid = OpVariable %_ptr_Input_v3u32 Input +%_ptr_StorageBuffer__runtimearr_u32 = OpTypePointer StorageBuffer %_runtimearr_u32 +%offset_buffer = OpVariable %_ptr_StorageBuffer__struct_8 StorageBuffer + %u32_0 = OpConstant %u32 0 +%_ptr_StorageBuffer_u32 = OpTypePointer StorageBuffer %u32 +%output_buffer = OpVariable %_ptr_StorageBuffer__struct_9 StorageBuffer + %21 = OpTypeFunction %u32 %u32 + %u32_1 = OpConstant %u32 1 + %bool = OpTypeBool + %f32_1_7 = OpConstant %f32 1.7 +%u32_1333788671 = OpConstant %u32 1333788671 +%u32_4294967295 = OpConstant %u32 4294967295 + %u32_5 = OpConstant %u32 5 + %u32_25096 = OpConstant %u32 25096 + %1 = OpFunction %void None %17 + %29 = OpLabel + OpLine %5 24 4 + %30 = OpLoad %v3u32 %tid + OpLine %5 25 4 + %31 = OpInBoundsAccessChain %_ptr_StorageBuffer__runtimearr_u32 %offset_buffer %u32_0 + %32 = OpArrayLength %u32 %offset_buffer 0 + OpLine %5 26 4 + %33 = OpInBoundsAccessChain %_ptr_StorageBuffer_u32 %output_buffer %u32_0 + OpLine %5 30 36 + %34 = OpCompositeExtract %u32 %30 0 + OpLine %5 30 21 + %35 = OpFunctionCall %u32 %dis_reference__compute_offset %34 + OpLine %5 31 26 + %36 = OpULessThan %bool %35 %32 + OpNoLine + OpSelectionMerge %37 None + OpBranchConditional %36 %38 %39 + %38 = OpLabel + OpBranch %37 + %39 = OpLabel + OpReturn + %37 = OpLabel + OpLine %5 31 26 + %40 = OpIAdd %u32 %u32_0 %35 + %41 = OpInBoundsAccessChain %_ptr_StorageBuffer_u32 %31 %40 + %42 = OpLoad %u32 %41 + OpLine %5 32 21 + %43 = OpConvertUToF %f32 %42 + OpLine %5 32 20 + %44 = OpFMul %f32 %43 %f32_1_7 + %45 = OpBitcast %f32 %u32_0 + %46 = OpBitcast %f32 %u32_1333788671 + %47 = OpConvertFToU %u32 %44 + %48 = OpFUnordLessThan %bool %44 %45 + %49 = OpFOrdGreaterThan %bool %44 %46 + %50 = OpSelect %u32 %48 %u32_0 %47 + %51 = OpSelect %u32 %49 %u32_4294967295 %50 + OpLine %5 59 13 + %52 = OpAtomicIAdd %u32 %33 %u32_5 %u32_25096 %51 + OpNoLine + OpReturn + OpFunctionEnd +%dis_reference__compute_offset = OpFunction %u32 DontInline|Const %21 + %53 = OpFunctionParameter %u32 + %54 = OpLabel + OpLine %5 43 4 + %55 = OpIAdd %u32 %u32_1 %53 + OpNoLine + OpReturnValue %55 + OpFunctionEnd diff --git a/spv/dis_reference.rspirv_like b/spv/dis_reference.rspirv_like index f838124e..13b1ab50 100644 --- a/spv/dis_reference.rspirv_like +++ b/spv/dis_reference.rspirv_like @@ -41,7 +41,7 @@ OpDecorate %4 DescriptorSet 1 %21 = OpTypeFunction %10 %10 %22 = OpConstant %10 1 %23 = OpTypeBool -%24 = OpConstant %15 1071225242 +%24 = OpConstant %15 1.7 %25 = OpConstant %10 1333788671 %26 = OpConstant %10 4294967295 %27 = OpConstant %10 5 diff --git a/spv/dis_reference.spirv_tools_like b/spv/dis_reference.spirv_tools_like index 5964e2dd..361f75a6 100644 --- a/spv/dis_reference.spirv_tools_like +++ b/spv/dis_reference.spirv_tools_like @@ -1,11 +1,11 @@ -OpCapability Shader -OpCapability StorageImageWriteWithoutFormat -OpCapability VulkanMemoryModel -OpMemoryModel Logical Vulkan -OpEntryPoint GLCompute %1 "main" %2 %3 %4 -OpExecutionMode %1 LocalSize 32 1 1 -%5 = OpString "ui/dis_reference.rs" -OpSource Unknown 0 %5 "// compile-flags: -C target-feature=+StorageImageWriteWithoutFormat + OpCapability Shader + OpCapability StorageImageWriteWithoutFormat + OpCapability VulkanMemoryModel + OpMemoryModel Logical Vulkan + OpEntryPoint GLCompute %1 "main" %tid %offset_buffer %output_buffer + OpExecutionMode %1 LocalSize 32 1 1 + %5 = OpString "ui/dis_reference.rs" + OpSource Unknown 0 %5 "// compile-flags: -C target-feature=+StorageImageWriteWithoutFormat // compile-flags: -C llvm-args=--disassemble // normalize-stderr-test \"OpSource .*\\n\" -> \"\" // normalize-stderr-test \"OpLine .*\\n\" -> \"\" @@ -75,94 +75,94 @@ pub unsafe fn atomic_i_add( } } " -OpName %2 "tid" -OpName %3 "offset_buffer" -OpName %4 "output_buffer" -OpName %6 "dis_reference::compute_offset" -OpDecorate %7 ArrayStride 4 -OpDecorate %8 Block -OpMemberDecorate %8 0 Offset 0 -OpDecorate %9 Block -OpMemberDecorate %9 0 Offset 0 -OpDecorate %2 BuiltIn LocalInvocationId -OpDecorate %3 NonWritable -OpDecorate %3 Binding 42 -OpDecorate %3 DescriptorSet 0 -OpDecorate %4 Binding 69 -OpDecorate %4 DescriptorSet 1 -%10 = OpTypeInt 32 0 -%11 = OpTypeVector %10 3 -%12 = OpTypePointer Input %11 -%7 = OpTypeRuntimeArray %10 -%8 = OpTypeStruct %7 -%13 = OpTypePointer StorageBuffer %8 -%9 = OpTypeStruct %10 -%14 = OpTypePointer StorageBuffer %9 -%15 = OpTypeFloat 32 -%16 = OpTypeVoid -%17 = OpTypeFunction %16 -%2 = OpVariable %12 Input -%18 = OpTypePointer StorageBuffer %7 -%3 = OpVariable %13 StorageBuffer -%19 = OpConstant %10 0 -%20 = OpTypePointer StorageBuffer %10 -%4 = OpVariable %14 StorageBuffer -%21 = OpTypeFunction %10 %10 -%22 = OpConstant %10 1 -%23 = OpTypeBool -%24 = OpConstant %15 1071225242 -%25 = OpConstant %10 1333788671 -%26 = OpConstant %10 4294967295 -%27 = OpConstant %10 5 -%28 = OpConstant %10 25096 -%1 = OpFunction %16 None %17 -%29 = OpLabel -OpLine %5 24 4 -%30 = OpLoad %11 %2 -OpLine %5 25 4 -%31 = OpInBoundsAccessChain %18 %3 %19 -%32 = OpArrayLength %10 %3 0 -OpLine %5 26 4 -%33 = OpInBoundsAccessChain %20 %4 %19 -OpLine %5 30 36 -%34 = OpCompositeExtract %10 %30 0 -OpLine %5 30 21 -%35 = OpFunctionCall %10 %6 %34 -OpLine %5 31 26 -%36 = OpULessThan %23 %35 %32 -OpNoLine -OpSelectionMerge %37 None -OpBranchConditional %36 %38 %39 -%38 = OpLabel -OpBranch %37 -%39 = OpLabel -OpReturn -%37 = OpLabel -OpLine %5 31 26 -%40 = OpIAdd %10 %19 %35 -%41 = OpInBoundsAccessChain %20 %31 %40 -%42 = OpLoad %10 %41 -OpLine %5 32 21 -%43 = OpConvertUToF %15 %42 -OpLine %5 32 20 -%44 = OpFMul %15 %43 %24 -%45 = OpBitcast %15 %19 -%46 = OpBitcast %15 %25 -%47 = OpConvertFToU %10 %44 -%48 = OpFUnordLessThan %23 %44 %45 -%49 = OpFOrdGreaterThan %23 %44 %46 -%50 = OpSelect %10 %48 %19 %47 -%51 = OpSelect %10 %49 %26 %50 -OpLine %5 59 13 -%52 = OpAtomicIAdd %10 %33 %27 %28 %51 -OpNoLine -OpReturn -OpFunctionEnd -%6 = OpFunction %10 DontInline|Const %21 -%53 = OpFunctionParameter %10 -%54 = OpLabel -OpLine %5 43 4 -%55 = OpIAdd %10 %22 %53 -OpNoLine -OpReturnValue %55 -OpFunctionEnd + OpName %tid "tid" + OpName %offset_buffer "offset_buffer" + OpName %output_buffer "output_buffer" + OpName %dis_reference__compute_offset "dis_reference::compute_offset" + OpDecorate %_runtimearr_uint ArrayStride 4 + OpDecorate %_struct_8 Block + OpMemberDecorate %_struct_8 0 Offset 0 + OpDecorate %_struct_9 Block + OpMemberDecorate %_struct_9 0 Offset 0 + OpDecorate %tid BuiltIn LocalInvocationId + OpDecorate %offset_buffer NonWritable + OpDecorate %offset_buffer Binding 42 + OpDecorate %offset_buffer DescriptorSet 0 + OpDecorate %output_buffer Binding 69 + OpDecorate %output_buffer DescriptorSet 1 + %uint = OpTypeInt 32 0 + %v3uint = OpTypeVector %uint 3 +%_ptr_Input_v3uint = OpTypePointer Input %v3uint +%_runtimearr_uint = OpTypeRuntimeArray %uint + %_struct_8 = OpTypeStruct %_runtimearr_uint +%_ptr_StorageBuffer__struct_8 = OpTypePointer StorageBuffer %_struct_8 + %_struct_9 = OpTypeStruct %uint +%_ptr_StorageBuffer__struct_9 = OpTypePointer StorageBuffer %_struct_9 + %float = OpTypeFloat 32 + %void = OpTypeVoid + %17 = OpTypeFunction %void + %tid = OpVariable %_ptr_Input_v3uint Input +%_ptr_StorageBuffer__runtimearr_uint = OpTypePointer StorageBuffer %_runtimearr_uint +%offset_buffer = OpVariable %_ptr_StorageBuffer__struct_8 StorageBuffer + %uint_0 = OpConstant %uint 0 +%_ptr_StorageBuffer_uint = OpTypePointer StorageBuffer %uint +%output_buffer = OpVariable %_ptr_StorageBuffer__struct_9 StorageBuffer + %21 = OpTypeFunction %uint %uint + %uint_1 = OpConstant %uint 1 + %bool = OpTypeBool + %float_1_7 = OpConstant %float 1.7 +%uint_1333788671 = OpConstant %uint 1333788671 +%uint_4294967295 = OpConstant %uint 4294967295 + %uint_5 = OpConstant %uint 5 + %uint_25096 = OpConstant %uint 25096 + %1 = OpFunction %void None %17 + %29 = OpLabel + OpLine %5 24 4 + %30 = OpLoad %v3uint %tid + OpLine %5 25 4 + %31 = OpInBoundsAccessChain %_ptr_StorageBuffer__runtimearr_uint %offset_buffer %uint_0 + %32 = OpArrayLength %uint %offset_buffer 0 + OpLine %5 26 4 + %33 = OpInBoundsAccessChain %_ptr_StorageBuffer_uint %output_buffer %uint_0 + OpLine %5 30 36 + %34 = OpCompositeExtract %uint %30 0 + OpLine %5 30 21 + %35 = OpFunctionCall %uint %dis_reference__compute_offset %34 + OpLine %5 31 26 + %36 = OpULessThan %bool %35 %32 + OpNoLine + OpSelectionMerge %37 None + OpBranchConditional %36 %38 %39 + %38 = OpLabel + OpBranch %37 + %39 = OpLabel + OpReturn + %37 = OpLabel + OpLine %5 31 26 + %40 = OpIAdd %uint %uint_0 %35 + %41 = OpInBoundsAccessChain %_ptr_StorageBuffer_uint %31 %40 + %42 = OpLoad %uint %41 + OpLine %5 32 21 + %43 = OpConvertUToF %float %42 + OpLine %5 32 20 + %44 = OpFMul %float %43 %float_1_7 + %45 = OpBitcast %float %uint_0 + %46 = OpBitcast %float %uint_1333788671 + %47 = OpConvertFToU %uint %44 + %48 = OpFUnordLessThan %bool %44 %45 + %49 = OpFOrdGreaterThan %bool %44 %46 + %50 = OpSelect %uint %48 %uint_0 %47 + %51 = OpSelect %uint %49 %uint_4294967295 %50 + OpLine %5 59 13 + %52 = OpAtomicIAdd %uint %33 %uint_5 %uint_25096 %51 + OpNoLine + OpReturn + OpFunctionEnd +%dis_reference__compute_offset = OpFunction %uint DontInline|Const %21 + %53 = OpFunctionParameter %uint + %54 = OpLabel + OpLine %5 43 4 + %55 = OpIAdd %uint %uint_1 %53 + OpNoLine + OpReturnValue %55 + OpFunctionEnd