Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/KhronosGroup/SPIRV-Tools.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/source/val/validate_constants.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/val/validate_constants.cpp')
-rw-r--r--source/val/validate_constants.cpp122
1 files changed, 62 insertions, 60 deletions
diff --git a/source/val/validate_constants.cpp b/source/val/validate_constants.cpp
index fdfaea5f7..a8ee5a6b1 100644
--- a/source/val/validate_constants.cpp
+++ b/source/val/validate_constants.cpp
@@ -24,7 +24,7 @@ namespace {
spv_result_t ValidateConstantBool(ValidationState_t& _,
const Instruction* inst) {
auto type = _.FindDef(inst->type_id());
- if (!type || type->opcode() != SpvOpTypeBool) {
+ if (!type || type->opcode() != spv::Op::OpTypeBool) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Op" << spvOpcodeString(inst->opcode()) << " Result Type <id> "
<< _.getIdName(inst->type_id()) << " is not a boolean type.";
@@ -46,7 +46,7 @@ spv_result_t ValidateConstantComposite(ValidationState_t& _,
const auto constituent_count = inst->words().size() - 3;
switch (result_type->opcode()) {
- case SpvOpTypeVector: {
+ case spv::Op::OpTypeVector: {
const auto component_count = result_type->GetOperandAs<uint32_t>(2);
if (component_count != constituent_count) {
// TODO: Output ID's on diagnostic
@@ -85,7 +85,7 @@ spv_result_t ValidateConstantComposite(ValidationState_t& _,
}
}
} break;
- case SpvOpTypeMatrix: {
+ case spv::Op::OpTypeMatrix: {
const auto column_count = result_type->GetOperandAs<uint32_t>(2);
if (column_count != constituent_count) {
// TODO: Output ID's on diagnostic
@@ -155,7 +155,7 @@ spv_result_t ValidateConstantComposite(ValidationState_t& _,
}
}
} break;
- case SpvOpTypeArray: {
+ case spv::Op::OpTypeArray: {
auto element_type = _.FindDef(result_type->GetOperandAs<uint32_t>(1));
if (!element_type) {
return _.diag(SPV_ERROR_INVALID_ID, result_type)
@@ -203,7 +203,7 @@ spv_result_t ValidateConstantComposite(ValidationState_t& _,
}
}
} break;
- case SpvOpTypeStruct: {
+ case spv::Op::OpTypeStruct: {
const auto member_count = result_type->words().size() - 2;
if (member_count != constituent_count) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
@@ -243,7 +243,7 @@ spv_result_t ValidateConstantComposite(ValidationState_t& _,
}
}
} break;
- case SpvOpTypeCooperativeMatrixNV: {
+ case spv::Op::OpTypeCooperativeMatrixNV: {
if (1 != constituent_count) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< opcode_name << " Constituent <id> "
@@ -281,7 +281,7 @@ spv_result_t ValidateConstantComposite(ValidationState_t& _,
spv_result_t ValidateConstantSampler(ValidationState_t& _,
const Instruction* inst) {
const auto result_type = _.FindDef(inst->type_id());
- if (!result_type || result_type->opcode() != SpvOpTypeSampler) {
+ if (!result_type || result_type->opcode() != spv::Op::OpTypeSampler) {
return _.diag(SPV_ERROR_INVALID_ID, result_type)
<< "OpConstantSampler Result Type <id> "
<< _.getIdName(inst->type_id()) << " is not a sampler type.";
@@ -298,23 +298,23 @@ bool IsTypeNullable(const std::vector<uint32_t>& instruction,
uint16_t opcode;
uint16_t word_count;
spvOpcodeSplit(instruction[0], &word_count, &opcode);
- switch (static_cast<SpvOp>(opcode)) {
- case SpvOpTypeBool:
- case SpvOpTypeInt:
- case SpvOpTypeFloat:
- case SpvOpTypeEvent:
- case SpvOpTypeDeviceEvent:
- case SpvOpTypeReserveId:
- case SpvOpTypeQueue:
+ switch (static_cast<spv::Op>(opcode)) {
+ case spv::Op::OpTypeBool:
+ case spv::Op::OpTypeInt:
+ case spv::Op::OpTypeFloat:
+ case spv::Op::OpTypeEvent:
+ case spv::Op::OpTypeDeviceEvent:
+ case spv::Op::OpTypeReserveId:
+ case spv::Op::OpTypeQueue:
return true;
- case SpvOpTypeArray:
- case SpvOpTypeMatrix:
- case SpvOpTypeCooperativeMatrixNV:
- case SpvOpTypeVector: {
+ case spv::Op::OpTypeArray:
+ case spv::Op::OpTypeMatrix:
+ case spv::Op::OpTypeCooperativeMatrixNV:
+ case spv::Op::OpTypeVector: {
auto base_type = _.FindDef(instruction[2]);
return base_type && IsTypeNullable(base_type->words(), _);
}
- case SpvOpTypeStruct: {
+ case spv::Op::OpTypeStruct: {
for (size_t elementIndex = 2; elementIndex < instruction.size();
++elementIndex) {
auto element = _.FindDef(instruction[elementIndex]);
@@ -322,8 +322,9 @@ bool IsTypeNullable(const std::vector<uint32_t>& instruction,
}
return true;
}
- case SpvOpTypePointer:
- if (instruction[2] == SpvStorageClassPhysicalStorageBuffer) {
+ case spv::Op::OpTypePointer:
+ if (spv::StorageClass(instruction[2]) ==
+ spv::StorageClass::PhysicalStorageBuffer) {
return false;
}
return true;
@@ -351,7 +352,8 @@ spv_result_t ValidateSpecConstant(ValidationState_t& _,
auto type_id = inst->GetOperandAs<const uint32_t>(0);
auto type_instruction = _.FindDef(type_id);
auto type_opcode = type_instruction->opcode();
- if (type_opcode != SpvOpTypeInt && type_opcode != SpvOpTypeFloat) {
+ if (type_opcode != spv::Op::OpTypeInt &&
+ type_opcode != spv::Op::OpTypeFloat) {
return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Specialization constant "
"must be an integer or "
"floating-point number.";
@@ -361,22 +363,22 @@ spv_result_t ValidateSpecConstant(ValidationState_t& _,
spv_result_t ValidateSpecConstantOp(ValidationState_t& _,
const Instruction* inst) {
- const auto op = inst->GetOperandAs<SpvOp>(2);
+ const auto op = inst->GetOperandAs<spv::Op>(2);
// The binary parser already ensures that the op is valid for *some*
// environment. Here we check restrictions.
switch (op) {
- case SpvOpQuantizeToF16:
- if (!_.HasCapability(SpvCapabilityShader)) {
+ case spv::Op::OpQuantizeToF16:
+ if (!_.HasCapability(spv::Capability::Shader)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Specialization constant operation " << spvOpcodeString(op)
<< " requires Shader capability";
}
break;
- case SpvOpUConvert:
+ case spv::Op::OpUConvert:
if (!_.features().uconvert_spec_constant_op &&
- !_.HasCapability(SpvCapabilityKernel)) {
+ !_.HasCapability(spv::Capability::Kernel)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Prior to SPIR-V 1.4, specialization constant operation "
"UConvert requires Kernel capability or extension "
@@ -384,27 +386,27 @@ spv_result_t ValidateSpecConstantOp(ValidationState_t& _,
}
break;
- case SpvOpConvertFToS:
- case SpvOpConvertSToF:
- case SpvOpConvertFToU:
- case SpvOpConvertUToF:
- case SpvOpConvertPtrToU:
- case SpvOpConvertUToPtr:
- case SpvOpGenericCastToPtr:
- case SpvOpPtrCastToGeneric:
- case SpvOpBitcast:
- case SpvOpFNegate:
- case SpvOpFAdd:
- case SpvOpFSub:
- case SpvOpFMul:
- case SpvOpFDiv:
- case SpvOpFRem:
- case SpvOpFMod:
- case SpvOpAccessChain:
- case SpvOpInBoundsAccessChain:
- case SpvOpPtrAccessChain:
- case SpvOpInBoundsPtrAccessChain:
- if (!_.HasCapability(SpvCapabilityKernel)) {
+ case spv::Op::OpConvertFToS:
+ case spv::Op::OpConvertSToF:
+ case spv::Op::OpConvertFToU:
+ case spv::Op::OpConvertUToF:
+ case spv::Op::OpConvertPtrToU:
+ case spv::Op::OpConvertUToPtr:
+ case spv::Op::OpGenericCastToPtr:
+ case spv::Op::OpPtrCastToGeneric:
+ case spv::Op::OpBitcast:
+ case spv::Op::OpFNegate:
+ case spv::Op::OpFAdd:
+ case spv::Op::OpFSub:
+ case spv::Op::OpFMul:
+ case spv::Op::OpFDiv:
+ case spv::Op::OpFRem:
+ case spv::Op::OpFMod:
+ case spv::Op::OpAccessChain:
+ case spv::Op::OpInBoundsAccessChain:
+ case spv::Op::OpPtrAccessChain:
+ case spv::Op::OpInBoundsPtrAccessChain:
+ if (!_.HasCapability(spv::Capability::Kernel)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Specialization constant operation " << spvOpcodeString(op)
<< " requires Kernel capability";
@@ -423,26 +425,26 @@ spv_result_t ValidateSpecConstantOp(ValidationState_t& _,
spv_result_t ConstantPass(ValidationState_t& _, const Instruction* inst) {
switch (inst->opcode()) {
- case SpvOpConstantTrue:
- case SpvOpConstantFalse:
- case SpvOpSpecConstantTrue:
- case SpvOpSpecConstantFalse:
+ case spv::Op::OpConstantTrue:
+ case spv::Op::OpConstantFalse:
+ case spv::Op::OpSpecConstantTrue:
+ case spv::Op::OpSpecConstantFalse:
if (auto error = ValidateConstantBool(_, inst)) return error;
break;
- case SpvOpConstantComposite:
- case SpvOpSpecConstantComposite:
+ case spv::Op::OpConstantComposite:
+ case spv::Op::OpSpecConstantComposite:
if (auto error = ValidateConstantComposite(_, inst)) return error;
break;
- case SpvOpConstantSampler:
+ case spv::Op::OpConstantSampler:
if (auto error = ValidateConstantSampler(_, inst)) return error;
break;
- case SpvOpConstantNull:
+ case spv::Op::OpConstantNull:
if (auto error = ValidateConstantNull(_, inst)) return error;
break;
- case SpvOpSpecConstant:
+ case spv::Op::OpSpecConstant:
if (auto error = ValidateSpecConstant(_, inst)) return error;
break;
- case SpvOpSpecConstantOp:
+ case spv::Op::OpSpecConstantOp:
if (auto error = ValidateSpecConstantOp(_, inst)) return error;
break;
default:
@@ -452,7 +454,7 @@ spv_result_t ConstantPass(ValidationState_t& _, const Instruction* inst) {
// Generally disallow creating 8- or 16-bit constants unless the full
// capabilities are present.
if (spvOpcodeIsConstant(inst->opcode()) &&
- _.HasCapability(SpvCapabilityShader) &&
+ _.HasCapability(spv::Capability::Shader) &&
!_.IsPointerType(inst->type_id()) &&
_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-05 02:40:38 +0300