| // 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. | |
| // Validates correctness of Pipe SPIR-V instructions. | |
| #include "source/val/instruction.h" | |
| #include "source/val/validate.h" | |
| #include "source/val/validate_scopes.h" | |
| #include "source/val/validation_state.h" | |
| #include "spirv/unified1/spirv.hpp11" | |
| namespace spvtools { | |
| namespace val { | |
| namespace { | |
| enum class ValidPipeType { | |
| READ_ONLY, | |
| WRITE_ONLY, | |
| READ_OR_WRITE, // still excludes Read AND Write | |
| }; | |
| spv_result_t ValidatePipeType(ValidationState_t& _, const Instruction* inst, | |
| uint32_t operand, ValidPipeType valid_pt) { | |
| const Instruction* pipe_type = _.FindDef(_.GetOperandTypeId(inst, operand)); | |
| if (pipe_type->opcode() != spv::Op::OpTypePipe) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pipe must be a type of OpTypePipe."; | |
| } | |
| const auto access_qualifier = | |
| pipe_type->GetOperandAs<spv::AccessQualifier>(1); | |
| if (valid_pt == ValidPipeType::READ_ONLY) { | |
| if (access_qualifier != spv::AccessQualifier::ReadOnly) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pipe must have a OpTypePipe with ReadOnly access qualifier."; | |
| } | |
| } else if (valid_pt == ValidPipeType::WRITE_ONLY) { | |
| if (access_qualifier != spv::AccessQualifier::WriteOnly) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pipe must have a OpTypePipe with WriteOnly access qualifier."; | |
| } | |
| } else if (valid_pt == ValidPipeType::READ_OR_WRITE) { | |
| if (access_qualifier != spv::AccessQualifier::ReadOnly && | |
| access_qualifier != spv::AccessQualifier::WriteOnly) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pipe must have a OpTypePipe with ReadOnly or WriteOnly access " | |
| "qualifier."; | |
| } | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidatePacketSizeAlign(ValidationState_t& _, | |
| const Instruction* inst, | |
| uint32_t size_operand, | |
| uint32_t alignment_operand) { | |
| const uint32_t packet_size_id = _.GetOperandTypeId(inst, size_operand); | |
| if (!_.IsIntScalarType(packet_size_id, 32)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Packet Size must be a 32-bit scalar integer."; | |
| } | |
| const uint32_t packet_alignment_id = | |
| _.GetOperandTypeId(inst, alignment_operand); | |
| if (!_.IsIntScalarType(packet_alignment_id, 32)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Packet Alignment must be a 32-bit scalar integer."; | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateReadWritePipe(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsIntScalarType(result_type, 32)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type must be a 32-bit int scalar."; | |
| } | |
| if (inst->opcode() == spv::Op::OpReadPipe) { | |
| if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::READ_ONLY)) | |
| return error; | |
| } else if (inst->opcode() == spv::Op::OpWritePipe) { | |
| if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::WRITE_ONLY)) | |
| return error; | |
| } | |
| const Instruction* pointer_type = _.FindDef(_.GetOperandTypeId(inst, 3)); | |
| if (pointer_type->opcode() != spv::Op::OpTypePointer) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pointer must be a type of OpTypePointer."; | |
| } | |
| if (pointer_type->GetOperandAs<spv::StorageClass>(1) != | |
| spv::StorageClass::Generic) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pointer must be a OpTypePointer with a Generic storage class."; | |
| } | |
| if (auto error = ValidatePacketSizeAlign(_, inst, 4, 5)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateReservedReadWritePipe(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsIntScalarType(result_type, 32)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type must be a 32-bit int scalar."; | |
| } | |
| if (inst->opcode() == spv::Op::OpReservedReadPipe) { | |
| if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::READ_ONLY)) | |
| return error; | |
| } else if (inst->opcode() == spv::Op::OpReservedWritePipe) { | |
| if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::WRITE_ONLY)) | |
| return error; | |
| } | |
| const Instruction* reserve_id = _.FindDef(_.GetOperandTypeId(inst, 3)); | |
| if (reserve_id->opcode() != spv::Op::OpTypeReserveId) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Reserve Id type must be OpTypeReserveId."; | |
| } | |
| const uint32_t index_id = _.GetOperandTypeId(inst, 4); | |
| if (!_.IsIntScalarType(index_id, 32)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Index must be a 32-bit scalar integer."; | |
| } | |
| const Instruction* pointer_type = _.FindDef(_.GetOperandTypeId(inst, 5)); | |
| if (pointer_type->opcode() != spv::Op::OpTypePointer) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pointer must be a type of OpTypePointer."; | |
| } | |
| if (pointer_type->GetOperandAs<spv::StorageClass>(1) != | |
| spv::StorageClass::Generic) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Pointer must be a OpTypePointer with a Generic storage class."; | |
| } | |
| if (auto error = ValidatePacketSizeAlign(_, inst, 6, 7)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateReservePackets(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const Instruction* result_type = _.FindDef(inst->type_id()); | |
| if (result_type->opcode() != spv::Op::OpTypeReserveId) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type must be OpTypeReserveId."; | |
| } | |
| if (inst->opcode() == spv::Op::OpReserveReadPipePackets) { | |
| if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::READ_ONLY)) | |
| return error; | |
| } else if (inst->opcode() == spv::Op::OpReserveWritePipePackets) { | |
| if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::WRITE_ONLY)) | |
| return error; | |
| } | |
| const uint32_t num_packets_id = _.GetOperandTypeId(inst, 3); | |
| if (!_.IsIntScalarType(num_packets_id, 32)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Num Packets must be a 32-bit scalar integer."; | |
| } | |
| if (auto error = ValidatePacketSizeAlign(_, inst, 4, 5)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateGroupReservePackets(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const Instruction* result_type = _.FindDef(inst->type_id()); | |
| if (result_type->opcode() != spv::Op::OpTypeReserveId) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type must be OpTypeReserveId."; | |
| } | |
| if (inst->opcode() == spv::Op::OpGroupReserveReadPipePackets) { | |
| if (auto error = ValidatePipeType(_, inst, 3, ValidPipeType::READ_ONLY)) | |
| return error; | |
| } else if (inst->opcode() == spv::Op::OpGroupReserveWritePipePackets) { | |
| if (auto error = ValidatePipeType(_, inst, 3, ValidPipeType::WRITE_ONLY)) | |
| return error; | |
| } | |
| const uint32_t num_packets_id = _.GetOperandTypeId(inst, 4); | |
| if (!_.IsIntScalarType(num_packets_id, 32)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Num Packets must be a 32-bit scalar integer."; | |
| } | |
| if (auto error = ValidatePacketSizeAlign(_, inst, 5, 6)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateCommitPipe(ValidationState_t& _, const Instruction* inst) { | |
| if (inst->opcode() == spv::Op::OpCommitReadPipe) { | |
| if (auto error = ValidatePipeType(_, inst, 0, ValidPipeType::READ_ONLY)) | |
| return error; | |
| } else if (inst->opcode() == spv::Op::OpCommitWritePipe) { | |
| if (auto error = ValidatePipeType(_, inst, 0, ValidPipeType::WRITE_ONLY)) | |
| return error; | |
| } | |
| const Instruction* reserve_id = _.FindDef(_.GetOperandTypeId(inst, 1)); | |
| if (reserve_id->opcode() != spv::Op::OpTypeReserveId) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Reserve Id type must be OpTypeReserveId."; | |
| } | |
| if (auto error = ValidatePacketSizeAlign(_, inst, 2, 3)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateGroupCommitPipe(ValidationState_t& _, | |
| const Instruction* inst) { | |
| if (inst->opcode() == spv::Op::OpGroupCommitReadPipe) { | |
| if (auto error = ValidatePipeType(_, inst, 1, ValidPipeType::READ_ONLY)) | |
| return error; | |
| } else if (inst->opcode() == spv::Op::OpGroupCommitWritePipe) { | |
| if (auto error = ValidatePipeType(_, inst, 1, ValidPipeType::WRITE_ONLY)) | |
| return error; | |
| } | |
| const Instruction* reserve_id = _.FindDef(_.GetOperandTypeId(inst, 2)); | |
| if (reserve_id->opcode() != spv::Op::OpTypeReserveId) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Reserve Id type must be OpTypeReserveId."; | |
| } | |
| if (auto error = ValidatePacketSizeAlign(_, inst, 3, 4)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidatePipePacketsQuery(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const uint32_t result_type = inst->type_id(); | |
| if (!_.IsIntScalarType(result_type, 32)) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type must be a 32-bit int scalar."; | |
| } | |
| if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::READ_OR_WRITE)) | |
| return error; | |
| if (auto error = ValidatePacketSizeAlign(_, inst, 3, 4)) return error; | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateIsValidReserveId(ValidationState_t& _, | |
| const Instruction* inst) { | |
| if (!_.IsBoolScalarType(inst->type_id())) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type must be a bool scalar"; | |
| } | |
| const Instruction* reserve_id = _.FindDef(_.GetOperandTypeId(inst, 2)); | |
| if (reserve_id->opcode() != spv::Op::OpTypeReserveId) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Reserve Id type must be OpTypeReserveId."; | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateCreatePipeFromPipeStorage(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const Instruction* result_type = _.FindDef(inst->type_id()); | |
| if (result_type->opcode() != spv::Op::OpTypePipe) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type must be OpTypePipe."; | |
| } | |
| // TODO - Need to check OpTypeStorage is from OpConstantPipeStorage | |
| return SPV_SUCCESS; | |
| } | |
| spv_result_t ValidateConstantPipeStorage(ValidationState_t& _, | |
| const Instruction* inst) { | |
| const Instruction* result_type = _.FindDef(inst->type_id()); | |
| if (result_type->opcode() != spv::Op::OpTypePipeStorage) { | |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) | |
| << "Result Type must be OpTypePipeStorage."; | |
| } | |
| // TODO - Should we validate the literal values? | |
| // https://gitlab.khronos.org/spirv/SPIR-V/-/issues/914 | |
| return SPV_SUCCESS; | |
| } | |
| } // namespace | |
| // Validates correctness of pipe instructions. | |
| spv_result_t PipePass(ValidationState_t& _, const Instruction* inst) { | |
| switch (inst->opcode()) { | |
| case spv::Op::OpReadPipe: | |
| case spv::Op::OpWritePipe: | |
| return ValidateReadWritePipe(_, inst); | |
| case spv::Op::OpReservedReadPipe: | |
| case spv::Op::OpReservedWritePipe: | |
| return ValidateReservedReadWritePipe(_, inst); | |
| case spv::Op::OpReserveReadPipePackets: | |
| case spv::Op::OpReserveWritePipePackets: | |
| return ValidateReservePackets(_, inst); | |
| case spv::Op::OpGroupReserveReadPipePackets: | |
| case spv::Op::OpGroupReserveWritePipePackets: | |
| return ValidateGroupReservePackets(_, inst); | |
| case spv::Op::OpCommitReadPipe: | |
| case spv::Op::OpCommitWritePipe: | |
| return ValidateCommitPipe(_, inst); | |
| case spv::Op::OpGroupCommitReadPipe: | |
| case spv::Op::OpGroupCommitWritePipe: | |
| return ValidateGroupCommitPipe(_, inst); | |
| case spv::Op::OpGetNumPipePackets: | |
| case spv::Op::OpGetMaxPipePackets: | |
| return ValidatePipePacketsQuery(_, inst); | |
| case spv::Op::OpIsValidReserveId: | |
| return ValidateIsValidReserveId(_, inst); | |
| case spv::Op::OpCreatePipeFromPipeStorage: | |
| return ValidateCreatePipeFromPipeStorage(_, inst); | |
| case spv::Op::OpConstantPipeStorage: | |
| return ValidateConstantPipeStorage(_, inst); | |
| default: | |
| break; | |
| } | |
| return SPV_SUCCESS; | |
| } | |
| } // namespace val | |
| } // namespace spvtools |