Support 64-bit OpSwitch literals

crates/grammar-parser/src/codegen/instructions.rs

@@ -3,6 +3,9 @@ use crate::codegen::{GrammarWriter, OPERAND_ID_RESULT, OPERAND_ID_RESULT_TYPE};
 use crate::parse::{Grammar, InstMeta, Operand, Quantifier};
 use quote::{format_ident, quote};
 
+const OP_SWITCH: &str = "OpSwitch";
+const OPERAND_PAIR_LITERAL_INTEGER_ID_REF: &str = "PairLiteralIntegerIdRef";
+
 pub fn write_inst(writer: &mut GrammarWriter, grammar: &Grammar<'_>) -> anyhow::Result<()> {
     let insts = grammar.insts.iter().map(|inst| {
         let struct_ident = InstMeta::type_ident(&inst.opname);
@@ -25,10 +28,15 @@ pub fn write_inst(writer: &mut GrammarWriter, grammar: &Grammar<'_>) -> anyhow::
                  meta,
                  ref name,
                  ref ty,
-             }| match meta.quantifier {
-                Quantifier::One => quote!(pub #name: #ty),
-                Quantifier::ZeroOrOne => quote!(pub #name: ZeroOrOne<#ty>),
-                Quantifier::ZeroOrMore => quote!(pub #name: ZeroOrMore<#ty>),
+             }| {
+                if is_op_switch_targets(inst.opname.as_ref(), meta.kind.as_ref(), meta.quantifier) {
+                    return quote!(pub #name: SwitchTargets);
+                }
+                match meta.quantifier {
+                    Quantifier::One => quote!(pub #name: #ty),
+                    Quantifier::ZeroOrOne => quote!(pub #name: ZeroOrOne<#ty>),
+                    Quantifier::ZeroOrMore => quote!(pub #name: ZeroOrMore<#ty>),
+                }
             },
         );
 
@@ -157,6 +165,12 @@ pub fn write_inst(writer: &mut GrammarWriter, grammar: &Grammar<'_>) -> anyhow::
     )
 }
 
+fn is_op_switch_targets(opname: &str, operand_kind: &str, quantifier: Quantifier) -> bool {
+    opname == OP_SWITCH
+        && operand_kind == OPERAND_PAIR_LITERAL_INTEGER_ID_REF
+        && quantifier == Quantifier::ZeroOrMore
+}
+
 pub fn write_inst_enum(
     writer: &mut GrammarWriter,
     grammar: &Grammar<'_>,

crates/grammar-parser/src/lib.rs

@@ -6,5 +6,7 @@ pub mod timer;
 #[cfg(feature = "codegen")]
 pub mod codegen;
 
+#[cfg(feature = "codegen")]
 pub use proc_macro2;
+#[cfg(feature = "codegen")]
 pub use quote;

crates/rspirv2-types/src/binary/decode_error.rs

@@ -38,6 +38,9 @@ pub enum DecodeErrorKind {
         op_len: usize,
         expected_multiple: usize,
     },
+    InvalidSwitchTargets {
+        word_len: usize,
+    },
     InstructionTooLong {
         op_len: usize,
         module_remaining: usize,
@@ -111,6 +114,10 @@ impl Display for DecodeErrorKind {
                 "The variable-sized Instruction has an unexpected operand length {op_len} \
                 which was expected to be a multiple of {expected_multiple}."
             ),
+            Self::InvalidSwitchTargets { word_len } => write!(
+                f,
+                "OpSwitch target table has {word_len} words, which is neither valid 32-bit nor 64-bit case encoding."
+            ),
             Self::InstructionTooLong {
                 op_len,
                 module_remaining,

crates/rspirv2-types/src/operand/mod.rs

@@ -4,6 +4,7 @@ mod literal_float;
 mod literal_integer;
 mod literal_string;
 mod parameterized_bitmask;
+mod switch;
 mod tuple;
 
 use crate::binary::{
@@ -20,6 +21,7 @@ pub use parameterized_bitmask::*;
 use smallvec::SmallVec;
 use std::fmt::{Debug, Display, Formatter};
 use std::ops::Deref;
+pub use switch::*;
 pub use tuple::*;
 
 /// A SPIR-V operand. The associated const [`Self::KIND`] links to it's [`OperandKind`].
@@ -126,10 +128,14 @@ pub unsafe trait OperandEncoding: Sized + Debug {
     /// Disassemble this operand
     ///
     /// Returns a type that impl [`Display`], so it's usable with `format!`:
-    /// ```no_run
-    /// # use rspirv2_types::operand::IdResult;
+    /// ```
+    /// # use rspirv2_types::Word;
+    /// # use rspirv2_types::dis::{DisContext, DisOptions};
+    /// # use rspirv2_types::operand::{IdResult, OperandDisContext, OperandEncoding};
+    /// let ctx = DisContext::no_context(DisOptions::simple());
+    /// let ctx = OperandDisContext::new(&ctx);
     /// let my_op = IdResult(Word(42));
-    /// let dis = format!("OpMyInst {}", my_op.dis());
+    /// let dis = format!("OpMyInst {}", my_op.dis(&ctx));
     /// assert_eq!(dis, "OpMyInst %42");
     /// ```
     #[inline]