Add EXT_mesh_shader validation support

1. Each OpEntryPoint with the MeshEXT Execution Model can have at most one global OpVariable of storage class TaskPayloadWorkgroupEXT.
2. PerPrimitiveEXT only be used on a memory object declaration or a member of a structure type
3. PerPrimitiveEXT only Input in Fragment and Output in MeshEXT
4. Added Mesh vulkan validation support for following rules:
   VUID-Layer-Layer-07039 VUID-PrimitiveId-PrimitiveId-07040,VUID-PrimitivePointIndicesEXT-PrimitivePointIndicesEXT-07042,
   VUID-PrimitiveLineIndicesEXT-PrimitiveLineIndicesEXT-07048, VUID-PrimitiveTriangleIndicesEXT-PrimitiveTriangleIndicesEXT-07054,
   VUID-ViewportIndex-ViewportIndex-07060 VUID-StandaloneSpirv-ExecutionModel-07330 VUID-StandaloneSpirv-ExecutionModel-07331

Author: pmistryNV

source/val/validate_annotation.cpp

@@ -163,6 +163,7 @@ spv_result_t ValidateDecorationTarget(ValidationState_t& _, spv::Decoration dec,
     case spv::Decoration::Stream:
     case spv::Decoration::RestrictPointer:
     case spv::Decoration::AliasedPointer:
+    case spv::Decoration::PerPrimitiveNV:
       if (target->opcode() != spv::Op::OpVariable &&
           target->opcode() != spv::Op::OpUntypedVariableKHR &&
           target->opcode() != spv::Op::OpFunctionParameter &&

source/val/validate_builtins.cpp

@@ -122,7 +122,7 @@ typedef enum VUIDError_ {
   VUIDErrorMax,
 } VUIDError;
 
-const static uint32_t NumVUIDBuiltins = 39;
+const static uint32_t NumVUIDBuiltins = 40;
 
 typedef struct {
   spv::BuiltIn builtIn;
@@ -172,6 +172,8 @@ std::array<BuiltinVUIDMapping, NumVUIDBuiltins> builtinVUIDInfo = {{
     {spv::BuiltIn::PrimitivePointIndicesEXT,  {7041, 7043, 7044}},
     {spv::BuiltIn::PrimitiveLineIndicesEXT,   {7047, 7049, 7050}},
     {spv::BuiltIn::PrimitiveTriangleIndicesEXT, {7053, 7055, 7056}},
+    {spv::BuiltIn::CullPrimitiveEXT,          {7034, 7035, 7036}},
+
     // clang-format on
 }};
 
@@ -249,6 +251,7 @@ bool IsExecutionModelValidForRtBuiltIn(spv::BuiltIn builtin,
   return false;
 }
 
+
 // Helper class managing validation of built-ins.
 // TODO: Generic functionality of this class can be moved into
 // ValidationState_t to be made available to other users.
@@ -671,6 +674,24 @@ class BuiltInsValidator {
   // instruction.
   void Update(const Instruction& inst);
 
+  bool isMeshInterfaceVar(const Instruction& inst) {
+    for (const uint32_t entry_point : _.entry_points()) {
+        const auto* models = _.GetExecutionModels(entry_point);
+        if (models->find(spv::ExecutionModel::MeshEXT ) != models->end() ||
+            models->find(spv::ExecutionModel::MeshNV ) != models->end()) {
+            for (const auto& desc : _.entry_point_descriptions(entry_point)) {
+              for (auto interface : desc.interfaces) {
+                if (inst.id() == interface) {
+                  return true;
+                }
+              }
+            }
+        }
+    }
+    return false;
+  }
+
+
   ValidationState_t& _;
 
   // Mapping id -> list of rules which validate instruction referencing the
@@ -2154,6 +2175,17 @@ spv_result_t BuiltInsValidator::ValidatePrimitiveIdAtDefinition(
         return error;
       }
     }
+
+    if (_.HasCapability(spv::Capability::MeshShadingEXT)) {
+      if (isMeshInterfaceVar(inst) && 
+        !_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) {
+        return _.diag(SPV_ERROR_INVALID_DATA, &inst)
+               << _.VkErrorID(7040)
+               << "According to the Vulkan spec the variable decorated with "
+                  "Builtin PrimitiveId within the MeshEXT Execution Model must "
+                  "also be decorated with the PerPrimitiveEXT decoration. ";
+      }
+    }
   }
 
   // Seed at reference checks with this built-in.
@@ -2765,6 +2797,21 @@ spv_result_t BuiltInsValidator::ValidateLayerOrViewportIndexAtDefinition(
         return error;
       }
     }
+
+    if (isMeshInterfaceVar(inst) &&
+        _.HasCapability(spv::Capability::MeshShadingEXT) &&
+        !_.HasDecoration(inst.id(), spv::Decoration::PerPrimitiveEXT)) {
+      const spv::BuiltIn label = spv::BuiltIn(decoration.params()[0]);
+      uint32_t vkerrid = (label == spv::BuiltIn::Layer) ? 7039 : 7060;
+      return _.diag(SPV_ERROR_INVALID_DATA, &inst)
+             << _.VkErrorID(vkerrid)
+             << "According to the Vulkan spec the variable decorated with "
+                "Builtin "
+             << _.grammar().lookupOperandName(SPV_OPERAND_TYPE_BUILT_IN,
+                                              decoration.params()[0])
+             << " within the MeshEXT Execution Model must also be decorated "
+                "with the PerPrimitiveEXT decoration. ";
+    }
   }
 
   // Seed at reference checks with this built-in.
