Fix builtin direction validation to check per-entry-point usage

The BuiltinStorageClassDirectionRule was validating builtin directions
against ALL entry points in the module, but a builtin variable may only
be used by specific entry points.

For example, ClipDistance as Input is valid in Fragment shaders but not
in Vertex shaders. If a module has both entry points but ClipDistance is
only in the Fragment interface, validation should pass.

This fix builds a map of which entry points actually use each variable
(from the OpEntryPoint interface lists) and only validates builtin
direction against those specific entry points.

Added positive and negative tests for the fix.

Author: LegNeato

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

@@ -1094,7 +1094,24 @@ impl ValidationRule for BuiltinStorageClassDirectionRule {
         }
 
         let module = ctx.module;
-        let entry_models = ctx.entry_models;
+
+        // Build map of variable ID -> set of execution models that use it
+        // by checking entry point interfaces
+        let mut var_to_models: HashMap<u32, HashSet<ExecutionModel>> = HashMap::new();
+        for ep in &module.entry_points {
+            if ep.class.opcode != Op::EntryPoint {
+                continue;
+            }
+            let Some(rspirv::dr::Operand::ExecutionModel(model)) = ep.operands.first() else {
+                continue;
+            };
+            // Interface variables start at operand index 3 (after ExecutionModel, Function, Name)
+            for op in ep.operands.iter().skip(3) {
+                if let rspirv::dr::Operand::IdRef(var_id) = op {
+                    var_to_models.entry(*var_id).or_default().insert(*model);
+                }
+            }
+        }
 
         // Collect built-in decorations with their storage classes
         for inst in &module.annotations {
@@ -1141,8 +1158,11 @@ impl ValidationRule for BuiltinStorageClassDirectionRule {
                 continue;
             };
 
-            // Validate direction per built-in per execution model
-            for model in entry_models {
+            // Only validate direction against entry points that actually use this variable
+            let Some(models) = var_to_models.get(target) else {
+                continue;
+            };
+            for model in models {
                 if let Some(error) = validate_builtin_direction(builtin, storage_class, *model) {
                     return Err(error.into());
                 }

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

@@ -30413,3 +30413,76 @@ fn instance_id_builtin_accepted_in_vulkan_ray_tracing_shader() {
         .validate(TargetEnv::Vulkan1_2)
         .expect("InstanceId should be accepted in Vulkan ray tracing shader");
 }
+
+#[test]
+fn clip_distance_input_rejected_in_vertex_shader() {
+    // ClipDistance as Input is not allowed in Vertex shaders
+    let text = [
+        "OpCapability Shader",
+        "OpCapability ClipDistance",
+        "OpMemoryModel Logical GLSL450",
+        "OpEntryPoint Vertex %main \"main\" %clip",
+        "%void = OpTypeVoid",
+        "%float = OpTypeFloat 32",
+        "%arr = OpTypeArray %float %uint_1",
+        "%uint = OpTypeInt 32 0",
+        "%uint_1 = OpConstant %uint 1",
+        "%ptr_input_arr = OpTypePointer Input %arr",
+        "%clip = OpVariable %ptr_input_arr Input",
+        "OpDecorate %clip BuiltIn ClipDistance",
+        "%fn = OpTypeFunction %void",
+        "%main = OpFunction %void None %fn",
+        "%entry = OpLabel",
+        "OpReturn",
+        "OpFunctionEnd",
+    ]
+    .join("\n");
+    let error = text
+        .as_str()
+        .validate(TargetEnv::Vulkan1_1)
+        .expect_err("ClipDistance Input should be rejected in Vertex shader");
+    assert!(
+        matches!(
+            error,
+            ValidationError::BuiltInWrongStorageClassForExecutionModel { .. }
+        ),
+        "Expected BuiltInWrongStorageClassForExecutionModel, got: {error:?}"
+    );
+}
+
+#[test]
+fn clip_distance_input_accepted_in_fragment_with_separate_vertex_entry() {
+    // ClipDistance as Input is allowed in Fragment shaders, even when
+    // the module also has a Vertex entry point (that doesn't use it)
+    let text = [
+        "OpCapability Shader",
+        "OpCapability ClipDistance",
+        "OpMemoryModel Logical GLSL450",
+        // Vertex entry point does NOT list %clip in its interface
+        "OpEntryPoint Vertex %vmain \"vmain\"",
+        // Fragment entry point DOES list %clip in its interface
+        "OpEntryPoint Fragment %fmain \"fmain\" %clip",
+        "OpExecutionMode %fmain OriginUpperLeft",
+        "%void = OpTypeVoid",
+        "%float = OpTypeFloat 32",
+        "%uint = OpTypeInt 32 0",
+        "%uint_1 = OpConstant %uint 1",
+        "%arr = OpTypeArray %float %uint_1",
+        "%ptr_input_arr = OpTypePointer Input %arr",
+        "%clip = OpVariable %ptr_input_arr Input",
+        "OpDecorate %clip BuiltIn ClipDistance",
+        "%fn = OpTypeFunction %void",
+        "%vmain = OpFunction %void None %fn",
+        "%ventry = OpLabel",
+        "OpReturn",
+        "OpFunctionEnd",
+        "%fmain = OpFunction %void None %fn",
+        "%fentry = OpLabel",
+        "OpReturn",
+        "OpFunctionEnd",
+    ]
+    .join("\n");
+    text.as_str()
+        .validate(TargetEnv::Vulkan1_1)
+        .expect("ClipDistance Input should be accepted in Fragment shader");
+}