diff options
Diffstat (limited to 'source/val/validate_mode_setting.cpp')
| -rw-r--r-- | source/val/validate_mode_setting.cpp | 452 |
1 files changed, 229 insertions, 223 deletions
diff --git a/source/val/validate_mode_setting.cpp b/source/val/validate_mode_setting.cpp index 672192b9c..dfa46466f 100644 --- a/source/val/validate_mode_setting.cpp +++ b/source/val/validate_mode_setting.cpp @@ -27,16 +27,16 @@ namespace { spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { const auto entry_point_id = inst->GetOperandAs<uint32_t>(1); auto entry_point = _.FindDef(entry_point_id); - if (!entry_point || SpvOpFunction != entry_point->opcode()) { + if (!entry_point || spv::Op::OpFunction != entry_point->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "OpEntryPoint Entry Point <id> " << _.getIdName(entry_point_id) << " is not a function."; } // Only check the shader execution models - const SpvExecutionModel execution_model = - inst->GetOperandAs<SpvExecutionModel>(0); - if (execution_model != SpvExecutionModelKernel) { + const spv::ExecutionModel execution_model = + inst->GetOperandAs<spv::ExecutionModel>(0); + if (execution_model != spv::ExecutionModel::Kernel) { const auto entry_point_type_id = entry_point->GetOperandAs<uint32_t>(3); const auto entry_point_type = _.FindDef(entry_point_type_id); if (!entry_point_type || 3 != entry_point_type->words().size()) { @@ -48,7 +48,7 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } auto return_type = _.FindDef(entry_point->type_id()); - if (!return_type || SpvOpTypeVoid != return_type->opcode()) { + if (!return_type || spv::Op::OpTypeVoid != return_type->opcode()) { return _.diag(SPV_ERROR_INVALID_ID, inst) << _.VkErrorID(4633) << "OpEntryPoint Entry Point <id> " << _.getIdName(entry_point_id) @@ -56,31 +56,31 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } const auto* execution_modes = _.GetExecutionModes(entry_point_id); - if (_.HasCapability(SpvCapabilityShader)) { + if (_.HasCapability(spv::Capability::Shader)) { switch (execution_model) { - case SpvExecutionModelFragment: + case spv::ExecutionModel::Fragment: if (execution_modes && - execution_modes->count(SpvExecutionModeOriginUpperLeft) && - execution_modes->count(SpvExecutionModeOriginLowerLeft)) { + execution_modes->count(spv::ExecutionMode::OriginUpperLeft) && + execution_modes->count(spv::ExecutionMode::OriginLowerLeft)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points can only specify " "one of OriginUpperLeft or OriginLowerLeft execution " "modes."; } if (!execution_modes || - (!execution_modes->count(SpvExecutionModeOriginUpperLeft) && - !execution_modes->count(SpvExecutionModeOriginLowerLeft))) { + (!execution_modes->count(spv::ExecutionMode::OriginUpperLeft) && + !execution_modes->count(spv::ExecutionMode::OriginLowerLeft))) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Fragment execution model entry points require either an " "OriginUpperLeft or OriginLowerLeft execution mode."; } if (execution_modes && 1 < std::count_if(execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { + [](const spv::ExecutionMode& mode) { switch (mode) { - case SpvExecutionModeDepthGreater: - case SpvExecutionModeDepthLess: - case SpvExecutionModeDepthUnchanged: + case spv::ExecutionMode::DepthGreater: + case spv::ExecutionMode::DepthLess: + case spv::ExecutionMode::DepthUnchanged: return true; default: return false; @@ -94,14 +94,15 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { if (execution_modes && 1 < std::count_if( execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { + [](const spv::ExecutionMode& mode) { switch (mode) { - case SpvExecutionModePixelInterlockOrderedEXT: - case SpvExecutionModePixelInterlockUnorderedEXT: - case SpvExecutionModeSampleInterlockOrderedEXT: - case SpvExecutionModeSampleInterlockUnorderedEXT: - case SpvExecutionModeShadingRateInterlockOrderedEXT: - case SpvExecutionModeShadingRateInterlockUnorderedEXT: + case spv::ExecutionMode::PixelInterlockOrderedEXT: + case spv::ExecutionMode::PixelInterlockUnorderedEXT: + case spv::ExecutionMode::SampleInterlockOrderedEXT: + case spv::ExecutionMode::SampleInterlockUnorderedEXT: + case spv::ExecutionMode::ShadingRateInterlockOrderedEXT: + case spv::ExecutionMode:: + ShadingRateInterlockUnorderedEXT: return true; default: return false; @@ -114,11 +115,11 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { if (execution_modes && 1 < std::count_if( execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { + [](const spv::ExecutionMode& mode) { switch (mode) { - case SpvExecutionModeStencilRefUnchangedFrontAMD: - case SpvExecutionModeStencilRefLessFrontAMD: - case SpvExecutionModeStencilRefGreaterFrontAMD: + case spv::ExecutionMode::StencilRefUnchangedFrontAMD: + case spv::ExecutionMode::StencilRefLessFrontAMD: + case spv::ExecutionMode::StencilRefGreaterFrontAMD: return true; default: return false; @@ -133,11 +134,11 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { if (execution_modes && 1 < std::count_if( execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { + [](const spv::ExecutionMode& mode) { switch (mode) { - case SpvExecutionModeStencilRefUnchangedBackAMD: - case SpvExecutionModeStencilRefLessBackAMD: - case SpvExecutionModeStencilRefGreaterBackAMD: + case spv::ExecutionMode::StencilRefUnchangedBackAMD: + case spv::ExecutionMode::StencilRefLessBackAMD: + case spv::ExecutionMode::StencilRefGreaterBackAMD: return true; default: return false; @@ -150,20 +151,21 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { "execution modes."; } break; - case SpvExecutionModelTessellationControl: - case SpvExecutionModelTessellationEvaluation: + case spv::ExecutionModel::TessellationControl: + case spv::ExecutionModel::TessellationEvaluation: if (execution_modes && - 1 < std::count_if(execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { - switch (mode) { - case SpvExecutionModeSpacingEqual: - case SpvExecutionModeSpacingFractionalEven: - case SpvExecutionModeSpacingFractionalOdd: - return true; - default: - return false; - } - })) { + 1 < std::count_if( + execution_modes->begin(), execution_modes->end(), + [](const spv::ExecutionMode& mode) { + switch (mode) { + case spv::ExecutionMode::SpacingEqual: + case spv::ExecutionMode::SpacingFractionalEven: + case spv::ExecutionMode::SpacingFractionalOdd: + return true; + default: + return false; + } + })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Tessellation execution model entry points can specify at " "most one of SpacingEqual, SpacingFractionalOdd or " @@ -171,11 +173,11 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } if (execution_modes && 1 < std::count_if(execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { + [](const spv::ExecutionMode& mode) { switch (mode) { - case SpvExecutionModeTriangles: - case SpvExecutionModeQuads: - case SpvExecutionModeIsolines: + case spv::ExecutionMode::Triangles: + case spv::ExecutionMode::Quads: + case spv::ExecutionMode::Isolines: return true; default: return false; @@ -187,10 +189,10 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } if (execution_modes && 1 < std::count_if(execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { + [](const spv::ExecutionMode& mode) { switch (mode) { - case SpvExecutionModeVertexOrderCw: - case SpvExecutionModeVertexOrderCcw: + case spv::ExecutionMode::VertexOrderCw: + case spv::ExecutionMode::VertexOrderCcw: return true; default: return false; @@ -202,21 +204,22 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { "modes."; } break; - case SpvExecutionModelGeometry: + case spv::ExecutionModel::Geometry: if (!execution_modes || - 1 != std::count_if(execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { - switch (mode) { - case SpvExecutionModeInputPoints: - case SpvExecutionModeInputLines: - case SpvExecutionModeInputLinesAdjacency: - case SpvExecutionModeTriangles: - case SpvExecutionModeInputTrianglesAdjacency: - return true; - default: - return false; - } - })) { + 1 != std::count_if( + execution_modes->begin(), execution_modes->end(), + [](const spv::ExecutionMode& mode) { + switch (mode) { + case spv::ExecutionMode::InputPoints: + case spv::ExecutionMode::InputLines: + case spv::ExecutionMode::InputLinesAdjacency: + case spv::ExecutionMode::Triangles: + case spv::ExecutionMode::InputTrianglesAdjacency: + return true; + default: + return false; + } + })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Geometry execution model entry points must specify " "exactly one of InputPoints, InputLines, " @@ -225,11 +228,11 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { } if (!execution_modes || 1 != std::count_if(execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { + [](const spv::ExecutionMode& mode) { switch (mode) { - case SpvExecutionModeOutputPoints: - case SpvExecutionModeOutputLineStrip: - case SpvExecutionModeOutputTriangleStrip: + case spv::ExecutionMode::OutputPoints: + case spv::ExecutionMode::OutputLineStrip: + case spv::ExecutionMode::OutputTriangleStrip: return true; default: return false; @@ -241,14 +244,14 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { "OutputTriangleStrip execution modes."; } break; - case SpvExecutionModelMeshEXT: + case spv::ExecutionModel::MeshEXT: if (!execution_modes || 1 != std::count_if(execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { + [](const spv::ExecutionMode& mode) { switch (mode) { - case SpvExecutionModeOutputPoints: - case SpvExecutionModeOutputLinesEXT: - case SpvExecutionModeOutputTrianglesEXT: + case spv::ExecutionMode::OutputPoints: + case spv::ExecutionMode::OutputLinesEXT: + case spv::ExecutionMode::OutputTrianglesEXT: return true; default: return false; @@ -260,10 +263,10 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { "OutputTrianglesEXT Execution Modes."; } else if (2 != std::count_if( execution_modes->begin(), execution_modes->end(), - [](const SpvExecutionMode& mode) { + [](const spv::ExecutionMode& mode) { switch (mode) { - case SpvExecutionModeOutputPrimitivesEXT: - case SpvExecutionModeOutputVertices: + case spv::ExecutionMode::OutputPrimitivesEXT: + case spv::ExecutionMode::OutputVertices: return true; default: return false; @@ -281,23 +284,25 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) { if (spvIsVulkanEnv(_.context()->target_env)) { switch (execution_model) { - case SpvExecutionModelGLCompute: + case spv::ExecutionModel::GLCompute: if (!execution_modes || - !execution_modes->count(SpvExecutionModeLocalSize)) { + !execution_modes->count(spv::ExecutionMode::LocalSize)) { bool ok = false; for (auto& i : _.ordered_instructions()) { - if (i.opcode() == SpvOpDecorate) { + if (i.opcode() == spv::Op::OpDecorate) { if (i.operands().size() > 2) { - if (i.GetOperandAs<SpvDecoration>(1) == SpvDecorationBuiltIn && - i.GetOperandAs<SpvBuiltIn>(2) == SpvBuiltInWorkgroupSize) { + if (i.GetOperandAs<spv::Decoration>(1) == + spv::Decoration::BuiltIn && + i.GetOperandAs<spv::BuiltIn>(2) == + spv::BuiltIn::WorkgroupSize) { ok = true; break; } } } - if (i.opcode() == SpvOpExecutionModeId) { - const auto mode = i.GetOperandAs<SpvExecutionMode>(1); - if (mode == SpvExecutionModeLocalSizeId) { + if (i.opcode() == spv::Op::OpExecutionModeId) { + const auto mode = i.GetOperandAs<spv::ExecutionMode>(1); + if (mode == spv::ExecutionMode::LocalSizeId) { ok = true; break; } @@ -333,15 +338,15 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, "operand of an OpEntryPoint."; } - const auto mode = inst->GetOperandAs<SpvExecutionMode>(1); - if (inst->opcode() == SpvOpExecutionModeId) { + const auto mode = inst->GetOperandAs<spv::ExecutionMode>(1); + if (inst->opcode() == spv::Op::OpExecutionModeId) { size_t operand_count = inst->operands().size(); for (size_t i = 2; i < operand_count; ++i) { const auto operand_id = inst->GetOperandAs<uint32_t>(2); const auto* operand_inst = _.FindDef(operand_id); - if (mode == SpvExecutionModeSubgroupsPerWorkgroupId || - mode == SpvExecutionModeLocalSizeHintId || - mode == SpvExecutionModeLocalSizeId) { + if (mode == spv::ExecutionMode::SubgroupsPerWorkgroupId || + mode == spv::ExecutionMode::LocalSizeHintId || + mode == spv::ExecutionMode::LocalSizeId) { if (!spvOpcodeIsConstant(operand_inst->opcode())) { return _.diag(SPV_ERROR_INVALID_ID, inst) << "For OpExecutionModeId all Extra Operand ids must be " @@ -355,9 +360,9 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, "operands."; } } - } else if (mode == SpvExecutionModeSubgroupsPerWorkgroupId || - mode == SpvExecutionModeLocalSizeHintId || - mode == SpvExecutionModeLocalSizeId) { + } else if (mode == spv::ExecutionMode::SubgroupsPerWorkgroupId || + mode == spv::ExecutionMode::LocalSizeHintId || + mode == spv::ExecutionMode::LocalSizeId) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "OpExecutionMode is only valid when the Mode operand is an " "execution mode that takes no Extra Operands, or takes Extra " @@ -366,39 +371,39 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, const auto* models = _.GetExecutionModels(entry_point_id); switch (mode) { - case SpvExecutionModeInvocations: - case SpvExecutionModeInputPoints: - case SpvExecutionModeInputLines: - case SpvExecutionModeInputLinesAdjacency: - case SpvExecutionModeInputTrianglesAdjacency: - case SpvExecutionModeOutputLineStrip: - case SpvExecutionModeOutputTriangleStrip: + case spv::ExecutionMode::Invocations: + case spv::ExecutionMode::InputPoints: + case spv::ExecutionMode::InputLines: + case spv::ExecutionMode::InputLinesAdjacency: + case spv::ExecutionMode::InputTrianglesAdjacency: + case spv::ExecutionMode::OutputLineStrip: + case spv::ExecutionMode::OutputTriangleStrip: if (!std::all_of(models->begin(), models->end(), - [](const SpvExecutionModel& model) { - return model == SpvExecutionModelGeometry; + [](const spv::ExecutionModel& model) { + return model == spv::ExecutionModel::Geometry; })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Geometry execution " "model."; } break; - case SpvExecutionModeOutputPoints: - if (!std::all_of(models->begin(), models->end(), - [&_](const SpvExecutionModel& model) { - switch (model) { - case SpvExecutionModelGeometry: - return true; - case SpvExecutionModelMeshNV: - return _.HasCapability(SpvCapabilityMeshShadingNV); - case SpvExecutionModelMeshEXT: - return _.HasCapability( - SpvCapabilityMeshShadingEXT); - default: - return false; - } - })) { - if (_.HasCapability(SpvCapabilityMeshShadingNV) || - _.HasCapability(SpvCapabilityMeshShadingEXT)) { + case spv::ExecutionMode::OutputPoints: + if (!std::all_of( + models->begin(), models->end(), + [&_](const spv::ExecutionModel& model) { + switch (model) { + case spv::ExecutionModel::Geometry: + return true; + case spv::ExecutionModel::MeshNV: + return _.HasCapability(spv::Capability::MeshShadingNV); + case spv::ExecutionModel::MeshEXT: + return _.HasCapability(spv::Capability::MeshShadingEXT); + default: + return false; + } + })) { + if (_.HasCapability(spv::Capability::MeshShadingNV) || + _.HasCapability(spv::Capability::MeshShadingEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Geometry " "MeshNV or MeshEXT execution model."; @@ -410,32 +415,32 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, } } break; - case SpvExecutionModeSpacingEqual: - case SpvExecutionModeSpacingFractionalEven: - case SpvExecutionModeSpacingFractionalOdd: - case SpvExecutionModeVertexOrderCw: - case SpvExecutionModeVertexOrderCcw: - case SpvExecutionModePointMode: - case SpvExecutionModeQuads: - case SpvExecutionModeIsolines: + case spv::ExecutionMode::SpacingEqual: + case spv::ExecutionMode::SpacingFractionalEven: + case spv::ExecutionMode::SpacingFractionalOdd: + case spv::ExecutionMode::VertexOrderCw: + case spv::ExecutionMode::VertexOrderCcw: + case spv::ExecutionMode::PointMode: + case spv::ExecutionMode::Quads: + case spv::ExecutionMode::Isolines: if (!std::all_of( models->begin(), models->end(), - [](const SpvExecutionModel& model) { - return (model == SpvExecutionModelTessellationControl) || - (model == SpvExecutionModelTessellationEvaluation); + [](const spv::ExecutionModel& model) { + return (model == spv::ExecutionModel::TessellationControl) || + (model == spv::ExecutionModel::TessellationEvaluation); })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with a tessellation " "execution model."; } break; - case SpvExecutionModeTriangles: + case spv::ExecutionMode::Triangles: if (!std::all_of(models->begin(), models->end(), - [](const SpvExecutionModel& model) { + [](const spv::ExecutionModel& model) { switch (model) { - case SpvExecutionModelGeometry: - case SpvExecutionModelTessellationControl: - case SpvExecutionModelTessellationEvaluation: + case spv::ExecutionModel::Geometry: + case spv::ExecutionModel::TessellationControl: + case spv::ExecutionModel::TessellationEvaluation: return true; default: return false; @@ -446,25 +451,25 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, "tessellation execution model."; } break; - case SpvExecutionModeOutputVertices: - if (!std::all_of(models->begin(), models->end(), - [&_](const SpvExecutionModel& model) { - switch (model) { - case SpvExecutionModelGeometry: - case SpvExecutionModelTessellationControl: - case SpvExecutionModelTessellationEvaluation: - return true; - case SpvExecutionModelMeshNV: - return _.HasCapability(SpvCapabilityMeshShadingNV); - case SpvExecutionModelMeshEXT: - return _.HasCapability( - SpvCapabilityMeshShadingEXT); - default: - return false; - } - })) { - if (_.HasCapability(SpvCapabilityMeshShadingNV) || - _.HasCapability(SpvCapabilityMeshShadingEXT)) { + case spv::ExecutionMode::OutputVertices: + if (!std::all_of( + models->begin(), models->end(), + [&_](const spv::ExecutionModel& model) { + switch (model) { + case spv::ExecutionModel::Geometry: + case spv::ExecutionModel::TessellationControl: + case spv::ExecutionModel::TessellationEvaluation: + return true; + case spv::ExecutionModel::MeshNV: + return _.HasCapability(spv::Capability::MeshShadingNV); + case spv::ExecutionModel::MeshEXT: + return _.HasCapability(spv::Capability::MeshShadingEXT); + default: + return false; + } + })) { + if (_.HasCapability(spv::Capability::MeshShadingNV) || + _.HasCapability(spv::Capability::MeshShadingEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with a Geometry, " "tessellation, MeshNV or MeshEXT execution model."; @@ -475,13 +480,13 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, } } break; - case SpvExecutionModeOutputLinesEXT: - case SpvExecutionModeOutputTrianglesEXT: - case SpvExecutionModeOutputPrimitivesEXT: + case spv::ExecutionMode::OutputLinesEXT: + case spv::ExecutionMode::OutputTrianglesEXT: + case spv::ExecutionMode::OutputPrimitivesEXT: if (!std::all_of(models->begin(), models->end(), - [](const SpvExecutionModel& model) { - return (model == SpvExecutionModelMeshEXT || - model == SpvExecutionModelMeshNV); + [](const spv::ExecutionModel& model) { + return (model == spv::ExecutionModel::MeshEXT || + model == spv::ExecutionModel::MeshNV); })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the MeshEXT or MeshNV " @@ -489,74 +494,74 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, "model."; } break; - case SpvExecutionModePixelCenterInteger: - case SpvExecutionModeOriginUpperLeft: - case SpvExecutionModeOriginLowerLeft: - case SpvExecutionModeEarlyFragmentTests: - case SpvExecutionModeDepthReplacing: - case SpvExecutionModeDepthGreater: - case SpvExecutionModeDepthLess: - case SpvExecutionModeDepthUnchanged: - case SpvExecutionModePixelInterlockOrderedEXT: - case SpvExecutionModePixelInterlockUnorderedEXT: - case SpvExecutionModeSampleInterlockOrderedEXT: - case SpvExecutionModeSampleInterlockUnorderedEXT: - case SpvExecutionModeShadingRateInterlockOrderedEXT: - case SpvExecutionModeShadingRateInterlockUnorderedEXT: - case SpvExecutionModeEarlyAndLateFragmentTestsAMD: - case SpvExecutionModeStencilRefUnchangedFrontAMD: - case SpvExecutionModeStencilRefGreaterFrontAMD: - case SpvExecutionModeStencilRefLessFrontAMD: - case SpvExecutionModeStencilRefUnchangedBackAMD: - case SpvExecutionModeStencilRefGreaterBackAMD: - case SpvExecutionModeStencilRefLessBackAMD: + case spv::ExecutionMode::PixelCenterInteger: + case spv::ExecutionMode::OriginUpperLeft: + case spv::ExecutionMode::OriginLowerLeft: + case spv::ExecutionMode::EarlyFragmentTests: + case spv::ExecutionMode::DepthReplacing: + case spv::ExecutionMode::DepthGreater: + case spv::ExecutionMode::DepthLess: + case spv::ExecutionMode::DepthUnchanged: + case spv::ExecutionMode::PixelInterlockOrderedEXT: + case spv::ExecutionMode::PixelInterlockUnorderedEXT: + case spv::ExecutionMode::SampleInterlockOrderedEXT: + case spv::ExecutionMode::SampleInterlockUnorderedEXT: + case spv::ExecutionMode::ShadingRateInterlockOrderedEXT: + case spv::ExecutionMode::ShadingRateInterlockUnorderedEXT: + case spv::ExecutionMode::EarlyAndLateFragmentTestsAMD: + case spv::ExecutionMode::StencilRefUnchangedFrontAMD: + case spv::ExecutionMode::StencilRefGreaterFrontAMD: + case spv::ExecutionMode::StencilRefLessFrontAMD: + case spv::ExecutionMode::StencilRefUnchangedBackAMD: + case spv::ExecutionMode::StencilRefGreaterBackAMD: + case spv::ExecutionMode::StencilRefLessBackAMD: if (!std::all_of(models->begin(), models->end(), - [](const SpvExecutionModel& model) { - return model == SpvExecutionModelFragment; + [](const spv::ExecutionModel& model) { + return model == spv::ExecutionModel::Fragment; })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Fragment execution " "model."; } break; - case SpvExecutionModeLocalSizeHint: - case SpvExecutionModeVecTypeHint: - case SpvExecutionModeContractionOff: - case SpvExecutionModeLocalSizeHintId: + case spv::ExecutionMode::LocalSizeHint: + case spv::ExecutionMode::VecTypeHint: + case spv::ExecutionMode::ContractionOff: + case spv::ExecutionMode::LocalSizeHintId: if (!std::all_of(models->begin(), models->end(), - [](const SpvExecutionModel& model) { - return model == SpvExecutionModelKernel; + [](const spv::ExecutionModel& model) { + return model == spv::ExecutionModel::Kernel; })) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with the Kernel execution " "model."; } break; - case SpvExecutionModeLocalSize: - case SpvExecutionModeLocalSizeId: - if (mode == SpvExecutionModeLocalSizeId && !_.IsLocalSizeIdAllowed()) + case spv::ExecutionMode::LocalSize: + case spv::ExecutionMode::LocalSizeId: + if (mode == spv::ExecutionMode::LocalSizeId && !_.IsLocalSizeIdAllowed()) return _.diag(SPV_ERROR_INVALID_DATA, inst) << "LocalSizeId mode is not allowed by the current environment."; - if (!std::all_of(models->begin(), models->end(), - [&_](const SpvExecutionModel& model) { - switch (model) { - case SpvExecutionModelKernel: - case SpvExecutionModelGLCompute: - return true; - case SpvExecutionModelTaskNV: - case SpvExecutionModelMeshNV: - return _.HasCapability(SpvCapabilityMeshShadingNV); - case SpvExecutionModelTaskEXT: - case SpvExecutionModelMeshEXT: - return _.HasCapability( - SpvCapabilityMeshShadingEXT); - default: - return false; - } - })) { - if (_.HasCapability(SpvCapabilityMeshShadingNV) || - _.HasCapability(SpvCapabilityMeshShadingEXT)) { + if (!std::all_of( + models->begin(), models->end(), + [&_](const spv::ExecutionModel& model) { + switch (model) { + case spv::ExecutionModel::Kernel: + case spv::ExecutionModel::GLCompute: + return true; + case spv::ExecutionModel::TaskNV: + case spv::ExecutionModel::MeshNV: + return _.HasCapability(spv::Capability::MeshShadingNV); + case spv::ExecutionModel::TaskEXT: + case spv::ExecutionModel::MeshEXT: + return _.HasCapability(spv::Capability::MeshShadingEXT); + default: + return false; + } + })) { + if (_.HasCapability(spv::Capability::MeshShadingNV) || + _.HasCapability(spv::Capability::MeshShadingEXT)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Execution mode can only be used with a Kernel, GLCompute, " "MeshNV, MeshEXT, TaskNV or TaskEXT execution model."; @@ -572,13 +577,13 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _, } if (spvIsVulkanEnv(_.context()->target_env)) { - if (mode == SpvExecutionModeOriginLowerLeft) { + if (mode == spv::ExecutionMode::OriginLowerLeft) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4653) << "In the Vulkan environment, the OriginLowerLeft execution mode " "must not be used."; } - if (mode == SpvExecutionModePixelCenterInteger) { + if (mode == spv::ExecutionMode::PixelCenterInteger) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4654) << "In the Vulkan environment, the PixelCenterInteger execution " @@ -593,29 +598,30 @@ spv_result_t ValidateMemoryModel(ValidationState_t& _, const Instruction* inst) { // Already produced an error if multiple memory model instructions are // present. - if (_.memory_model() != SpvMemoryModelVulkanKHR && - _.HasCapability(SpvCapabilityVulkanMemoryModelKHR)) { + if (_.memory_model() != spv::MemoryModel::VulkanKHR && + _.HasCapability(spv::Capability::VulkanMemoryModelKHR)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "VulkanMemoryModelKHR capability must only be specified if " "the VulkanKHR memory model is used."; } if (spvIsOpenCLEnv(_.context()->target_env)) { - if ((_.addressing_model() != SpvAddressingModelPhysical32) && - (_.addressing_model() != SpvAddressingModelPhysical64)) { + if ((_.addressing_model() != spv::AddressingModel::Physical32) && + (_.addressing_model() != spv::AddressingModel::Physical64)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Addressing model must be Physical32 or Physical64 " << "in the OpenCL environment."; } - if (_.memory_model() != SpvMemoryModelOpenCL) { + if (_.memory_model() != spv::MemoryModel::OpenCL) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Memory model must be OpenCL in the OpenCL environment."; } } if (spvIsVulkanEnv(_.context()->target_env)) { - if ((_.addressing_model() != SpvAddressingModelLogical) && - (_.addressing_model() != SpvAddressingModelPhysicalStorageBuffer64)) { + if ((_.addressing_model() != spv::AddressingModel::Logical) && + (_.addressing_model() != + spv::AddressingModel::PhysicalStorageBuffer64)) { return _.diag(SPV_ERROR_INVALID_DATA, inst) << _.VkErrorID(4635) << "Addressing model must be Logical or PhysicalStorageBuffer64 " @@ -629,14 +635,14 @@ spv_result_t ValidateMemoryModel(ValidationState_t& _, spv_result_t ModeSettingPass(ValidationState_t& _, const Instruction* inst) { switch (inst->opcode()) { - case SpvOpEntryPoint: + case spv::Op::OpEntryPoint: if (auto error = ValidateEntryPoint(_, inst)) return error; break; - case SpvOpExecutionMode: - case SpvOpExecutionModeId: + case spv::Op::OpExecutionMode: + case spv::Op::OpExecutionModeId: if (auto error = ValidateExecutionMode(_, inst)) return error; break; - case SpvOpMemoryModel: + case spv::Op::OpMemoryModel: if (auto error = ValidateMemoryModel(_, inst)) return error; break; default: |