@@ -3473,6 +3520,7 @@ spv_result_t BuiltInsValidator::ValidateViewIndexAtReference(
                                    referenced_from_inst, execution_model);
       }
     }
+    
   }
 
   if (function_id_ == 0) {
@@ -4273,7 +4321,6 @@ spv_result_t BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtReference(
                                  referenced_from_inst)
              << " " << GetStorageClassDesc(referenced_from_inst);
     }
-
     for (const spv::ExecutionModel execution_model : execution_models_) {
       if (execution_model != spv::ExecutionModel::MeshEXT) {
         uint32_t vuid = GetVUIDForBuiltin(builtin, VUIDErrorExecutionModel);
@@ -4288,6 +4335,92 @@ spv_result_t BuiltInsValidator::ValidateMeshShadingEXTBuiltinsAtReference(
                                    referenced_from_inst, execution_model);
       }
     }
+
+    for (const uint32_t entry_point : *entry_points_) {
+      // Every entry point from which this function is called needs to have
+      // Execution Mode DepthReplacing.
+      const auto* modes = _.GetExecutionModes(entry_point);
+      uint32_t maxOutputPrimitives = _.GetOutputPrimitivesEXT(entry_point);
+      uint32_t underlying_type = 0;
+      if (spv_result_t error =
+              GetUnderlyingType(_, decoration, referenced_inst, &underlying_type)) {
+        return error;
+      }
+
+      uint32_t primitiveArrayDim = 0;
+      // Strip the array, if present.
+      if (_.GetIdOpcode(underlying_type) == spv::Op::OpTypeArray) {
+        underlying_type = _.FindDef(underlying_type)->word(3u);
+        if (_.GetIdOpcode(underlying_type) == spv::Op::OpConstant) {
+            assert(_.GetIdOpcode(_.FindDef(underlying_type)->word(1)) == spv::Op::OpTypeInt);
+            primitiveArrayDim = _.FindDef(underlying_type)->word(3);
+        }
+      }
+      switch (builtin) {
+        case spv::BuiltIn::PrimitivePointIndicesEXT:
+          if (!modes || !modes->count(spv::ExecutionMode::OutputPoints)) {
+            return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
+                   << _.VkErrorID(7042)
+                   << "The PrimitivePointIndicesEXT decoration must be used "
+                      "with "
+                      "the OutputPoints Execution Mode. "
+                   << GetReferenceDesc(decoration, built_in_inst,
+                                       referenced_inst, referenced_from_inst);
+          }
+          if (primitiveArrayDim && primitiveArrayDim != maxOutputPrimitives) {
+            return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
+                   << _.VkErrorID(7046)
+                   << "The size of the array decorated with "
+                      "PrimitivePointIndicesEXT must match the value specified "
+                      "by OutputPrimitivesEXT. "
+                   << GetReferenceDesc(decoration, built_in_inst,
+                                       referenced_inst, referenced_from_inst);
+          }
+          break;
+        case spv::BuiltIn::PrimitiveLineIndicesEXT:
+          if (!modes || !modes->count(spv::ExecutionMode::OutputLinesEXT)) {
+            return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
+                   << _.VkErrorID(7048)
+                   << "The PrimitiveLineIndicesEXT decoration must be used "
+                      "with "
+                      "the OutputLinesEXT Execution Mode. "
+                   << GetReferenceDesc(decoration, built_in_inst,
+                                       referenced_inst, referenced_from_inst);
+          }
+          if (primitiveArrayDim && primitiveArrayDim != maxOutputPrimitives) {
+            return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
+                   << _.VkErrorID(7052)
+                   << "The size of the array decorated with "
+                      "PrimitiveLineIndicesEXT must match the value specified "
+                      "by OutputPrimitivesEXT. "
+                   << GetReferenceDesc(decoration, built_in_inst,
+                                       referenced_inst, referenced_from_inst);
+          }
+          break;
+        case spv::BuiltIn::PrimitiveTriangleIndicesEXT:
+          if (!modes || !modes->count(spv::ExecutionMode::OutputTrianglesEXT)) {
+            return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
+                   << _.VkErrorID(7054)
+                   << "The PrimitiveTriangleIndicesEXT decoration must be used "
+                      "with "
+                      "the OutputTrianglesEXT Execution Mode. "
+                   << GetReferenceDesc(decoration, built_in_inst,
+                                       referenced_inst, referenced_from_inst);
+          }
+          if (primitiveArrayDim && primitiveArrayDim != maxOutputPrimitives) {
+            return _.diag(SPV_ERROR_INVALID_DATA, &referenced_from_inst)
+                   << _.VkErrorID(7058)
+                   << "The size of the array decorated with "
+                      "PrimitiveTriangleIndicesEXT must match the value specified "
+                      "by OutputPrimitivesEXT. "
+                   << GetReferenceDesc(decoration, built_in_inst,
+                                       referenced_inst, referenced_from_inst);
+          }
+          break;
+        default:
+          break;  // no validation rules
+      }
+    }
   }
 
   if (function_id_ == 0) {
@@ -4476,6 +4609,7 @@ spv_result_t BuiltInsValidator::ValidateSingleBuiltInAtDefinition(
     case spv::BuiltIn::CullMaskKHR: {
       return ValidateRayTracingBuiltinsAtDefinition(decoration, inst);
     }
+    case spv::BuiltIn::CullPrimitiveEXT:
     case spv::BuiltIn::PrimitivePointIndicesEXT:
     case spv::BuiltIn::PrimitiveLineIndicesEXT:
     case spv::BuiltIn::PrimitiveTriangleIndicesEXT: {

source/val/validate_decorations.cpp

@@ -767,6 +767,7 @@ spv_result_t CheckDecorationsOfEntryPoints(ValidationState_t& vstate) {
     int num_workgroup_variables = 0;
     int num_workgroup_variables_with_block = 0;
     int num_workgroup_variables_with_aliased = 0;
+    bool has_task_payload = false;
     for (const auto& desc : descs) {
       std::unordered_set<Instruction*> seen_vars;
       std::unordered_set<spv::BuiltIn> input_var_builtin;
@@ -786,6 +787,19 @@ spv_result_t CheckDecorationsOfEntryPoints(ValidationState_t& vstate) {
         const auto sc_index = 2u;
         const spv::StorageClass storage_class =
             var_instr->GetOperandAs<spv::StorageClass>(sc_index);
+        if (vstate.version() >= SPV_SPIRV_VERSION_WORD(1, 4)) {
+          // SPV_EXT_mesh_shader, at most one task payload is permitted
+          // per entry point
+          if (storage_class == spv::StorageClass::TaskPayloadWorkgroupEXT) {
+            if (has_task_payload) {
+              return vstate.diag(SPV_ERROR_INVALID_ID, var_instr)
+                     << "There can be at most one OpVariable with storage "
+                        "class TaskPayloadWorkgroupEXT associated with "
+                        "an OpEntryPoint";
+            }
+            has_task_payload = true;
+          }
+        }
         if (vstate.version() >= SPV_SPIRV_VERSION_WORD(1, 4)) {
           // Starting in 1.4, OpEntryPoint must list all global variables
           // it statically uses and those interfaces must be unique.

source/val/validate_instruction.cpp

@@ -481,6 +481,10 @@ spv_result_t InstructionPass(ValidationState_t& _, const Instruction* inst) {
             spv::ExecutionMode::LocalSizeId) {
       _.RegisterEntryPointLocalSize(entry_point, inst);
     }
+    if (inst->GetOperandAs<spv::ExecutionMode>(1) ==
+            spv::ExecutionMode::OutputPrimitivesEXT) {
+        _.RegisterEntryPointOutputPrimitivesEXT(entry_point, inst);
+    }
   } else if (opcode == spv::Op::OpVariable) {
     const auto storage_class = inst->GetOperandAs<spv::StorageClass>(2);
     if (auto error = LimitCheckNumVars(_, inst->id(), storage_class)) {

source/val/validate_mesh_shading.cpp

@@ -15,13 +15,32 @@
 // Validates ray query instructions from SPV_KHR_ray_query
 
 #include "source/opcode.h"
+#include "source/spirv_target_env.h"
 #include "source/val/instruction.h"
 #include "source/val/validate.h"
 #include "source/val/validation_state.h"
 
 namespace spvtools {
 namespace val {
 
+bool IsInterfaceVariable(ValidationState_t& _, const Instruction* inst,
+                         spv::ExecutionModel model) {
+  bool foundInterface = false;
+  for (auto entry_point : _.entry_points()) {
+    const auto* models = _.GetExecutionModels(entry_point);
+    if (models->find(model) == models->end()) return false;
+    for (const auto& desc : _.entry_point_descriptions(entry_point)) {
+      for (auto interface : desc.interfaces) {
+        if (inst->id() == interface) {
+          foundInterface = true;
+          break;
+        }
+      }
+    }
+  }
+  return foundInterface;
+}
+
 spv_result_t MeshShadingPass(ValidationState_t& _, const Instruction* inst) {
   const spv::Op opcode = inst->opcode();
   switch (opcode) {
@@ -103,15 +122,45 @@ spv_result_t MeshShadingPass(ValidationState_t& _, const Instruction* inst) {
         return _.diag(SPV_ERROR_INVALID_DATA, inst)
                << "Primitive Count must be a 32-bit unsigned int scalar";
       }
-
+      
       break;
     }
 
     case spv::Op::OpWritePackedPrimitiveIndices4x8NV: {
       // No validation rules (for the moment).
       break;
     }
-
+    case spv::Op::OpVariable: {
+      if (_.HasCapability(spv::Capability::MeshShadingEXT)) {
+        bool meshInterfaceVar = IsInterfaceVariable(
+            _, inst, spv::ExecutionModel::MeshEXT);
+        bool fragInterfaceVar = IsInterfaceVariable(
+            _, inst, spv::ExecutionModel::Fragment);
+
+        const spv::StorageClass storage_class =
+            inst->GetOperandAs<spv::StorageClass>(2);
+        bool storage_output = (storage_class == spv::StorageClass::Output);
+        bool storage_input = (storage_class == spv::StorageClass::Input);
+        
+        if (_.HasDecoration(inst->id(), spv::Decoration::PerPrimitiveEXT)) {
+          if (fragInterfaceVar && !storage_input) {
+            return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                   << "PerPrimitiveEXT decoration must be applied only to "
+                      "variables in the Input Storage Class in the Fragment "
+                      "Execution Model.";
+          }
+
+          if (meshInterfaceVar && !storage_output) {
+            return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                   << _.VkErrorID(4336)
+                   << "PerPrimitiveEXT decoration must be applied only to "
+                      "variables in the Output Storage Class in the "
+                      "Storage Class in the MeshEXT Execution Model.";
+          }
+        }
+      }
+      break;
+    } 
     default:
       break;
   }

source/val/validate_mode_setting.cpp

@@ -543,6 +543,15 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _,
                     "tessellation execution model.";
         }
       }
+      if (spvIsVulkanEnv(_.context()->target_env)) {
+        if (_.HasCapability(spv::Capability::MeshShadingEXT) &&
+            inst->GetOperandAs<uint32_t>(2) == 0) {
+          return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                 << _.VkErrorID(7330)
+                 << "In mesh shaders using the MeshEXT Execution Model the "
+                    "OutputVertices Execution Mode must be greater than 0";
+        }
+      }
       break;
     case spv::ExecutionMode::OutputLinesEXT:
     case spv::ExecutionMode::OutputTrianglesEXT:
@@ -557,6 +566,16 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _,
                   "execution "
                   "model.";
       }
+      if (mode == spv::ExecutionMode::OutputPrimitivesEXT &&
+          spvIsVulkanEnv(_.context()->target_env)) {
+        if (_.HasCapability(spv::Capability::MeshShadingEXT) &&
+            inst->GetOperandAs<uint32_t>(2) == 0) {
+          return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                 << _.VkErrorID(7331)
+                 << "In mesh shaders using the MeshEXT Execution Model the "
+                    "OutputPrimitivesEXT Execution Mode must be greater than 0";
+        }
+      }
       break;
     case spv::ExecutionMode::QuadDerivativesKHR:
       if (!std::all_of(models->begin(), models->end(),