spv: minimal OpSpecConstantOp support.

eddyb · eddyb · commit 301b711926e5 · 2025-09-24T19:17:51.000+03:00
diff --git a/src/print/mod.rs b/src/print/mod.rs
@@ -1803,7 +1803,7 @@ impl Printer<'_> {
     fn sanitize_spv_operand_name<'b>(&self, name: &'b str) -> Option<Cow<'b, str>> {
         Some(name).and_then(|name| {
             // HACK(eddyb) some operand names are useless.
-            if name == "Type"
+            if matches!(name, "Opcode" | "Operand" | "Type")
                 || name
                     .strip_prefix("Operand ")
                     .is_some_and(|s| s.chars().all(|c| c.is_ascii_digit()))
diff --git a/src/spv/print.rs b/src/spv/print.rs
@@ -77,6 +77,9 @@ impl TokensForOperand<String> {
 
 // FIXME(eddyb) keep a `&'static spec::Spec` if that can even speed up anything.
 struct OperandPrinter<IMMS: Iterator<Item = spv::Imm>, ID, IDS: Iterator<Item = ID>> {
+    // FIXME(eddyb) use a field like this to interpret `Opcode`/`OperandKind`, too.
+    wk: &'static spv::spec::WellKnown,
+
     /// Input immediate operands to print from (may be grouped e.g. into literals).
     imms: iter::Peekable<IMMS>,
 
@@ -123,7 +126,41 @@ impl<IMMS: Iterator<Item = spv::Imm>, ID, IDS: Iterator<Item = ID>> OperandPrint
         let def = kind.def();
         assert!(matches!(def, spec::OperandKindDef::Literal { .. }));
 
-        let literal_token = if kind == spec::Spec::get().well_known.LiteralString {
+        let literal_token = if kind == self.wk.LiteralSpecConstantOpInteger {
+            assert_eq!(words.len(), 1);
+            let (_, inner_name, inner_def) = match u16::try_from(first_word)
+                .ok()
+                .and_then(spec::Opcode::try_from_u16_with_name_and_def)
+            {
+                Some(opcode_name_and_def) => opcode_name_and_def,
+                None => {
+                    self.out.tokens.push(Token::Error(format!(
+                        "/* {first_word} not a valid `OpSpecConstantOp` opcode */"
+                    )));
+                    return;
+                }
+            };
+
+            // FIXME(eddyb) deduplicate this with `enumerant_params`.
+            self.out.tokens.push(Token::EnumerandName(inner_name));
+
+            let mut first = true;
+            for (inner_mode, inner_name_and_kind) in inner_def.all_operands_with_names() {
+                if inner_mode == spec::OperandMode::Optional && self.is_exhausted() {
+                    break;
+                }
+
+                self.out.tokens.push(Token::Punctuation(if first { "(" } else { ", " }));
+                first = false;
+
+                let (inner_name, inner_kind) = inner_name_and_kind.name_and_kind();
+                self.operand(inner_name, inner_kind);
+            }
+            if !first {
+                self.out.tokens.push(Token::Punctuation(")"));
+            }
+            return;
+        } else if kind == self.wk.LiteralString {
             // FIXME(eddyb) deduplicate with `spv::extract_literal_string`.
             let bytes: SmallVec<[u8; 64]> = words
                 .into_iter()
@@ -260,6 +297,7 @@ impl<IMMS: Iterator<Item = spv::Imm>, ID, IDS: Iterator<Item = ID>> OperandPrint
 /// an enumerand with parameters (which consumes more immediates).
 pub fn operand_from_imms<T>(imms: impl IntoIterator<Item = spv::Imm>) -> TokensForOperand<T> {
     let mut printer = OperandPrinter {
+        wk: &spec::Spec::get().well_known,
         imms: imms.into_iter().peekable(),
         ids: iter::empty().peekable(),
         out: TokensForOperand::default(),
@@ -282,6 +320,7 @@ pub fn inst_operands<ID>(
     ids: impl IntoIterator<Item = ID>,
 ) -> impl Iterator<Item = TokensForOperand<ID>> {
     OperandPrinter {
+        wk: &spec::Spec::get().well_known,
         imms: imms.into_iter().peekable(),
         ids: ids.into_iter().peekable(),
         out: TokensForOperand::default(),
diff --git a/src/spv/read.rs b/src/spv/read.rs
@@ -28,6 +28,9 @@ impl KnownIdDef {
 
 // FIXME(eddyb) keep a `&'static spec::Spec` if that can even speed up anything.
 struct InstParser<'a> {
+    // FIXME(eddyb) use a field like this to interpret `Opcode`/`OperandKind`, too.
+    wk: &'static spv::spec::WellKnown,
+
     /// IDs defined so far in the module.
     known_ids: &'a FxHashMap<spv::Id, KnownIdDef>,
 
@@ -60,6 +63,9 @@ enum InstParseError {
     /// The type of a `LiteralContextDependentNumber` was not a supported type
     /// (one of either `OpTypeInt` or `OpTypeFloat`).
     UnsupportedContextSensitiveLiteralType { type_opcode: spec::Opcode },
+
+    /// Unsupported `OpSpecConstantOp` (`LiteralSpecConstantOpInteger`) opcode.
+    UnsupportedSpecConstantOpOpcode(u32),
 }
 
 impl InstParseError {
@@ -94,6 +100,9 @@ impl InstParseError {
             Self::UnsupportedContextSensitiveLiteralType { type_opcode } => {
                 format!("{} is not a supported literal type", type_opcode.name()).into()
             }
+            Self::UnsupportedSpecConstantOpOpcode(opcode) => {
+                format!("{opcode} is not a supported opcode (for `OpSpecConstantOp`)").into()
+            }
         }
     }
 }
@@ -198,6 +207,22 @@ impl InstParser<'_> {
             }
         }
 
+        // HACK(eddyb) this isn't cleanly uniform because it's an odd special case.
+        if kind == self.wk.LiteralSpecConstantOpInteger {
+            // FIXME(eddyb) this partially duplicates the main instruction parsing.
+            let (_, _, inner_def) = u16::try_from(word)
+                .ok()
+                .and_then(spec::Opcode::try_from_u16_with_name_and_def)
+                .ok_or(Error::UnsupportedSpecConstantOpOpcode(word))?;
+
+            for (inner_mode, inner_kind) in inner_def.all_operands() {
+                if inner_mode == spec::OperandMode::Optional && self.is_exhausted() {
+                    break;
+                }
+                self.operand(inner_kind)?;
+            }
+        }
+
         Ok(())
     }
 
@@ -324,6 +349,7 @@ impl Iterator for ModuleParser {
         }
 
         let parser = InstParser {
+            wk: &spec::Spec::get().well_known,
             known_ids: &self.known_ids,
             words: words[1..inst_len].iter().copied(),
             inst: spv::InstWithIds {
diff --git a/src/spv/spec.rs b/src/spv/spec.rs
@@ -183,6 +183,7 @@ def_well_known! {
         LiteralExtInstInteger,
         LiteralString,
         LiteralContextDependentNumber,
+        LiteralSpecConstantOpInteger,
     ],
     // FIXME(eddyb) find a way to namespace these to avoid conflicts.
     addressing_model: u32 = [
diff --git a/src/spv/write.rs b/src/spv/write.rs
@@ -7,6 +7,9 @@ use std::{fs, io, iter, slice};
 
 // FIXME(eddyb) keep a `&'static spec::Spec` if that can even speed up anything.
 struct OperandEmitter<'a> {
+    // FIXME(eddyb) use a field like this to interpret `Opcode`/`OperandKind`, too.
+    wk: &'static spv::spec::WellKnown,
+
     /// Input immediate operands of an instruction.
     imms: iter::Copied<slice::Iter<'a, spv::Imm>>,
 
@@ -32,6 +35,9 @@ enum OperandEmitError {
 
     /// Unsupported enumerand value.
     UnsupportedEnumerand(spec::OperandKind, u32),
+
+    /// Unsupported `OpSpecConstantOp` (`LiteralSpecConstantOpInteger`) opcode.
+    UnsupportedSpecConstantOpOpcode(u32),
 }
 
 impl OperandEmitError {
@@ -60,6 +66,9 @@ impl OperandEmitError {
                     _ => unreachable!(),
                 }
             }
+            Self::UnsupportedSpecConstantOpOpcode(opcode) => {
+                format!("{opcode} is not a supported opcode (for `OpSpecConstantOp`)").into()
+            }
         }
     }
 }
@@ -140,6 +149,23 @@ impl OperandEmitter<'_> {
             }
         }
 
+        // HACK(eddyb) this isn't cleanly uniform because it's an odd special case.
+        if kind == self.wk.LiteralSpecConstantOpInteger {
+            // FIXME(eddyb) this partially duplicates the main instruction emission.
+            let &word = self.out.last().unwrap();
+            let (_, _, inner_def) = u16::try_from(word)
+                .ok()
+                .and_then(spec::Opcode::try_from_u16_with_name_and_def)
+                .ok_or(Error::UnsupportedSpecConstantOpOpcode(word))?;
+
+            for (inner_mode, inner_kind) in inner_def.all_operands() {
+                if inner_mode == spec::OperandMode::Optional && self.is_exhausted() {
+                    break;
+                }
+                self.operand(inner_kind)?;
+            }
+        }
+
         Ok(())
     }
 
@@ -221,6 +247,7 @@ impl ModuleEmitter {
         );
 
         OperandEmitter {
+            wk: &spec::Spec::get().well_known,
             imms: inst.imms.iter().copied(),
             ids: inst.ids.iter().copied(),
             out: &mut self.words,
