Add OpSwitch selector type validation

Add SwitchSelectorTypeRule that verifies the OpSwitch selector operand
is an integer type (OpTypeInt), as required by the SPIR-V spec. A float
or other non-integer selector is rejected with SwitchSelectorNotInteger.

Author: LegNeato

rust/spirv-tools-core/src/validation/error.rs

@@ -2813,6 +2813,14 @@ pub enum ValidationError {
         /// The duplicate literal value.
         literal: u64,
     },
+    /// OpSwitch selector must be an integer type.
+    #[error("OpSwitch selector {selector_id} must be OpTypeInt, found {found_opcode:?}")]
+    SwitchSelectorNotInteger {
+        /// The selector operand ID.
+        selector_id: Id,
+        /// The opcode of the selector's type.
+        found_opcode: rspirv::spirv::Op,
+    },
     /// A basic block is missing its required `OpLabel`.
     #[error("function {function:?} contains a block without OpLabel at index {block_index}")]
     MissingBlockLabel {

rust/spirv-tools-core/src/validation/rules/cfg.rs

@@ -1737,6 +1737,62 @@ impl ValidationRule for SwitchCaseUniquenessRule {
     }
 }
 
+// ============================================================================
+// Switch Selector Type Rule
+// ============================================================================
+
+/// Validates that OpSwitch selector operand is an integer type.
+pub struct SwitchSelectorTypeRule;
+
+impl ValidationRule for SwitchSelectorTypeRule {
+    fn name(&self) -> &'static str {
+        "switch-selector-type"
+    }
+
+    fn validate(&self, ctx: &ValidationContext<'_>) -> ValidationResult {
+        for function in &ctx.module.functions {
+            for block in &function.blocks {
+                for inst in &block.instructions {
+                    if inst.class.opcode != Op::Switch {
+                        continue;
+                    }
+                    // OpSwitch operands[0] = selector id
+                    let Some(Operand::IdRef(selector_id)) = inst.operands.first() else {
+                        continue;
+                    };
+                    let selector_rid = match ResultId::try_from(*selector_id) {
+                        Ok(r) => r,
+                        Err(_) => continue,
+                    };
+                    // Look up the instruction that defines the selector
+                    let Some(selector_def) = ctx.definitions.get(&selector_rid) else {
+                        continue;
+                    };
+                    // Get the selector's result type
+                    let Some(type_id) = selector_def.result_type else {
+                        continue;
+                    };
+                    let type_rid = match ResultId::try_from(type_id) {
+                        Ok(r) => r,
+                        Err(_) => continue,
+                    };
+                    let Some(type_inst) = ctx.definitions.get(&type_rid) else {
+                        continue;
+                    };
+                    if type_inst.class.opcode != Op::TypeInt {
+                        return Err(ValidationError::SwitchSelectorNotInteger {
+                            selector_id: to_id(*selector_id),
+                            found_opcode: type_inst.class.opcode,
+                        }
+                        .into());
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
 /// Static rule instances
 static BLOCK_STRUCTURE_RULE: BlockStructureRule = BlockStructureRule;
 static MERGE_INSTRUCTION_RULE: MergeInstructionRule = MergeInstructionRule;
@@ -1752,6 +1808,7 @@ static MAXIMAL_RECONVERGENCE_PREDECESSORS_RULE: MaximalReconvergencePredecessors
     MaximalReconvergencePredecessorsRule;
 static LIFETIME_RULE: LifetimeRule = LifetimeRule;
 static SWITCH_CASE_UNIQUENESS_RULE: SwitchCaseUniquenessRule = SwitchCaseUniquenessRule;
+static SWITCH_SELECTOR_TYPE_RULE: SwitchSelectorTypeRule = SwitchSelectorTypeRule;
 
 /// Returns all CFG validation rules.
 pub fn all_cfg_rules() -> Vec<&'static dyn ValidationRule> {
@@ -1769,5 +1826,6 @@ pub fn all_cfg_rules() -> Vec<&'static dyn ValidationRule> {
         &MAXIMAL_RECONVERGENCE_PREDECESSORS_RULE,
         &LIFETIME_RULE,
         &SWITCH_CASE_UNIQUENESS_RULE,
+        &SWITCH_SELECTOR_TYPE_RULE,
     ]
 }

rust/spirv-tools-core/src/validation/tests/cfg.rs

@@ -1654,3 +1654,140 @@ fn switch_duplicate_case_literal_fails() {
         "expected SwitchDuplicateCaseLiteral with literal 42, got {err:?}"
     );
 }
+
+// ============================================================================
+// Switch Selector Type Validation
+// ============================================================================
+
+#[test]
+fn switch_with_integer_selector_passes() {
+    let text = r#"
+OpCapability Shader
+OpMemoryModel Logical GLSL450
+OpEntryPoint GLCompute %main "main"
+OpExecutionMode %main LocalSize 1 1 1
+%void = OpTypeVoid
+%fn = OpTypeFunction %void
+%u32 = OpTypeInt 32 0
+%u32_0 = OpConstant %u32 0
+%main = OpFunction %void None %fn
+%entry = OpLabel
+OpSelectionMerge %merge None
+OpSwitch %u32_0 %merge 1 %case1 2 %case2
+%case1 = OpLabel
+OpBranch %merge
+%case2 = OpLabel
+OpBranch %merge
+%merge = OpLabel
+OpReturn
+OpFunctionEnd
+"#;
+    assemble_and_validate(text).expect("OpSwitch with integer selector should pass");
+}
+
+#[test]
+fn switch_with_float_selector_fails() {
+    use rspirv::binary::Assemble;
+    use rspirv::dr::{Instruction, Module, Operand};
+
+    let mut module = Module::new();
+    module.header = Some(rspirv::dr::ModuleHeader {
+        magic_number: rspirv::spirv::MAGIC_NUMBER,
+        version: (1 << 16) | (5 << 8),
+        generator: 0,
+        bound: 20,
+        reserved_word: 0,
+    });
+
+    module.capabilities.push(Instruction::new(
+        Op::Capability,
+        None,
+        None,
+        vec![Operand::Capability(rspirv::spirv::Capability::Shader)],
+    ));
+    module.memory_model = Some(Instruction::new(
+        Op::MemoryModel,
+        None,
+        None,
+        vec![
+            Operand::AddressingModel(rspirv::spirv::AddressingModel::Logical),
+            Operand::MemoryModel(rspirv::spirv::MemoryModel::GLSL450),
+        ],
+    ));
+    module.entry_points.push(Instruction::new(
+        Op::EntryPoint,
+        None,
+        None,
+        vec![
+            Operand::ExecutionModel(rspirv::spirv::ExecutionModel::GLCompute),
+            Operand::IdRef(10),
+            Operand::LiteralString("main".to_string()),
+        ],
+    ));
+    module.execution_modes.push(Instruction::new(
+        Op::ExecutionMode,
+        None,
+        None,
+        vec![
+            Operand::IdRef(10),
+            Operand::ExecutionMode(rspirv::spirv::ExecutionMode::LocalSize),
+            Operand::LiteralBit32(1),
+            Operand::LiteralBit32(1),
+            Operand::LiteralBit32(1),
+        ],
+    ));
+
+    // %2 = OpTypeVoid
+    module.types_global_values.push(Instruction::new(Op::TypeVoid, None, Some(2), vec![]));
+    // %3 = OpTypeFunction %void
+    module.types_global_values.push(Instruction::new(
+        Op::TypeFunction, None, Some(3), vec![Operand::IdRef(2)],
+    ));
+    // %4 = OpTypeFloat 32
+    module.types_global_values.push(Instruction::new(
+        Op::TypeFloat, None, Some(4), vec![Operand::LiteralBit32(32)],
+    ));
+    // %5 = OpConstant %4 0.0
+    module.types_global_values.push(Instruction::new(
+        Op::Constant, Some(4), Some(5), vec![Operand::LiteralBit32(0)],
+    ));
+
+    let mut func = rspirv::dr::Function::new();
+    func.def = Some(Instruction::new(
+        Op::Function, Some(2), Some(10),
+        vec![
+            Operand::FunctionControl(rspirv::spirv::FunctionControl::NONE),
+            Operand::IdRef(3),
+        ],
+    ));
+
+    // Entry block with Switch on float selector
+    let mut entry = rspirv::dr::Block::new();
+    entry.label = Some(Instruction::new(Op::Label, None, Some(11), vec![]));
+    entry.instructions.push(Instruction::new(
+        Op::SelectionMerge, None, None,
+        vec![Operand::IdRef(14), Operand::SelectionControl(rspirv::spirv::SelectionControl::NONE)],
+    ));
+    // OpSwitch %5(float) %14(merge) -- this is invalid
+    entry.instructions.push(Instruction::new(
+        Op::Switch, None, None,
+        vec![Operand::IdRef(5), Operand::IdRef(14)],
+    ));
+    func.blocks.push(entry);
+
+    let mut merge = rspirv::dr::Block::new();
+    merge.label = Some(Instruction::new(Op::Label, None, Some(14), vec![]));
+    merge.instructions.push(Instruction::new(Op::Return, None, None, vec![]));
+    func.blocks.push(merge);
+
+    func.end = Some(Instruction::new(Op::FunctionEnd, None, None, vec![]));
+    module.functions.push(func);
+
+    let binary = module.assemble();
+    let err = validate_module(&binary, TargetEnv::Universal1_6)
+        .expect_err("OpSwitch with float selector should fail");
+    assert!(
+        matches!(err, ValidationError::SwitchSelectorNotInteger { .. }),
+        "expected SwitchSelectorNotInteger, got {err:?}"
+    );
+}