| // Copyright (c) 2017 Google Inc. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| // Validates correctness of conversion instructions. | |
| #include <climits> | |
| #include "source/opcode.h" | |
| #include "source/spirv_constant.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 { | |
| namespace { | |
| bool IsNumericScalarOrVectorType(ValidationState_t& _, uint32_t type_id) { | |
| return _.IsFloatScalarType(type_id) || _.IsFloatVectorType(type_id) || | |
| _.IsIntScalarType(type_id) || _.IsIntVectorType(type_id); | |
| } | |
| bool IsIEEEOrAlternativeFloatTypeAllowedForOCPMicroscalingFConvert( | |
| ValidationState_t& _, uint32_t type_id) { | |
| const uint32_t component_type = _.GetComponentType(type_id); | |
| const Instruction* inst = _.FindDef(component_type); | |
| if (!inst || inst->opcode() != spv::Op::OpTypeFloat) return false; | |
| if (inst->words().size() <= 3) return true; | |
| const auto encoding = inst->GetOperandAs<spv::FPEncoding>(2); | |
| return encoding == spv::FPEncoding::Float8E4M3EXT || | |
| encoding == spv::FPEncoding::Float8E5M2EXT || | |
| encoding == spv::FPEncoding::BFloat16KHR; | |
| } | |
| spv_result_t ValidateVulkanOCPMicroscalingFloatIntConversion( | |
| ValidationState_t& _, const Instruction* inst, uint32_t float_type) { | |
| if (spvIsVulkanEnv(_.context()->target_env) && | |
| _.ContainsOCPMicroscalingType(float_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << _.VkErrorID(12465) << spvOpcodeString(inst->opcode()) | |
| << " must not consume or produce OCP microscaling types in the " | |
| "Vulkan environment."; | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| bool HasCoopMatTranspose(ValidationState_t& _, uint32_t id) { | |
| return _.HasDecoration(id, spv::Decoration::CooperativeMatrixTransposeEXT); | |
| } | |
| } // namespace | |
| spv_result_t ValidateShaderBitWidth(ValidationState_t& _, | |
| const Instruction* inst) { | |
| if (_.HasCapability(spv::Capability::Shader)) { | |
| if (_.ContainsLimitedUseIntOrFloatType(inst->type_id()) || | |
| _.ContainsLimitedUseIntOrFloatType(_.GetOperandTypeId(inst, 2u))) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "8- or 16-bit types can only be used with width-only " | |
| "conversions"; | |
| } | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateConvertFToU(ValidationState_t& _, const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsUnsignedIntScalarType(result_type) && | |
| !_.IsUnsignedIntVectorType(result_type) && | |
| !_.IsUnsignedIntCooperativeMatrixType(result_type) && | |
| !_.IsUnsignedIntCooperativeVectorNVType(result_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected unsigned int scalar or vector type as Result Type: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| if (!input_type || | |
| (!_.IsFloatScalarType(input_type) && !_.IsFloatVectorType(input_type) && | |
| !_.IsFloatCooperativeMatrixType(input_type) && | |
| !_.IsFloatCooperativeVectorNVType(input_type))) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be float scalar or vector: " | |
| << spvOpcodeString(opcode); | |
| if (_.IsCooperativeVectorNVType(result_type) || | |
| _.IsCooperativeVectorNVType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else if (_.IsCooperativeMatrixType(result_type) || | |
| _.IsCooperativeMatrixType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true, | |
| HasCoopMatTranspose(_, inst->id())); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else { | |
| if (_.GetDimension(result_type) != _.GetDimension(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (auto error = | |
| ValidateVulkanOCPMicroscalingFloatIntConversion(_, inst, input_type)) | |
| return error; | |
| if (auto error = ValidateShaderBitWidth(_, inst)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateConvertFToS(ValidationState_t& _, const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type) && | |
| !_.IsIntCooperativeMatrixType(result_type) && | |
| !_.IsIntCooperativeVectorNVType(result_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected int scalar or vector type as Result Type: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| if (!input_type || | |
| (!_.IsFloatScalarType(input_type) && !_.IsFloatVectorType(input_type) && | |
| !_.IsFloatCooperativeMatrixType(input_type) && | |
| !_.IsFloatCooperativeVectorNVType(input_type))) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be float scalar or vector: " | |
| << spvOpcodeString(opcode); | |
| if (_.IsCooperativeVectorNVType(result_type) || | |
| _.IsCooperativeVectorNVType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else if (_.IsCooperativeMatrixType(result_type) || | |
| _.IsCooperativeMatrixType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true, | |
| HasCoopMatTranspose(_, inst->id())); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else { | |
| if (_.GetDimension(result_type) != _.GetDimension(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (auto error = | |
| ValidateVulkanOCPMicroscalingFloatIntConversion(_, inst, input_type)) | |
| return error; | |
| if (auto error = ValidateShaderBitWidth(_, inst)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateConvertIntToF(ValidationState_t& _, | |
| const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsFloatScalarType(result_type) && !_.IsFloatVectorType(result_type) && | |
| !_.IsFloatCooperativeMatrixType(result_type) && | |
| !_.IsFloatCooperativeVectorNVType(result_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected float scalar or vector type as Result Type: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| if (!input_type || | |
| (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type) && | |
| !_.IsIntCooperativeMatrixType(input_type) && | |
| !_.IsIntCooperativeVectorNVType(input_type))) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be int scalar or vector: " | |
| << spvOpcodeString(opcode); | |
| if (_.IsCooperativeVectorNVType(result_type) || | |
| _.IsCooperativeVectorNVType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else if (_.IsCooperativeMatrixType(result_type) || | |
| _.IsCooperativeMatrixType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true, | |
| HasCoopMatTranspose(_, inst->id())); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else { | |
| if (_.GetDimension(result_type) != _.GetDimension(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (auto error = | |
| ValidateVulkanOCPMicroscalingFloatIntConversion(_, inst, result_type)) | |
| return error; | |
| if (auto error = ValidateShaderBitWidth(_, inst)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateUConvert(ValidationState_t& _, const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsUnsignedIntScalarType(result_type) && | |
| !_.IsUnsignedIntVectorType(result_type) && | |
| !_.IsUnsignedIntCooperativeMatrixType(result_type) && | |
| !_.IsUnsignedIntCooperativeVectorNVType(result_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected unsigned int scalar or vector type as Result Type: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| if (!input_type || | |
| (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type) && | |
| !_.IsIntCooperativeMatrixType(input_type) && | |
| !_.IsIntCooperativeVectorNVType(input_type))) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be int scalar or vector: " | |
| << spvOpcodeString(opcode); | |
| if (_.IsCooperativeVectorNVType(result_type) || | |
| _.IsCooperativeVectorNVType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else if (_.IsCooperativeMatrixType(result_type) || | |
| _.IsCooperativeMatrixType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true, | |
| HasCoopMatTranspose(_, inst->id())); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else { | |
| if (_.GetDimension(result_type) != _.GetDimension(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have different bit width from Result " | |
| "Type: " | |
| << spvOpcodeString(opcode); | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateSConvert(ValidationState_t& _, const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type) && | |
| !_.IsIntCooperativeMatrixType(result_type) && | |
| !_.IsIntCooperativeVectorNVType(result_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected int scalar or vector type as Result Type: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| if (!input_type || | |
| (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type) && | |
| !_.IsIntCooperativeMatrixType(input_type) && | |
| !_.IsIntCooperativeVectorNVType(input_type))) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be int scalar or vector: " | |
| << spvOpcodeString(opcode); | |
| if (_.IsCooperativeVectorNVType(result_type) || | |
| _.IsCooperativeVectorNVType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else if (_.IsCooperativeMatrixType(result_type) || | |
| _.IsCooperativeMatrixType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true, | |
| HasCoopMatTranspose(_, inst->id())); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else { | |
| if (_.GetDimension(result_type) != _.GetDimension(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (_.GetBitWidth(result_type) == _.GetBitWidth(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have different bit width from Result " | |
| "Type: " | |
| << spvOpcodeString(opcode); | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateFConvert(ValidationState_t& _, const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsFloatScalarType(result_type) && !_.IsFloatVectorType(result_type) && | |
| !_.IsFloatCooperativeMatrixType(result_type) && | |
| !_.IsFloatCooperativeVectorNVType(result_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected float scalar or vector type as Result Type: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| if (!input_type || | |
| (!_.IsFloatScalarType(input_type) && !_.IsFloatVectorType(input_type) && | |
| !_.IsFloatCooperativeMatrixType(input_type) && | |
| !_.IsFloatCooperativeVectorNVType(input_type))) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be float scalar or vector: " | |
| << spvOpcodeString(opcode); | |
| if (_.IsCooperativeVectorNVType(result_type) || | |
| _.IsCooperativeVectorNVType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else if (_.IsCooperativeMatrixType(result_type) || | |
| _.IsCooperativeMatrixType(input_type)) { | |
| spv_result_t ret = | |
| _.CooperativeMatrixShapesMatch(inst, result_type, input_type, true, | |
| HasCoopMatTranspose(_, inst->id())); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } else { | |
| if (_.GetDimension(result_type) != _.GetDimension(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| // Scalar type | |
| const uint32_t resScalarType = _.GetComponentType(result_type); | |
| const uint32_t inputScalartype = _.GetComponentType(input_type); | |
| if (resScalarType == inputScalartype) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected component type of Value to be different from " | |
| "component type of Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (spvIsVulkanEnv(_.context()->target_env)) { | |
| if (_.ContainsOCPMicroscalingType(result_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << _.VkErrorID(12466) << spvOpcodeString(opcode) | |
| << " must not produce OCP microscaling types in the Vulkan " | |
| "environment."; | |
| } | |
| if (_.ContainsOCPMicroscalingType(input_type) && | |
| !IsIEEEOrAlternativeFloatTypeAllowedForOCPMicroscalingFConvert( | |
| _, result_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << _.VkErrorID(12467) << spvOpcodeString(opcode) | |
| << " consuming an OCP microscaling type in the Vulkan " | |
| "environment must produce IEEE 754, Float8E4M3EXT, " | |
| "Float8E5M2EXT, or BFloat16KHR."; | |
| } | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateQuantizeToF16(ValidationState_t& _, | |
| const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if ((!_.IsFloatScalarType(result_type) && | |
| !_.IsFloatVectorType(result_type)) || | |
| _.GetBitWidth(result_type) != 32) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected 32-bit float scalar or vector type as Result Type: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| if (input_type != result_type) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input type to be equal to Result Type: " | |
| << spvOpcodeString(opcode); | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateConvertPtrToU(ValidationState_t& _, | |
| const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| const bool has_masked_gather_scatter = | |
| _.HasCapability(spv::Capability::MaskedGatherScatterINTEL); | |
| bool valid_result_type = _.IsUnsignedIntScalarType(result_type); | |
| if (!valid_result_type && has_masked_gather_scatter) { | |
| valid_result_type = _.IsUnsignedIntVectorType(result_type); | |
| } | |
| if (!valid_result_type) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected unsigned int scalar type as Result Type" | |
| << (has_masked_gather_scatter ? " (or vector of unsigned int with " | |
| "MaskedGatherScatterINTEL)" | |
| : "") | |
| << ": " << spvOpcodeString(opcode); | |
| } | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| bool valid_input_type = _.IsPointerType(input_type); | |
| if (!valid_input_type && has_masked_gather_scatter && input_type) { | |
| if (_.IsVectorType(input_type)) { | |
| const uint32_t component_type = _.GetComponentType(input_type); | |
| valid_input_type = _.IsPointerType(component_type); | |
| } | |
| } | |
| if (!valid_input_type) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be a pointer" | |
| << (has_masked_gather_scatter | |
| ? " (or vector of pointers with MaskedGatherScatterINTEL)" | |
| : "") | |
| << ": " << spvOpcodeString(opcode); | |
| } | |
| if (has_masked_gather_scatter && _.IsVectorType(result_type)) { | |
| if (!_.IsVectorType(input_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be a vector when Result Type is a vector: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (_.GetDimension(result_type) != _.GetDimension(input_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| } | |
| if (_.addressing_model() == spv::AddressingModel::Logical) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Logical addressing not supported: " << spvOpcodeString(opcode); | |
| if (_.addressing_model() == spv::AddressingModel::PhysicalStorageBuffer64) { | |
| uint32_t ptr_type = input_type; | |
| if (_.IsVectorType(input_type)) { | |
| ptr_type = _.GetComponentType(input_type); | |
| } | |
| spv::StorageClass input_storage_class; | |
| uint32_t input_data_type = 0; | |
| _.GetPointerTypeInfo(ptr_type, &input_data_type, &input_storage_class); | |
| if (input_storage_class != spv::StorageClass::PhysicalStorageBuffer) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pointer storage class must be PhysicalStorageBuffer: " | |
| << spvOpcodeString(opcode); | |
| if (spvIsVulkanEnv(_.context()->target_env)) { | |
| if (_.GetBitWidth(result_type) != 64) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << _.VkErrorID(4710) | |
| << "PhysicalStorageBuffer64 addressing mode requires the " | |
| "result integer type to have a 64-bit width for Vulkan " | |
| "environment."; | |
| } | |
| } | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateSatConvertInt(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsIntScalarType(result_type) && !_.IsIntVectorType(result_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected int scalar or vector type as Result Type: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, 2); | |
| if (!input_type || | |
| (!_.IsIntScalarType(input_type) && !_.IsIntVectorType(input_type))) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected int scalar or vector as input: " | |
| << spvOpcodeString(opcode); | |
| if (_.GetDimension(result_type) != _.GetDimension(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateConvertUToPtr(ValidationState_t& _, | |
| const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| const bool has_masked_gather_scatter = | |
| _.HasCapability(spv::Capability::MaskedGatherScatterINTEL); | |
| bool valid_result_type = _.IsPointerType(result_type); | |
| if (!valid_result_type && has_masked_gather_scatter) { | |
| if (_.IsVectorType(result_type)) { | |
| const uint32_t component_type = _.GetComponentType(result_type); | |
| valid_result_type = _.IsPointerType(component_type); | |
| } | |
| } | |
| if (!valid_result_type) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Result Type to be a pointer" | |
| << (has_masked_gather_scatter | |
| ? " (or vector of pointers with MaskedGatherScatterINTEL)" | |
| : "") | |
| << ": " << spvOpcodeString(opcode); | |
| } | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| bool valid_input_type = input_type && _.IsIntScalarType(input_type); | |
| if (!valid_input_type && has_masked_gather_scatter && input_type) { | |
| valid_input_type = _.IsIntVectorType(input_type); | |
| } | |
| if (!valid_input_type) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected int scalar as input" | |
| << (has_masked_gather_scatter | |
| ? " (or vector of int with MaskedGatherScatterINTEL)" | |
| : "") | |
| << ": " << spvOpcodeString(opcode); | |
| } | |
| if (has_masked_gather_scatter && _.IsVectorType(result_type)) { | |
| if (!_.IsVectorType(input_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be a vector when Result Type is a vector: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (_.GetDimension(result_type) != _.GetDimension(input_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| } | |
| if (_.addressing_model() == spv::AddressingModel::Logical) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Logical addressing not supported: " << spvOpcodeString(opcode); | |
| if (_.addressing_model() == spv::AddressingModel::PhysicalStorageBuffer64) { | |
| uint32_t ptr_type = result_type; | |
| if (_.IsVectorType(result_type)) { | |
| ptr_type = _.GetComponentType(result_type); | |
| } | |
| spv::StorageClass result_storage_class; | |
| uint32_t result_data_type = 0; | |
| _.GetPointerTypeInfo(ptr_type, &result_data_type, &result_storage_class); | |
| if (result_storage_class != spv::StorageClass::PhysicalStorageBuffer) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pointer storage class must be PhysicalStorageBuffer: " | |
| << spvOpcodeString(opcode); | |
| if (spvIsVulkanEnv(_.context()->target_env)) { | |
| if (_.GetBitWidth(input_type) != 64) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << _.VkErrorID(4710) | |
| << "PhysicalStorageBuffer64 addressing mode requires the " | |
| "input integer to have a 64-bit width for Vulkan " | |
| "environment."; | |
| } | |
| } | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidatePtrCastToGeneric(ValidationState_t& _, | |
| const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| spv::StorageClass result_storage_class; | |
| uint32_t result_data_type = 0; | |
| if (!_.GetPointerTypeInfo(result_type, &result_data_type, | |
| &result_storage_class)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Result Type to be a pointer: " | |
| << spvOpcodeString(opcode); | |
| if (result_storage_class != spv::StorageClass::Generic) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Result Type to have storage class Generic: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| spv::StorageClass input_storage_class; | |
| uint32_t input_data_type = 0; | |
| if (!_.GetPointerTypeInfo(input_type, &input_data_type, &input_storage_class)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be a pointer: " << spvOpcodeString(opcode); | |
| if (input_storage_class != spv::StorageClass::Workgroup && | |
| input_storage_class != spv::StorageClass::CrossWorkgroup && | |
| input_storage_class != spv::StorageClass::Function && | |
| input_storage_class != spv::StorageClass::CodeSectionINTEL) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have storage class Workgroup, " | |
| << "CrossWorkgroup, Function or CodeSectionINTEL: " | |
| << spvOpcodeString(opcode); | |
| if (result_data_type != input_data_type) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input and Result Type to point to the same type: " | |
| << spvOpcodeString(opcode); | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateGenericCastToPtr(ValidationState_t& _, | |
| const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| spv::StorageClass result_storage_class; | |
| uint32_t result_data_type = 0; | |
| if (!_.GetPointerTypeInfo(result_type, &result_data_type, | |
| &result_storage_class)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Result Type to be a pointer: " | |
| << spvOpcodeString(opcode); | |
| if (result_storage_class != spv::StorageClass::Workgroup && | |
| result_storage_class != spv::StorageClass::CrossWorkgroup && | |
| result_storage_class != spv::StorageClass::Function && | |
| result_storage_class != spv::StorageClass::CodeSectionINTEL) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Result Type to have storage class Workgroup, " | |
| << "CrossWorkgroup, Function or CodeSectionINTEL: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| spv::StorageClass input_storage_class; | |
| uint32_t input_data_type = 0; | |
| if (!_.GetPointerTypeInfo(input_type, &input_data_type, &input_storage_class)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be a pointer: " << spvOpcodeString(opcode); | |
| if (input_storage_class != spv::StorageClass::Generic) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have storage class Generic: " | |
| << spvOpcodeString(opcode); | |
| if (result_data_type != input_data_type) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input and Result Type to point to the same type: " | |
| << spvOpcodeString(opcode); | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateGenericCastToPtrExplicit(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| spv::StorageClass result_storage_class; | |
| uint32_t result_data_type = 0; | |
| if (!_.GetPointerTypeInfo(result_type, &result_data_type, | |
| &result_storage_class)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Result Type to be a pointer: " | |
| << spvOpcodeString(opcode); | |
| const auto target_storage_class = inst->GetOperandAs<spv::StorageClass>(3); | |
| if (result_storage_class != target_storage_class) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Result Type to be of target storage class: " | |
| << spvOpcodeString(opcode); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, 2); | |
| spv::StorageClass input_storage_class; | |
| uint32_t input_data_type = 0; | |
| if (!_.GetPointerTypeInfo(input_type, &input_data_type, &input_storage_class)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be a pointer: " << spvOpcodeString(opcode); | |
| if (input_storage_class != spv::StorageClass::Generic) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have storage class Generic: " | |
| << spvOpcodeString(opcode); | |
| if (result_data_type != input_data_type) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input and Result Type to point to the same type: " | |
| << spvOpcodeString(opcode); | |
| if (target_storage_class != spv::StorageClass::Workgroup && | |
| target_storage_class != spv::StorageClass::CrossWorkgroup && | |
| target_storage_class != spv::StorageClass::Function && | |
| target_storage_class != spv::StorageClass::CodeSectionINTEL) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected target storage class to be Workgroup, " | |
| << "CrossWorkgroup, Function or CodeSectionINTEL: " | |
| << spvOpcodeString(opcode); | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateBitcast(ValidationState_t& _, const Instruction* inst, | |
| uint32_t operand_index = 2) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| const uint32_t input_type = _.GetOperandTypeId(inst, operand_index); | |
| if (!input_type) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have a type: " << spvOpcodeString(opcode); | |
| const bool result_is_pointer = _.IsPointerType(result_type); | |
| const bool result_is_int_scalar = _.IsIntScalarType(result_type); | |
| const bool input_is_pointer = _.IsPointerType(input_type); | |
| const bool input_is_int_scalar = _.IsIntScalarType(input_type); | |
| const bool result_is_coopmat = _.IsCooperativeMatrixType(result_type); | |
| const bool input_is_coopmat = _.IsCooperativeMatrixType(input_type); | |
| const bool result_is_coopvec = _.IsCooperativeVectorNVType(result_type); | |
| const bool input_is_coopvec = _.IsCooperativeVectorNVType(input_type); | |
| if (!result_is_pointer && !result_is_int_scalar && !result_is_coopmat && | |
| !result_is_coopvec && !_.IsIntVectorType(result_type) && | |
| !_.IsFloatScalarType(result_type) && !_.IsFloatVectorType(result_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Result Type to be a pointer or int or float vector " | |
| << "or scalar type: " << spvOpcodeString(opcode); | |
| if (!input_is_pointer && !input_is_int_scalar && !input_is_coopmat && | |
| !input_is_coopvec && !_.IsIntVectorType(input_type) && | |
| !_.IsFloatScalarType(input_type) && !_.IsFloatVectorType(input_type)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to be a pointer or int or float vector " | |
| << "or scalar: " << spvOpcodeString(opcode); | |
| // NV_cooperative_vector doesn't allow bitcasting between vec<->coopvec, | |
| // but long_vector does. | |
| if (result_is_coopvec != input_is_coopvec && | |
| !_.HasCapability(spv::Capability::LongVectorEXT)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Cooperative vector can only be cast to another cooperative " | |
| << "vector: " << spvOpcodeString(opcode); | |
| if (result_is_coopmat != input_is_coopmat) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Cooperative matrix can only be cast to another cooperative " | |
| << "matrix: " << spvOpcodeString(opcode); | |
| if (result_is_coopvec && input_is_coopvec && | |
| !_.HasCapability(spv::Capability::LongVectorEXT)) { | |
| spv_result_t ret = | |
| _.CooperativeVectorDimensionsMatch(inst, result_type, input_type); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } | |
| if (result_is_coopmat) { | |
| spv_result_t ret = _.CooperativeMatrixShapesMatch(inst, result_type, | |
| input_type, false, false); | |
| if (ret != SPV_SUCCESS) return ret; | |
| } | |
| if (_.version() >= SPV_SPIRV_VERSION_WORD(1, 5) || | |
| _.HasExtension(kSPV_KHR_physical_storage_buffer)) { | |
| const bool result_is_int_vector = _.IsIntVectorType(result_type); | |
| const bool result_has_int32 = | |
| _.ContainsSizedIntOrFloatType(result_type, spv::Op::OpTypeInt, 32); | |
| const bool input_is_int_vector = _.IsIntVectorType(input_type); | |
| const bool input_has_int32 = | |
| _.ContainsSizedIntOrFloatType(input_type, spv::Op::OpTypeInt, 32); | |
| if (result_is_pointer && !input_is_pointer && !input_is_int_scalar && | |
| !(input_is_int_vector && input_has_int32)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "In SPIR-V 1.5 or later (or with " | |
| "SPV_KHR_physical_storage_buffer), expected input to be a " | |
| "pointer, " | |
| "int scalar or 32-bit int " | |
| "vector if Result Type is pointer: " | |
| << spvOpcodeString(opcode); | |
| if (input_is_pointer && !result_is_pointer && !result_is_int_scalar && | |
| !(result_is_int_vector && result_has_int32)) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "In SPIR-V 1.5 or later (or with " | |
| "SPV_KHR_physical_storage_buffer), pointer can only be " | |
| "converted to " | |
| "another pointer, int " | |
| "scalar or 32-bit int vector: " | |
| << spvOpcodeString(opcode); | |
| } else { | |
| if (result_is_pointer && !input_is_pointer && !input_is_int_scalar) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "In SPIR-V 1.4 or earlier (and without " | |
| "SPV_KHR_physical_storage_buffer), expected input to be a " | |
| "pointer " | |
| "or int scalar if Result " | |
| "Type is pointer: " | |
| << spvOpcodeString(opcode); | |
| if (input_is_pointer && !result_is_pointer && !result_is_int_scalar) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "In SPIR-V 1.4 or earlier (and without " | |
| "SPV_KHR_physical_storage_buffer), pointer can only be " | |
| "converted " | |
| "to another pointer or int " | |
| "scalar: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (!result_is_pointer && !input_is_pointer) { | |
| const uint32_t result_size = | |
| _.GetBitWidth(result_type) * _.GetDimension(result_type); | |
| const uint32_t input_size = | |
| _.GetBitWidth(input_type) * _.GetDimension(input_type); | |
| if (result_size != input_size) | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected input to have the same total bit width as " | |
| << "Result Type: " << spvOpcodeString(opcode); | |
| } | |
| if (auto error = ValidateShaderBitWidth(_, inst)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateConvertUToAccelerationStructure(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsAccelerationStructureType(result_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Result Type to be a Acceleration Structure: " | |
| << spvOpcodeString(opcode); | |
| } | |
| const uint32_t input_type = _.GetOperandTypeId(inst, 2); | |
| if (!input_type || !_.IsUnsigned64BitHandle(input_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected 64-bit uint scalar or 2-component 32-bit uint " | |
| "vector as input: " | |
| << spvOpcodeString(opcode); | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateBitcastExtract(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| const uint32_t base_type = _.GetOperandTypeId(inst, 2); | |
| const uint32_t offset_type = _.GetOperandTypeId(inst, 3); | |
| if (!IsNumericScalarOrVectorType(_, result_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << _.VkErrorID(12468) | |
| << "Expected Result Type to be a numerical scalar or vector type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (spvIsVulkanEnv(_.context()->target_env) && | |
| !_.ContainsOCPMicroscalingNonByteType(result_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << _.VkErrorID(12468) | |
| << "Expected Result Type to be a Float4EXT or Float6EXT type in " | |
| "the Vulkan environment: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (!base_type || !IsNumericScalarOrVectorType(_, base_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << _.VkErrorID(12469) | |
| << "Expected Base to be a numerical scalar or vector type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (spvIsVulkanEnv(_.context()->target_env) && | |
| !_.IsIntScalarType(base_type) && !_.IsIntVectorType(base_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << _.VkErrorID(12469) | |
| << "Expected Base to be an integer scalar or vector type in the " | |
| "Vulkan environment: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (_.GetDimension(result_type) != _.GetDimension(base_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Base to have the same dimension as Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (_.GetBitWidth(base_type) <= _.GetBitWidth(result_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Base component bit width to be greater than Result " | |
| "Type component bit width: " | |
| << spvOpcodeString(opcode); | |
| } | |
| if (!offset_type || !_.IsIntScalarType(offset_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected Offset to be a scalar integer type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateCooperativeMatrix(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsCooperativeMatrixKHRType(result_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected OpTypeCooperativeMatrixKHR Result Type: " | |
| << spvOpcodeString(opcode); | |
| } | |
| const uint32_t input_type = _.GetOperandTypeId(inst, 2); | |
| if (!_.IsCooperativeMatrixKHRType(input_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Expected OpTypeCooperativeMatrixKHR type for Matrix input: " | |
| << spvOpcodeString(opcode); | |
| } | |
| const bool has_transpose_decoration = HasCoopMatTranspose(_, inst->id()); | |
| const bool swap_row_col = opcode == spv::Op::OpCooperativeMatrixTransposeNV || | |
| has_transpose_decoration; | |
| if (auto error = _.CooperativeMatrixShapesMatch(inst, result_type, input_type, | |
| true, swap_row_col)) | |
| return error; | |
| if (opcode == spv::Op::OpCooperativeMatrixConvertUseEXT) { | |
| auto result_comp_type_id = | |
| _.FindDef(result_type)->GetOperandAs<uint32_t>(1); | |
| auto input_comp_type_id = _.FindDef(input_type)->GetOperandAs<uint32_t>(1); | |
| auto result_comp_type = _.FindDef(result_comp_type_id); | |
| auto input_comp_type = _.FindDef(input_comp_type_id); | |
| const bool same_component_type = result_comp_type_id == input_comp_type_id; | |
| const bool signedness_only_difference = | |
| result_comp_type->opcode() == spv::Op::OpTypeInt && | |
| input_comp_type->opcode() == spv::Op::OpTypeInt && | |
| result_comp_type->word(2) == input_comp_type->word(2) && | |
| result_comp_type->word(3) != input_comp_type->word(3); | |
| if (!same_component_type && !signedness_only_difference) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type and Matrix component types mismatch: " | |
| << spvOpcodeString(opcode); | |
| } | |
| const auto result_use_id = | |
| _.FindDef(result_type)->GetOperandAs<uint32_t>(5); | |
| const auto input_use_id = _.FindDef(input_type)->GetOperandAs<uint32_t>(5); | |
| const auto result_use_eval = _.EvalInt32IfConst(result_use_id); | |
| const auto input_use_eval = _.EvalInt32IfConst(input_use_id); | |
| const bool result_is_const_int32 = std::get<1>(result_use_eval); | |
| const bool input_is_const_int32 = std::get<1>(input_use_eval); | |
| const uint32_t result_use = std::get<2>(result_use_eval); | |
| const uint32_t input_use = std::get<2>(input_use_eval); | |
| const auto is_accumulator = [](uint32_t use) { | |
| return use == uint32_t(spv::CooperativeMatrixUse::MatrixAccumulatorKHR); | |
| }; | |
| const auto is_a_or_b = [](uint32_t use) { | |
| return use == uint32_t(spv::CooperativeMatrixUse::MatrixAKHR) || | |
| use == uint32_t(spv::CooperativeMatrixUse::MatrixBKHR); | |
| }; | |
| bool invalid_use_change = result_use_id == input_use_id; | |
| if (_.HasCapability(spv::Capability::CooperativeMatrixConversionsEXT)) { | |
| if (result_is_const_int32 && input_is_const_int32) { | |
| invalid_use_change |= | |
| !((is_accumulator(input_use) && is_a_or_b(result_use)) || | |
| (is_a_or_b(input_use) && is_accumulator(result_use))); | |
| } else { | |
| invalid_use_change |= | |
| (result_is_const_int32 && !is_accumulator(result_use) && | |
| !is_a_or_b(result_use)) || | |
| (input_is_const_int32 && !is_accumulator(input_use) && | |
| !is_a_or_b(input_use)); | |
| } | |
| } else { | |
| invalid_use_change |= | |
| (result_is_const_int32 && !is_a_or_b(result_use)) || | |
| (input_is_const_int32 && !is_accumulator(input_use)); | |
| } | |
| if (invalid_use_change) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Matrix and Result Type must convert between " | |
| "MatrixAccumulatorKHR and MatrixAKHR or MatrixBKHR: " | |
| << spvOpcodeString(opcode); | |
| } | |
| } | |
| if (opcode == spv::Op::OpCooperativeMatrixTransposeNV) { | |
| const auto result_use_id = | |
| _.FindDef(result_type)->GetOperandAs<uint32_t>(5); | |
| const auto input_use_id = _.FindDef(input_type)->GetOperandAs<uint32_t>(5); | |
| const auto result_use_eval = _.EvalInt32IfConst(result_use_id); | |
| const auto input_use_eval = _.EvalInt32IfConst(input_use_id); | |
| const bool result_is_const_int32 = std::get<1>(result_use_eval); | |
| const bool input_is_const_int32 = std::get<1>(input_use_eval); | |
| const uint32_t result_use = std::get<2>(result_use_eval); | |
| const uint32_t input_use = std::get<2>(input_use_eval); | |
| if (result_use_id == input_use_id || | |
| (result_is_const_int32 && | |
| result_use != uint32_t(spv::CooperativeMatrixUse::MatrixBKHR)) || | |
| (input_is_const_int32 && | |
| input_use != | |
| uint32_t(spv::CooperativeMatrixUse::MatrixAccumulatorKHR))) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type must have UseB and Matrix must have " | |
| "UseAccumulator: " | |
| << spvOpcodeString(opcode); | |
| } | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateBitCastArray(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const spv::Op opcode = inst->opcode(); | |
| const uint32_t result_type = inst->type_id(); | |
| const auto result_type_inst = _.FindDef(result_type); | |
| const auto source = _.FindDef(inst->GetOperandAs<uint32_t>(2u)); | |
| const auto source_type_inst = _.FindDef(source->type_id()); | |
| // Are the input and the result arrays? | |
| if (result_type_inst->opcode() != spv::Op::OpTypeArray || | |
| source_type_inst->opcode() != spv::Op::OpTypeArray) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Opcode " << spvOpcodeString(opcode) | |
| << " requires OpTypeArray operands for the input and the " | |
| "result."; | |
| } | |
| const auto source_elt_type = _.GetComponentType(source_type_inst->id()); | |
| const auto result_elt_type = _.GetComponentType(result_type_inst->id()); | |
| if (!_.IsIntNOrFP32OrFP16<32>(source_elt_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Opcode " << spvOpcodeString(opcode) | |
| << " requires the source element type be one of 32-bit " | |
| "OpTypeInt " | |
| "(signed/unsigned), 32-bit OpTypeFloat and 16-bit " | |
| "OpTypeFloat"; | |
| } | |
| if (!_.IsIntNOrFP32OrFP16<32>(result_elt_type)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Opcode " << spvOpcodeString(opcode) | |
| << " requires the result element type be one of 32-bit " | |
| "OpTypeInt " | |
| "(signed/unsigned), 32-bit OpTypeFloat and 16-bit " | |
| "OpTypeFloat"; | |
| } | |
| unsigned src_arr_len_id = source_type_inst->GetOperandAs<unsigned>(2u); | |
| unsigned res_arr_len_id = result_type_inst->GetOperandAs<unsigned>(2u); | |
| // Are the input and result element types compatible? | |
| unsigned src_arr_len = UINT_MAX, res_arr_len = UINT_MAX; | |
| bool src_arr_len_status = | |
| _.GetConstantValueAs<unsigned>(src_arr_len_id, src_arr_len); | |
| bool res_arr_len_status = | |
| _.GetConstantValueAs<unsigned>(res_arr_len_id, res_arr_len); | |
| bool is_src_arr_len_spec_const = | |
| spvOpcodeIsSpecConstant(_.FindDef(src_arr_len_id)->opcode()); | |
| bool is_res_arr_len_spec_const = | |
| spvOpcodeIsSpecConstant(_.FindDef(res_arr_len_id)->opcode()); | |
| unsigned source_bitlen = _.GetBitWidth(source_elt_type) * src_arr_len; | |
| unsigned result_bitlen = _.GetBitWidth(result_elt_type) * res_arr_len; | |
| if (!is_src_arr_len_spec_const && !is_res_arr_len_spec_const && | |
| (!src_arr_len_status || !res_arr_len_status || | |
| source_bitlen != result_bitlen)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Opcode " << spvOpcodeString(opcode) | |
| << " requires source and result types be compatible for " | |
| "conversion."; | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| // Validates correctness of conversion instructions. | |
| spv_result_t ConversionPass(ValidationState_t& _, const Instruction* inst) { | |
| switch (inst->opcode()) { | |
| case spv::Op::OpConvertFToU: | |
| return ValidateConvertFToU(_, inst); | |
| case spv::Op::OpConvertFToS: | |
| return ValidateConvertFToS(_, inst); | |
| case spv::Op::OpConvertSToF: | |
| case spv::Op::OpConvertUToF: | |
| return ValidateConvertIntToF(_, inst); | |
| case spv::Op::OpUConvert: | |
| return ValidateUConvert(_, inst); | |
| case spv::Op::OpSConvert: | |
| return ValidateSConvert(_, inst); | |
| case spv::Op::OpFConvert: | |
| return ValidateFConvert(_, inst); | |
| case spv::Op::OpQuantizeToF16: | |
| return ValidateQuantizeToF16(_, inst); | |
| case spv::Op::OpConvertPtrToU: | |
| return ValidateConvertPtrToU(_, inst); | |
| case spv::Op::OpSatConvertSToU: | |
| case spv::Op::OpSatConvertUToS: | |
| return ValidateSatConvertInt(_, inst); | |
| case spv::Op::OpConvertUToPtr: | |
| return ValidateConvertUToPtr(_, inst); | |
| case spv::Op::OpPtrCastToGeneric: | |
| return ValidatePtrCastToGeneric(_, inst); | |
| case spv::Op::OpGenericCastToPtr: | |
| return ValidateGenericCastToPtr(_, inst); | |
| case spv::Op::OpGenericCastToPtrExplicit: | |
| return ValidateGenericCastToPtrExplicit(_, inst); | |
| case spv::Op::OpBitcast: | |
| return ValidateBitcast(_, inst); | |
| case spv::Op::OpBitcastExtractEXT: | |
| return ValidateBitcastExtract(_, inst); | |
| case spv::Op::OpConvertUToAccelerationStructureKHR: | |
| return ValidateConvertUToAccelerationStructure(_, inst); | |
| case spv::Op::OpCooperativeMatrixConvertUseEXT: | |
| case spv::Op::OpCooperativeMatrixTransposeNV: | |
| return ValidateCooperativeMatrix(_, inst); | |
| case spv::Op::OpBitCastArrayQCOM: | |
| return ValidateBitCastArray(_, inst); | |
| case spv::Op::OpSpecConstantOp: { | |
| switch (inst->GetOperandAs<spv::Op>(2u)) { | |
| case spv::Op::OpUConvert: | |
| return ValidateUConvert(_, inst, 3); | |
| case spv::Op::OpSConvert: | |
| return ValidateSConvert(_, inst, 3); | |
| case spv::Op::OpFConvert: | |
| return ValidateFConvert(_, inst, 3); | |
| case spv::Op::OpConvertSToF: | |
| case spv::Op::OpConvertUToF: | |
| return ValidateConvertIntToF(_, inst, 3); | |
| case spv::Op::OpConvertFToS: | |
| return ValidateConvertFToS(_, inst, 3); | |
| case spv::Op::OpConvertFToU: | |
| return ValidateConvertFToU(_, inst, 3); | |
| case spv::Op::OpQuantizeToF16: | |
| return ValidateQuantizeToF16(_, inst, 3); | |
| case spv::Op::OpConvertPtrToU: | |
| return ValidateConvertPtrToU(_, inst, 3); | |
| case spv::Op::OpConvertUToPtr: | |
| return ValidateConvertUToPtr(_, inst, 3); | |
| case spv::Op::OpGenericCastToPtr: | |
| return ValidateGenericCastToPtr(_, inst, 3); | |
| case spv::Op::OpPtrCastToGeneric: | |
| return ValidatePtrCastToGeneric(_, inst, 3); | |
| case spv::Op::OpBitcast: | |
| return ValidateBitcast(_, inst, 3); | |
| default: | |
| break; | |
| } | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| } // namespace val | |
| } // namespace spvtools |