mirror of
https://github.com/bkaradzic/bgfx.git
synced 2026-08-17 16:49:41 +00:00
354 lines
13 KiB
C++
354 lines
13 KiB
C++
// 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
|