| // Copyright (c) 2026 LunarG 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. |
| |
| #include <cstdint> |
| |
| #include "source/val/instruction.h" |
| #include "source/val/validate.h" |
| #include "source/val/validate_scopes.h" |
| #include "source/val/validation_state.h" |
| |
| namespace spvtools { |
| namespace val { |
| namespace { |
| |
| spv_result_t ValidateSameSignedDot(ValidationState_t& _, |
| const Instruction* inst) { |
| const uint32_t result_id = inst->type_id(); |
| if (!_.IsIntScalarType(result_id)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result must be an int scalar type."; |
| } |
| |
| const spv::Op opcode = inst->opcode(); |
| const bool has_accumulator = opcode == spv::Op::OpSDotAccSat || |
| opcode == spv::Op::OpUDotAccSat || |
| opcode == spv::Op::OpSUDotAccSat; |
| if (has_accumulator) { |
| const uint32_t accumulator_type = _.GetOperandTypeId(inst, 4); |
| if (accumulator_type != result_id) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result must be the same as the Accumulator type."; |
| } |
| } |
| |
| if (opcode == spv::Op::OpUDot || opcode == spv::Op::OpUDotAccSat) { |
| if (!_.IsIntScalarTypeWithSignedness(result_id, 0)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result must be an unsigned int scalar type."; |
| } |
| } |
| |
| const uint32_t vec_1_id = _.GetOperandTypeId(inst, 2); |
| const uint32_t vec_2_id = _.GetOperandTypeId(inst, 3); |
| |
| const bool is_vec_1_scalar = _.IsIntScalarType(vec_1_id, 32); |
| const bool is_vec_2_scalar = _.IsIntScalarType(vec_2_id, 32); |
| if (is_vec_1_scalar != is_vec_2_scalar) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "'Vector 1' and 'Vector 2' must be the same type."; |
| } else if (is_vec_1_scalar && is_vec_2_scalar) { |
| if (!_.HasCapability(spv::Capability::DotProductInput4x8BitPacked)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "DotProductInput4x8BitPacked capability is required to use " |
| "scalar integers."; |
| } |
| |
| // If both are scalar, spec doesn't say Signedness needs to match |
| const uint32_t vec_1_width = _.GetBitWidth(vec_1_id); |
| const uint32_t vec_2_width = _.GetBitWidth(vec_2_id); |
| if (vec_1_width != 32) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 1' to be 32-bit when a scalar."; |
| } else if (vec_2_width != 32) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 2' to be 32-bit when a scalar."; |
| } |
| |
| // When packed, the result can be 8-bit |
| const uint32_t result_width = _.GetBitWidth(result_id); |
| if (result_width < 8) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result width (" << result_width |
| << ") must be greater than or equal to the packed vector width of " |
| "8"; |
| } |
| |
| // PackedVectorFormat4x8Bit is used when the "Vector" operand are really |
| // scalar |
| const uint32_t packed_operand = has_accumulator ? 6 : 5; |
| const bool has_packed_vec_format = |
| inst->operands().size() == packed_operand; |
| if (!has_packed_vec_format) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "'Vector 1' and 'Vector 2' are a 32-bit int scalar, but no " |
| "Packed Vector " |
| "Format was provided."; |
| } |
| } else { |
| // both should be vectors |
| |
| if (!_.IsVectorType(vec_1_id)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 1' to be an int scalar or vector."; |
| } else if (!_.IsVectorType(vec_2_id)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 2' to be an int scalar or vector."; |
| } |
| |
| const uint32_t vec_1_length = _.GetDimension(vec_1_id); |
| const uint32_t vec_2_length = _.GetDimension(vec_2_id); |
| // If using OpTypeVectorIdEXT with a spec constant, this can be evaluated |
| // when spec constants are frozen |
| if (vec_1_length != 0 && vec_2_length != 0 && |
| vec_1_length != vec_2_length) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "'Vector 1' is " << vec_1_length |
| << " components but 'Vector 2' is " << vec_2_length |
| << " components"; |
| } |
| |
| const uint32_t vec_1_type = _.GetComponentType(vec_1_id); |
| const uint32_t vec_2_type = _.GetComponentType(vec_2_id); |
| if (!_.IsIntScalarType(vec_1_type)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 1' to be a vector of integers."; |
| } else if (!_.IsIntScalarType(vec_2_type)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 2' to be a vector of integers."; |
| } |
| |
| const uint32_t vec_1_width = _.GetBitWidth(vec_1_type); |
| const uint32_t vec_2_width = _.GetBitWidth(vec_2_type); |
| if (vec_1_width != vec_2_width) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "'Vector 1' component is " << vec_1_width |
| << "-bit but 'Vector 2' component is " << vec_2_width << "-bit"; |
| } |
| |
| const uint32_t result_width = _.GetBitWidth(result_id); |
| if (result_width < vec_1_width) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result width (" << result_width |
| << ") must be greater than or equal to the vectors width (" |
| << vec_1_width << ")."; |
| } |
| |
| if (!_.HasCapability(spv::Capability::DotProductInputAll)) { |
| // 4-wide 8-bit ints are special exception that has its own capability |
| if (vec_1_length == 4 && vec_1_width == 8) { |
| if (!_.HasCapability(spv::Capability::DotProductInput4x8Bit)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "DotProductInput4x8Bit or DotProductInputAll capability is " |
| "required to use 4-component vectors of 8-bit integers."; |
| } |
| } else { |
| // provide a more helpful message what is going on if we are here |
| // reporting this error |
| if (_.HasCapability(spv::Capability::DotProductInput4x8BitPacked)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "DotProductInputAll capability is required use vectors. " |
| "(DotProductInput4x8BitPacked capability declared allows " |
| "for only 32-bit int scalars)"; |
| } else { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "DotProductInputAll capability is additionally required to " |
| "the DotProduct capability to use vectors. (It is possible " |
| "to set DotProductInput4x8BitPacked to only use 32-bit " |
| "scalars packed as a 4-wide 8-byte vector)"; |
| } |
| } |
| } |
| |
| if (opcode == spv::Op::OpUDot || opcode == spv::Op::OpUDotAccSat) { |
| const bool vec_1_unsigned = |
| _.IsIntScalarTypeWithSignedness(vec_1_type, 0); |
| const bool vec_2_unsigned = |
| _.IsIntScalarTypeWithSignedness(vec_2_type, 0); |
| if (!vec_1_unsigned) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 1' to be an vector of unsigned integers."; |
| } else if (!vec_2_unsigned) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 2' to be an vector of unsigned integers."; |
| } |
| } else if (opcode == spv::Op::OpSUDot || opcode == spv::Op::OpSUDotAccSat) { |
| const bool vec_2_unsigned = |
| _.IsIntScalarTypeWithSignedness(vec_2_type, 0); |
| if (!vec_2_unsigned) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 2' to be an vector of unsigned integers."; |
| } |
| } |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t ValidateFDotMixVectors(ValidationState_t& _, |
| const Instruction* inst, uint32_t vec_1_id, |
| uint32_t vec_2_id, uint32_t length) { |
| if (!_.IsVectorType(vec_1_id)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 1' to be an vector."; |
| } else if (!_.IsVectorType(vec_2_id)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 2' to be an vector."; |
| } |
| |
| // If using OpTypeVectorIdEXT with a spec constant, |
| // this can be evaluated when spec constants are frozen |
| const uint32_t vec_1_length = _.GetDimension(vec_1_id); |
| const uint32_t vec_2_length = _.GetDimension(vec_2_id); |
| if (vec_1_length != 0 && vec_1_length != length && vec_2_length != 0 && |
| vec_2_length != length) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "'Vector 1' is " << vec_1_length |
| << " components and 'Vector 2' is " << vec_2_length |
| << " components, but both need to be " << length << "-components"; |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t ValidateFDot2MixAcc32(ValidationState_t& _, |
| const Instruction* inst) { |
| const uint32_t result_id = inst->type_id(); |
| if (!_.IsFloatScalarType(result_id, 32)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result must be a 32-bit IEEE 754 float scalar type."; |
| } |
| |
| const uint32_t vec_1_id = _.GetOperandTypeId(inst, 2); |
| const uint32_t vec_2_id = _.GetOperandTypeId(inst, 3); |
| |
| if (auto error = ValidateFDotMixVectors(_, inst, vec_1_id, vec_2_id, 2)) |
| return error; |
| |
| const uint32_t vec_1_type = _.GetComponentType(vec_1_id); |
| const uint32_t vec_2_type = _.GetComponentType(vec_2_id); |
| if (!_.IsFloatScalarType(vec_1_type, 16)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 1' to be a vector of 16-bit floats."; |
| } else if (!_.IsFloatScalarType(vec_2_type, 16)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 2' to be a vector of 16-bit floats."; |
| } |
| |
| // Currently 16-bit floats are only BFloat or IEEE 754 |
| const bool is_vec_1_bfloat = _.IsBfloat16ScalarType(vec_1_type); |
| const bool is_vec_2_bfloat = _.IsBfloat16ScalarType(vec_2_type); |
| if (is_vec_1_bfloat != is_vec_2_bfloat) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "'Vector 1' and 'Vector 2' must be the same float encoding."; |
| } |
| |
| if (is_vec_1_bfloat) { |
| if (!_.HasCapability(spv::Capability::DotProductBFloat16AccVALVE)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "DotProductBFloat16AccVALVE capability is required to use " |
| "BFloat16 encoded floats."; |
| } |
| } else { |
| if (!_.HasCapability(spv::Capability::DotProductFloat16AccFloat32VALVE)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "DotProductFloat16AccFloat32VALVE capability is required to " |
| "use " |
| "IEEE 754 encoded 16-bit floats."; |
| } |
| } |
| |
| const uint32_t accumulator_type = _.GetOperandTypeId(inst, 4); |
| if (accumulator_type != result_id) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Accumulator Type must be the same as the Result Type."; |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t ValidateFDot2MixAcc16(ValidationState_t& _, |
| const Instruction* inst) { |
| const uint32_t vec_1_id = _.GetOperandTypeId(inst, 2); |
| const uint32_t vec_2_id = _.GetOperandTypeId(inst, 3); |
| |
| if (auto error = ValidateFDotMixVectors(_, inst, vec_1_id, vec_2_id, 2)) |
| return error; |
| |
| const uint32_t vec_1_type = _.GetComponentType(vec_1_id); |
| const uint32_t vec_2_type = _.GetComponentType(vec_2_id); |
| if (!_.IsFloatScalarType(vec_1_type, 16)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 1' to be a vector of 16-bit floats."; |
| } else if (!_.IsFloatScalarType(vec_2_type, 16)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 2' to be a vector of 16-bit floats."; |
| } |
| |
| // Currently 16-bit floats are only BFloat or IEEE 754 |
| const bool is_vec_1_bfloat = _.IsBfloat16ScalarType(vec_1_type); |
| const bool is_vec_2_bfloat = _.IsBfloat16ScalarType(vec_2_type); |
| if (is_vec_1_bfloat != is_vec_2_bfloat) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "'Vector 1' and 'Vector 2' must be the same float encoding."; |
| } |
| |
| if (is_vec_1_bfloat) { |
| if (!_.HasCapability(spv::Capability::DotProductBFloat16AccVALVE)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "DotProductBFloat16AccVALVE capability is required to use " |
| "BFloat16 encoded floats."; |
| } |
| } else { |
| if (!_.HasCapability(spv::Capability::DotProductFloat16AccFloat16VALVE)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "DotProductFloat16AccFloat16VALVE capability is required to " |
| "use " |
| "IEEE 754 encoded 16-bit floats."; |
| } |
| } |
| |
| const uint32_t result_id = inst->type_id(); |
| if (!_.IsFloatScalarType(result_id, 16)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result must be a 16-bit float scalar type."; |
| } |
| |
| const bool is_result_bfloat = _.IsBfloat16ScalarType(result_id); |
| if (is_result_bfloat != is_vec_1_bfloat) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result must have the same float encoding as 'Vector 1' and " |
| "'Vector 2'."; |
| } |
| |
| const uint32_t accumulator_type = _.GetOperandTypeId(inst, 4); |
| if (accumulator_type != result_id) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Accumulator Type must be the same as the Result Type."; |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t ValidateFDot4MixAcc32(ValidationState_t& _, |
| const Instruction* inst) { |
| const uint32_t result_id = inst->type_id(); |
| if (!_.IsFloatScalarType(result_id, 32)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result must be a 32-bit IEEE 754 float scalar type."; |
| } |
| |
| const uint32_t vec_1_id = _.GetOperandTypeId(inst, 2); |
| const uint32_t vec_2_id = _.GetOperandTypeId(inst, 3); |
| |
| if (auto error = ValidateFDotMixVectors(_, inst, vec_1_id, vec_2_id, 4)) |
| return error; |
| |
| // Currently 8-bit floats are only Float8E4M3/Float8E5M2 |
| const uint32_t vec_1_type = _.GetComponentType(vec_1_id); |
| const uint32_t vec_2_type = _.GetComponentType(vec_2_id); |
| if (!_.IsFloatScalarType(vec_1_type, 8)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 1' to be a vector of 8-bit floats."; |
| } else if (!_.IsFloatScalarType(vec_2_type, 8)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Expected 'Vector 2' to be a vector of 8-bit floats."; |
| } |
| |
| const uint32_t accumulator_type = _.GetOperandTypeId(inst, 4); |
| if (accumulator_type != result_id) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Accumulator Type must be the same as the Result Type."; |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| } // namespace |
| |
| spv_result_t DotProductPass(ValidationState_t& _, const Instruction* inst) { |
| const spv::Op opcode = inst->opcode(); |
| |
| switch (opcode) { |
| case spv::Op::OpSDot: |
| case spv::Op::OpUDot: |
| case spv::Op::OpSUDot: |
| case spv::Op::OpSDotAccSat: |
| case spv::Op::OpUDotAccSat: |
| case spv::Op::OpSUDotAccSat: |
| return ValidateSameSignedDot(_, inst); |
| // Tried combining these to a single validate function, but they are less |
| // similar than appeared at first glance |
| case spv::Op::OpFDot2MixAcc32VALVE: |
| return ValidateFDot2MixAcc32(_, inst); |
| case spv::Op::OpFDot2MixAcc16VALVE: |
| return ValidateFDot2MixAcc16(_, inst); |
| case spv::Op::OpFDot4MixAcc32VALVE: |
| return ValidateFDot4MixAcc32(_, inst); |
| default: |
| break; |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| } // namespace val |
| } // namespace spvtools |
