diff options
Diffstat (limited to 'source/val/validate_instruction.cpp')
-rw-r--r-- | source/val/validate_instruction.cpp | 99 |
1 files changed, 49 insertions, 50 deletions
diff --git a/source/val/validate_instruction.cpp b/source/val/validate_instruction.cpp index 1b7847ca..767c0cee 100644 --- a/source/val/validate_instruction.cpp +++ b/source/val/validate_instruction.cpp @@ -44,13 +44,13 @@ namespace { std::string ToString(const CapabilitySet& capabilities, const AssemblyGrammar& grammar) { std::stringstream ss; - capabilities.ForEach([&grammar, &ss](spv::Capability cap) { + capabilities.ForEach([&grammar, &ss](SpvCapability cap) { spv_operand_desc desc; - if (SPV_SUCCESS == grammar.lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, - uint32_t(cap), &desc)) + if (SPV_SUCCESS == + grammar.lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, cap, &desc)) ss << desc->name << " "; else - ss << uint32_t(cap) << " "; + ss << cap << " "; }); return ss.str(); } @@ -60,18 +60,18 @@ std::string ToString(const CapabilitySet& capabilities, // the opcode may only be used if at least one of the capabilities is specified // by the module. CapabilitySet EnablingCapabilitiesForOp(const ValidationState_t& state, - spv::Op opcode) { + SpvOp opcode) { // Exceptions for SPV_AMD_shader_ballot switch (opcode) { // Normally these would require Group capability - case spv::Op::OpGroupIAddNonUniformAMD: - case spv::Op::OpGroupFAddNonUniformAMD: - case spv::Op::OpGroupFMinNonUniformAMD: - case spv::Op::OpGroupUMinNonUniformAMD: - case spv::Op::OpGroupSMinNonUniformAMD: - case spv::Op::OpGroupFMaxNonUniformAMD: - case spv::Op::OpGroupUMaxNonUniformAMD: - case spv::Op::OpGroupSMaxNonUniformAMD: + case SpvOpGroupIAddNonUniformAMD: + case SpvOpGroupFAddNonUniformAMD: + case SpvOpGroupFMinNonUniformAMD: + case SpvOpGroupUMinNonUniformAMD: + case SpvOpGroupSMinNonUniformAMD: + case SpvOpGroupFMaxNonUniformAMD: + case SpvOpGroupUMaxNonUniformAMD: + case SpvOpGroupSMaxNonUniformAMD: if (state.HasExtension(kSPV_AMD_shader_ballot)) return CapabilitySet(); break; default: @@ -151,10 +151,10 @@ spv_result_t CheckRequiredCapabilities(ValidationState_t& state, // not implemented yet. This rule is independent of target environment. // See https://github.com/KhronosGroup/SPIRV-Tools/issues/365 if (operand.type == SPV_OPERAND_TYPE_BUILT_IN) { - switch (spv::BuiltIn(word)) { - case spv::BuiltIn::PointSize: - case spv::BuiltIn::ClipDistance: - case spv::BuiltIn::CullDistance: + switch (word) { + case SpvBuiltInPointSize: + case SpvBuiltInClipDistance: + case SpvBuiltInCullDistance: return SPV_SUCCESS; default: break; @@ -166,7 +166,7 @@ spv_result_t CheckRequiredCapabilities(ValidationState_t& state, } } else if (operand.type == SPV_OPERAND_TYPE_GROUP_OPERATION && state.features().group_ops_reduce_and_scans && - (word <= uint32_t(spv::GroupOperation::ExclusiveScan))) { + (word <= uint32_t(SpvGroupOperationExclusiveScan))) { // Allow certain group operations if requested. return SPV_SUCCESS; } @@ -178,16 +178,15 @@ spv_result_t CheckRequiredCapabilities(ValidationState_t& state, if (lookup_result == SPV_SUCCESS) { // Allow FPRoundingMode decoration if requested. if (operand.type == SPV_OPERAND_TYPE_DECORATION && - spv::Decoration(operand_desc->value) == - spv::Decoration::FPRoundingMode) { + operand_desc->value == SpvDecorationFPRoundingMode) { if (state.features().free_fp_rounding_mode) return SPV_SUCCESS; // Vulkan API requires more capabilities on rounding mode. if (spvIsVulkanEnv(state.context()->target_env)) { - enabling_capabilities.Add(spv::Capability::StorageUniformBufferBlock16); - enabling_capabilities.Add(spv::Capability::StorageUniform16); - enabling_capabilities.Add(spv::Capability::StoragePushConstant16); - enabling_capabilities.Add(spv::Capability::StorageInputOutput16); + enabling_capabilities.Add(SpvCapabilityStorageUniformBufferBlock16); + enabling_capabilities.Add(SpvCapabilityStorageUniform16); + enabling_capabilities.Add(SpvCapabilityStoragePushConstant16); + enabling_capabilities.Add(SpvCapabilityStorageInputOutput16); } } else { enabling_capabilities = state.grammar().filterCapsAgainstTargetEnv( @@ -198,7 +197,7 @@ spv_result_t CheckRequiredCapabilities(ValidationState_t& state, // registers a capability with the module *before* checking capabilities. // So in the case of an OpCapability instruction, don't bother checking // enablement by another capability. - if (inst->opcode() != spv::Op::OpCapability) { + if (inst->opcode() != SpvOpCapability) { const bool enabled_by_cap = state.HasAnyOfCapabilities(enabling_capabilities); if (!enabling_capabilities.IsEmpty() && !enabled_by_cap) { @@ -219,14 +218,14 @@ spv_result_t CheckRequiredCapabilities(ValidationState_t& state, // is explicitly reserved in the SPIR-V core spec. Otherwise return // SPV_SUCCESS. spv_result_t ReservedCheck(ValidationState_t& _, const Instruction* inst) { - const spv::Op opcode = inst->opcode(); + const SpvOp opcode = inst->opcode(); switch (opcode) { // These instructions are enabled by a capability, but should never // be used anyway. - case spv::Op::OpImageSparseSampleProjImplicitLod: - case spv::Op::OpImageSparseSampleProjExplicitLod: - case spv::Op::OpImageSparseSampleProjDrefImplicitLod: - case spv::Op::OpImageSparseSampleProjDrefExplicitLod: { + case SpvOpImageSparseSampleProjImplicitLod: + case SpvOpImageSparseSampleProjExplicitLod: + case SpvOpImageSparseSampleProjDrefImplicitLod: + case SpvOpImageSparseSampleProjDrefExplicitLod: { spv_opcode_desc inst_desc; _.grammar().lookupOpcode(opcode, &inst_desc); return _.diag(SPV_ERROR_INVALID_BINARY, inst) @@ -242,7 +241,7 @@ spv_result_t ReservedCheck(ValidationState_t& _, const Instruction* inst) { // instruction is invalid because the required capability isn't declared // in the module. spv_result_t CapabilityCheck(ValidationState_t& _, const Instruction* inst) { - const spv::Op opcode = inst->opcode(); + const SpvOp opcode = inst->opcode(); CapabilitySet opcode_caps = EnablingCapabilitiesForOp(_, opcode); if (!_.HasAnyOfCapabilities(opcode_caps)) { return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst) @@ -300,7 +299,7 @@ spv_result_t VersionCheck(ValidationState_t& _, const Instruction* inst) { // OpTerminateInvocation is special because it is enabled by Shader // capability, but also requires an extension and/or version check. const bool capability_check_is_sufficient = - inst->opcode() != spv::Op::OpTerminateInvocation; + inst->opcode() != SpvOpTerminateInvocation; if (capability_check_is_sufficient && (inst_desc->numCapabilities > 0u)) { // We already checked that the direct capability dependency has been @@ -358,7 +357,7 @@ spv_result_t LimitCheckIdBound(ValidationState_t& _, const Instruction* inst) { // Checks that the number of OpTypeStruct members is within the limit. spv_result_t LimitCheckStruct(ValidationState_t& _, const Instruction* inst) { - if (spv::Op::OpTypeStruct != inst->opcode()) { + if (SpvOpTypeStruct != inst->opcode()) { return SPV_SUCCESS; } @@ -383,7 +382,7 @@ spv_result_t LimitCheckStruct(ValidationState_t& _, const Instruction* inst) { for (size_t word_i = 2; word_i < inst->words().size(); ++word_i) { auto member = inst->word(word_i); auto memberTypeInstr = _.FindDef(member); - if (memberTypeInstr && spv::Op::OpTypeStruct == memberTypeInstr->opcode()) { + if (memberTypeInstr && SpvOpTypeStruct == memberTypeInstr->opcode()) { max_member_depth = std::max( max_member_depth, _.struct_nesting_depth(memberTypeInstr->id())); } @@ -403,7 +402,7 @@ spv_result_t LimitCheckStruct(ValidationState_t& _, const Instruction* inst) { // Checks that the number of (literal, label) pairs in OpSwitch is within // the limit. spv_result_t LimitCheckSwitch(ValidationState_t& _, const Instruction* inst) { - if (spv::Op::OpSwitch == inst->opcode()) { + if (SpvOpSwitch == inst->opcode()) { // The instruction syntax is as follows: // OpSwitch <selector ID> <Default ID> literal label literal label ... // literal,label pairs come after the first 2 operands. @@ -423,8 +422,8 @@ spv_result_t LimitCheckSwitch(ValidationState_t& _, const Instruction* inst) { // Ensure the number of variables of the given class does not exceed the // limit. spv_result_t LimitCheckNumVars(ValidationState_t& _, const uint32_t var_id, - const spv::StorageClass storage_class) { - if (spv::StorageClass::Function == storage_class) { + const SpvStorageClass storage_class) { + if (SpvStorageClassFunction == storage_class) { _.registerLocalVariable(var_id); const uint32_t num_local_vars_limit = _.options()->universal_limits_.max_local_variables; @@ -463,29 +462,29 @@ spv_result_t CheckIfKnownExtension(ValidationState_t& _, } // namespace spv_result_t InstructionPass(ValidationState_t& _, const Instruction* inst) { - const spv::Op opcode = inst->opcode(); - if (opcode == spv::Op::OpExtension) { + const SpvOp opcode = inst->opcode(); + if (opcode == SpvOpExtension) { CheckIfKnownExtension(_, inst); - } else if (opcode == spv::Op::OpCapability) { - _.RegisterCapability(inst->GetOperandAs<spv::Capability>(0)); - } else if (opcode == spv::Op::OpMemoryModel) { + } else if (opcode == SpvOpCapability) { + _.RegisterCapability(inst->GetOperandAs<SpvCapability>(0)); + } else if (opcode == SpvOpMemoryModel) { if (_.has_memory_model_specified()) { return _.diag(SPV_ERROR_INVALID_LAYOUT, inst) << "OpMemoryModel should only be provided once."; } - _.set_addressing_model(inst->GetOperandAs<spv::AddressingModel>(0)); - _.set_memory_model(inst->GetOperandAs<spv::MemoryModel>(1)); - } else if (opcode == spv::Op::OpExecutionMode) { + _.set_addressing_model(inst->GetOperandAs<SpvAddressingModel>(0)); + _.set_memory_model(inst->GetOperandAs<SpvMemoryModel>(1)); + } else if (opcode == SpvOpExecutionMode) { const uint32_t entry_point = inst->word(1); _.RegisterExecutionModeForEntryPoint(entry_point, - spv::ExecutionMode(inst->word(2))); - } else if (opcode == spv::Op::OpVariable) { - const auto storage_class = inst->GetOperandAs<spv::StorageClass>(2); + SpvExecutionMode(inst->word(2))); + } else if (opcode == SpvOpVariable) { + const auto storage_class = inst->GetOperandAs<SpvStorageClass>(2); if (auto error = LimitCheckNumVars(_, inst->id(), storage_class)) { return error; } - } else if (opcode == spv::Op::OpSamplerImageAddressingModeNV) { - if (!_.HasCapability(spv::Capability::BindlessTextureNV)) { + } else if (opcode == SpvOpSamplerImageAddressingModeNV) { + if (!_.HasCapability(SpvCapabilityBindlessTextureNV)) { return _.diag(SPV_ERROR_MISSING_EXTENSION, inst) << "OpSamplerImageAddressingModeNV supported only with extension " "SPV_NV_bindless_texture"; |