Mirrors/bgfx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bgfx.git synced 2026-02-17 20:52:36 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
a3df2328164d5894c4e7c47494dd1ffb6d75e975
bgfx/3rdparty/spirv-tools/source/val/validate_composites.cpp
Бранимир Караџић a3df232816 Updated spirv-tools.
2025-11-20 09:57:11 -08:00

1116 lines
46 KiB
C++
Raw Blame History

// Copyright (c) 2017 Google Inc.
// Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights
// reserved.
//
// 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 composite SPIR-V instructions.
#include <climits>
#include "source/opcode.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 {
// Returns the type of the value accessed by OpCompositeExtract or
// OpCompositeInsert instruction. The function traverses the hierarchy of
// nested data structures (structs, arrays, vectors, matrices) as directed by
// the sequence of indices in the instruction. May return error if traversal
// fails (encountered non-composite, out of bounds, no indices, nesting too
// deep).
spv_result_t GetExtractInsertValueType(ValidationState_t& _,
const Instruction* inst,
uint32_t* member_type) {
const spv::Op opcode = inst->opcode();
assert(opcode == spv::Op::OpCompositeExtract ||
opcode == spv::Op::OpCompositeInsert);
uint32_t word_index = opcode == spv::Op::OpCompositeExtract ? 4 : 5;
const uint32_t num_words = static_cast<uint32_t>(inst->words().size());
const uint32_t composite_id_index = word_index - 1;
const uint32_t num_indices = num_words - word_index;
const uint32_t kCompositeExtractInsertMaxNumIndices = 255;
if (num_indices == 0) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected at least one index to Op"
<< spvOpcodeString(inst->opcode()) << ", zero found";
} else if (num_indices > kCompositeExtractInsertMaxNumIndices) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "The number of indexes in Op" << spvOpcodeString(opcode)
<< " may not exceed " << kCompositeExtractInsertMaxNumIndices
<< ". Found " << num_indices << " indexes.";
}
*member_type = _.GetTypeId(inst->word(composite_id_index));
if (*member_type == 0) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Composite to be an object of composite type";
}
for (; word_index < num_words; ++word_index) {
const uint32_t component_index = inst->word(word_index);
const Instruction* const type_inst = _.FindDef(*member_type);
assert(type_inst);
switch (type_inst->opcode()) {
case spv::Op::OpTypeVector: {
*member_type = type_inst->word(2);
const uint32_t vector_size = type_inst->word(3);
if (component_index >= vector_size) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Vector access is out of bounds, vector size is "
<< vector_size << ", but access index is " << component_index;
}
break;
}
case spv::Op::OpTypeMatrix: {
*member_type = type_inst->word(2);
const uint32_t num_cols = type_inst->word(3);
if (component_index >= num_cols) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Matrix access is out of bounds, matrix has " << num_cols
<< " columns, but access index is " << component_index;
}
break;
}
case spv::Op::OpTypeArray: {
uint64_t array_size = 0;
auto size = _.FindDef(type_inst->word(3));
*member_type = type_inst->word(2);
if (spvOpcodeIsSpecConstant(size->opcode())) {
// Cannot verify against the size of this array.
break;
}
if (!_.EvalConstantValUint64(type_inst->word(3), &array_size)) {
assert(0 && "Array type definition is corrupt");
}
if (component_index >= array_size) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Array access is out of bounds, array size is "
<< array_size << ", but access index is " << component_index;
}
break;
}
case spv::Op::OpTypeRuntimeArray:
case spv::Op::OpTypeNodePayloadArrayAMDX: {
*member_type = type_inst->word(2);
// Array size is unknown.
break;
}
case spv::Op::OpTypeStruct: {
const size_t num_struct_members = type_inst->words().size() - 2;
if (component_index >= num_struct_members) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Index is out of bounds, can not find index "
<< component_index << " in the structure <id> '"
<< type_inst->id() << "'. This structure has "
<< num_struct_members << " members. Largest valid index is "
<< num_struct_members - 1 << ".";
}
*member_type = type_inst->word(component_index + 2);
break;
}
case spv::Op::OpTypeCooperativeVectorNV:
case spv::Op::OpTypeCooperativeMatrixKHR:
case spv::Op::OpTypeCooperativeMatrixNV: {
*member_type = type_inst->word(2);
break;
}
default:
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Reached non-composite type while indexes still remain to "
"be traversed.";
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateVectorExtractDynamic(ValidationState_t& _,
const Instruction* inst) {
const uint32_t result_type = inst->type_id();
const spv::Op result_opcode = _.GetIdOpcode(result_type);
if (!spvOpcodeIsScalarType(result_opcode)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Result Type to be a scalar type";
}
const uint32_t vector_type = _.GetOperandTypeId(inst, 2);
const spv::Op vector_opcode = _.GetIdOpcode(vector_type);
if (vector_opcode != spv::Op::OpTypeVector &&
vector_opcode != spv::Op::OpTypeCooperativeVectorNV) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Vector type to be OpTypeVector";
}
if (_.GetComponentType(vector_type) != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Vector component type to be equal to Result Type";
}
const auto index = _.FindDef(inst->GetOperandAs<uint32_t>(3));
if (!index || index->type_id() == 0 || !_.IsIntScalarType(index->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Index to be int scalar";
}
if (_.HasCapability(spv::Capability::Shader) &&
_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Cannot extract from a vector of 8- or 16-bit types";
}
return SPV_SUCCESS;
}
spv_result_t ValidateVectorInsertDyanmic(ValidationState_t& _,
const Instruction* inst) {
const uint32_t result_type = inst->type_id();
const spv::Op result_opcode = _.GetIdOpcode(result_type);
if (result_opcode != spv::Op::OpTypeVector &&
result_opcode != spv::Op::OpTypeCooperativeVectorNV) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Result Type to be OpTypeVector";
}
const uint32_t vector_type = _.GetOperandTypeId(inst, 2);
if (vector_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Vector type to be equal to Result Type";
}
const uint32_t component_type = _.GetOperandTypeId(inst, 3);
if (_.GetComponentType(result_type) != component_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Component type to be equal to Result Type "
<< "component type";
}
const uint32_t index_type = _.GetOperandTypeId(inst, 4);
if (!_.IsIntScalarType(index_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Index to be int scalar";
}
if (_.HasCapability(spv::Capability::Shader) &&
_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Cannot insert into a vector of 8- or 16-bit types";
}
return SPV_SUCCESS;
}
spv_result_t ValidateCompositeConstruct(ValidationState_t& _,
const Instruction* inst) {
const uint32_t num_operands = static_cast<uint32_t>(inst->operands().size());
const uint32_t result_type = inst->type_id();
const spv::Op result_opcode = _.GetIdOpcode(result_type);
switch (result_opcode) {
case spv::Op::OpTypeVector:
case spv::Op::OpTypeCooperativeVectorNV: {
uint32_t num_result_components = _.GetDimension(result_type);
const uint32_t result_component_type = _.GetComponentType(result_type);
uint32_t given_component_count = 0;
bool comp_is_int32 = true, comp_is_const_int32 = true;
if (result_opcode == spv::Op::OpTypeVector) {
if (num_operands <= 3) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected number of constituents to be at least 2";
}
} else {
uint32_t comp_count_id =
_.FindDef(result_type)->GetOperandAs<uint32_t>(2);
std::tie(comp_is_int32, comp_is_const_int32, num_result_components) =
_.EvalInt32IfConst(comp_count_id);
}
for (uint32_t operand_index = 2; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (operand_type == result_component_type) {
++given_component_count;
} else {
if (_.GetIdOpcode(operand_type) != spv::Op::OpTypeVector ||
_.GetComponentType(operand_type) != result_component_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Constituents to be scalars or vectors of"
<< " the same type as Result Type components";
}
given_component_count += _.GetDimension(operand_type);
}
}
if (comp_is_const_int32 &&
num_result_components != given_component_count) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected total number of given components to be equal "
<< "to the size of Result Type vector";
}
break;
}
case spv::Op::OpTypeMatrix: {
uint32_t result_num_rows = 0;
uint32_t result_num_cols = 0;
uint32_t result_col_type = 0;
uint32_t result_component_type = 0;
if (!_.GetMatrixTypeInfo(result_type, &result_num_rows, &result_num_cols,
&result_col_type, &result_component_type)) {
assert(0);
}
if (result_num_cols + 2 != num_operands) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected total number of Constituents to be equal "
<< "to the number of columns of Result Type matrix";
}
for (uint32_t operand_index = 2; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (operand_type != result_col_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Constituent type to be equal to the column "
<< "type Result Type matrix";
}
}
break;
}
case spv::Op::OpTypeArray: {
const Instruction* const array_inst = _.FindDef(result_type);
assert(array_inst);
assert(array_inst->opcode() == spv::Op::OpTypeArray);
auto size = _.FindDef(array_inst->word(3));
if (spvOpcodeIsSpecConstant(size->opcode())) {
// Cannot verify against the size of this array.
break;
}
uint64_t array_size = 0;
if (!_.EvalConstantValUint64(array_inst->word(3), &array_size)) {
assert(0 && "Array type definition is corrupt");
}
if (array_size + 2 != num_operands) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected total number of Constituents to be equal "
<< "to the number of elements of Result Type array";
}
const uint32_t result_component_type = array_inst->word(2);
for (uint32_t operand_index = 2; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (operand_type != result_component_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Constituent type to be equal to the column "
<< "type Result Type array";
}
}
break;
}
case spv::Op::OpTypeStruct: {
const Instruction* const struct_inst = _.FindDef(result_type);
assert(struct_inst);
assert(struct_inst->opcode() == spv::Op::OpTypeStruct);
if (struct_inst->operands().size() + 1 != num_operands) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected total number of Constituents to be equal "
<< "to the number of members of Result Type struct";
}
for (uint32_t operand_index = 2; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
const uint32_t member_type = struct_inst->word(operand_index);
if (operand_type != member_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Constituent type to be equal to the "
<< "corresponding member type of Result Type struct";
}
}
break;
}
case spv::Op::OpTypeCooperativeMatrixKHR: {
const auto result_type_inst = _.FindDef(result_type);
assert(result_type_inst);
const auto component_type_id =
result_type_inst->GetOperandAs<uint32_t>(1);
if (3 != num_operands) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Must be only one constituent";
}
const uint32_t operand_type_id = _.GetOperandTypeId(inst, 2);
if (operand_type_id != component_type_id) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Constituent type to be equal to the component type";
}
break;
}
case spv::Op::OpTypeCooperativeMatrixNV: {
const auto result_type_inst = _.FindDef(result_type);
assert(result_type_inst);
const auto component_type_id =
result_type_inst->GetOperandAs<uint32_t>(1);
if (3 != num_operands) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected single constituent";
}
const uint32_t operand_type_id = _.GetOperandTypeId(inst, 2);
if (operand_type_id != component_type_id) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Constituent type to be equal to the component type";
}
break;
}
default: {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Result Type to be a composite type";
}
}
if (_.HasCapability(spv::Capability::Shader) &&
_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Cannot create a composite containing 8- or 16-bit types";
}
return SPV_SUCCESS;
}
spv_result_t ValidateCompositeExtract(ValidationState_t& _,
const Instruction* inst) {
uint32_t member_type = 0;
if (spv_result_t error = GetExtractInsertValueType(_, inst, &member_type)) {
return error;
}
const uint32_t result_type = inst->type_id();
if (result_type != member_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Result type (Op" << spvOpcodeString(_.GetIdOpcode(result_type))
<< ") does not match the type that results from indexing into "
"the composite (Op"
<< spvOpcodeString(_.GetIdOpcode(member_type)) << ").";
}
if (_.HasCapability(spv::Capability::Shader) &&
_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Cannot extract from a composite of 8- or 16-bit types";
}
return SPV_SUCCESS;
}
spv_result_t ValidateCompositeInsert(ValidationState_t& _,
const Instruction* inst) {
const uint32_t object_type = _.GetOperandTypeId(inst, 2);
const uint32_t composite_type = _.GetOperandTypeId(inst, 3);
const uint32_t result_type = inst->type_id();
if (result_type != composite_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "The Result Type must be the same as Composite type in Op"
<< spvOpcodeString(inst->opcode()) << " yielding Result Id "
<< result_type << ".";
}
uint32_t member_type = 0;
if (spv_result_t error = GetExtractInsertValueType(_, inst, &member_type)) {
return error;
}
if (object_type != member_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "The Object type (Op"
<< spvOpcodeString(_.GetIdOpcode(object_type))
<< ") does not match the type that results from indexing into the "
"Composite (Op"
<< spvOpcodeString(_.GetIdOpcode(member_type)) << ").";
}
if (_.HasCapability(spv::Capability::Shader) &&
_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Cannot insert into a composite of 8- or 16-bit types";
}
return SPV_SUCCESS;
}
spv_result_t ValidateCopyObject(ValidationState_t& _, const Instruction* inst) {
const uint32_t result_type = inst->type_id();
const uint32_t operand_type = _.GetOperandTypeId(inst, 2);
if (operand_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Result Type and Operand type to be the same";
}
if (_.IsVoidType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "OpCopyObject cannot have void result type";
}
return SPV_SUCCESS;
}
spv_result_t ValidateTranspose(ValidationState_t& _, const Instruction* inst) {
uint32_t result_num_rows = 0;
uint32_t result_num_cols = 0;
uint32_t result_col_type = 0;
uint32_t result_component_type = 0;
const uint32_t result_type = inst->type_id();
if (!_.GetMatrixTypeInfo(result_type, &result_num_rows, &result_num_cols,
&result_col_type, &result_component_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Result Type to be a matrix type";
}
const uint32_t matrix_type = _.GetOperandTypeId(inst, 2);
uint32_t matrix_num_rows = 0;
uint32_t matrix_num_cols = 0;
uint32_t matrix_col_type = 0;
uint32_t matrix_component_type = 0;
if (!_.GetMatrixTypeInfo(matrix_type, &matrix_num_rows, &matrix_num_cols,
&matrix_col_type, &matrix_component_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected Matrix to be of type OpTypeMatrix";
}
if (result_component_type != matrix_component_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected component types of Matrix and Result Type to be "
<< "identical";
}
if (result_num_rows != matrix_num_cols ||
result_num_cols != matrix_num_rows) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Expected number of columns and the column size of Matrix "
<< "to be the reverse of those of Result Type";
}
if (_.HasCapability(spv::Capability::Shader) &&
_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Cannot transpose matrices of 16-bit floats";
}
return SPV_SUCCESS;
}
spv_result_t ValidateVectorShuffle(ValidationState_t& _,
const Instruction* inst) {
auto resultType = _.FindDef(inst->type_id());
if (!resultType || resultType->opcode() != spv::Op::OpTypeVector) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "The Result Type of OpVectorShuffle must be"
<< " OpTypeVector. Found Op" << spvOpcodeString(resultType->opcode())
<< ".";
}
// The number of components in Result Type must be the same as the number of
// Component operands.
auto componentCount = inst->operands().size() - 4;
auto resultVectorDimension = resultType->GetOperandAs<uint32_t>(2);
if (componentCount != resultVectorDimension) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "OpVectorShuffle component literals count does not match "
"Result Type <id> "
<< _.getIdName(resultType->id()) << "s vector component count.";
}
// Vector 1 and Vector 2 must both have vector types, with the same Component
// Type as Result Type.
auto vector1Object = _.FindDef(inst->GetOperandAs<uint32_t>(2));
auto vector1Type = _.FindDef(vector1Object->type_id());
auto vector2Object = _.FindDef(inst->GetOperandAs<uint32_t>(3));
auto vector2Type = _.FindDef(vector2Object->type_id());
if (!vector1Type || vector1Type->opcode() != spv::Op::OpTypeVector) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "The type of Vector 1 must be OpTypeVector.";
}
if (!vector2Type || vector2Type->opcode() != spv::Op::OpTypeVector) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "The type of Vector 2 must be OpTypeVector.";
}
auto resultComponentType = resultType->GetOperandAs<uint32_t>(1);
if (vector1Type->GetOperandAs<uint32_t>(1) != resultComponentType) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "The Component Type of Vector 1 must be the same as ResultType.";
}
if (vector2Type->GetOperandAs<uint32_t>(1) != resultComponentType) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "The Component Type of Vector 2 must be the same as ResultType.";
}
// All Component literals must either be FFFFFFFF or in [0, N - 1].
auto vector1ComponentCount = vector1Type->GetOperandAs<uint32_t>(2);
auto vector2ComponentCount = vector2Type->GetOperandAs<uint32_t>(2);
auto N = vector1ComponentCount + vector2ComponentCount;
auto firstLiteralIndex = 4;
for (size_t i = firstLiteralIndex; i < inst->operands().size(); ++i) {
auto literal = inst->GetOperandAs<uint32_t>(i);
if (literal != 0xFFFFFFFF && literal >= N) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Component index " << literal << " is out of bounds for "
<< "combined (Vector1 + Vector2) size of " << N << ".";
}
}
if (_.HasCapability(spv::Capability::Shader) &&
_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Cannot shuffle a vector of 8- or 16-bit types";
}
return SPV_SUCCESS;
}
spv_result_t ValidateCopyLogical(ValidationState_t& _,
const Instruction* inst) {
const auto result_type = _.FindDef(inst->type_id());
const auto source = _.FindDef(inst->GetOperandAs<uint32_t>(2u));
const auto source_type = _.FindDef(source->type_id());
if (!source_type || !result_type || source_type == result_type) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Result Type must not equal the Operand type";
}
if (!_.LogicallyMatch(source_type, result_type, false)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Result Type does not logically match the Operand type";
}
if (_.HasCapability(spv::Capability::Shader) &&
_.ContainsLimitedUseIntOrFloatType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Cannot copy composites of 8- or 16-bit types";
}
return SPV_SUCCESS;
}
spv_result_t ValidateCompositeConstructCoopMatQCOM(ValidationState_t& _,
const Instruction* inst) {
// Is the result of coop mat ?
const auto result_type_inst = _.FindDef(inst->type_id());
if (!result_type_inst ||
result_type_inst->opcode() != spv::Op::OpTypeCooperativeMatrixKHR) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the result type be OpTypeCooperativeMatrixKHR";
}
const auto source = _.FindDef(inst->GetOperandAs<uint32_t>(2u));
const auto source_type_inst = _.FindDef(source->type_id());
if (!source_type_inst || source_type_inst->opcode() != spv::Op::OpTypeArray) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the input operand be an OpTypeArray.";
}
// Is the scope Subgrouop ?
{
unsigned scope = UINT_MAX;
unsigned scope_id = result_type_inst->GetOperandAs<unsigned>(2u);
bool status = _.GetConstantValueAs<unsigned>(scope_id, scope);
bool is_scope_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(scope_id)->opcode());
if (!is_scope_spec_const &&
(!status || scope != static_cast<uint64_t>(spv::Scope::Subgroup))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the result type's scope be Subgroup.";
}
}
unsigned ar_len = UINT_MAX;
unsigned src_arr_len_id = source_type_inst->GetOperandAs<unsigned>(2u);
bool ar_len_status = _.GetConstantValueAs<unsigned>(src_arr_len_id, ar_len);
bool is_src_arr_len_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(src_arr_len_id)->opcode());
const auto source_elt_type = _.GetComponentType(source_type_inst->id());
const auto result_elt_type = result_type_inst->GetOperandAs<uint32_t>(1u);
if ((source_elt_type != result_elt_type) &&
!(_.ContainsSizedIntOrFloatType(source_elt_type, spv::Op::OpTypeInt,
32) &&
_.IsUnsignedIntScalarType(source_elt_type))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires ether the input element type is equal to the result "
"element type or it is the unsigned 32-bit integer.";
}
unsigned res_row_id = result_type_inst->GetOperandAs<unsigned>(3u);
unsigned res_col_id = result_type_inst->GetOperandAs<unsigned>(4u);
unsigned res_use_id = result_type_inst->GetOperandAs<unsigned>(5u);
unsigned cm_use = UINT_MAX;
bool cm_use_status = _.GetConstantValueAs<unsigned>(res_use_id, cm_use);
switch (static_cast<spv::CooperativeMatrixUse>(cm_use)) {
case spv::CooperativeMatrixUse::MatrixAKHR: {
// result coopmat component type check
if (!_.IsIntNOrFP32OrFP16<8>(result_elt_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the result element type is one of 8-bit OpTypeInt "
"signed/unsigned, 16- or 32-bit OpTypeFloat"
<< " when result coopmat's use is MatrixAKHR";
}
// result coopmat column length check
unsigned n_cols = UINT_MAX;
bool status = _.GetConstantValueAs<unsigned>(res_col_id, n_cols);
bool is_res_col_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(res_col_id)->opcode());
if (!is_res_col_spec_const &&
(!status || (!(_.ContainsSizedIntOrFloatType(result_elt_type,
spv::Op::OpTypeInt, 8) &&
n_cols == 32) &&
!(_.ContainsSizedIntOrFloatType(
result_elt_type, spv::Op::OpTypeFloat, 16) &&
n_cols == 16) &&
!(_.ContainsSizedIntOrFloatType(
result_elt_type, spv::Op::OpTypeFloat, 32) &&
n_cols == 8)))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the columns of the result coopmat have the bit "
"length of 256"
<< " when result coopmat's use is MatrixAKHR";
}
// source array length check
if (!is_src_arr_len_spec_const &&
(!ar_len_status ||
(!(_.ContainsSizedIntOrFloatType(source_elt_type, spv::Op::OpTypeInt,
32) &&
_.IsUnsignedIntScalarType(source_elt_type) && (ar_len == 8)) &&
!(n_cols == ar_len)))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the source array length be 8 if its elt type is "
"32-bit unsigned OpTypeInt and be the result's number of "
"columns, otherwise"
<< " when result coopmat's use is MatrixAKHR";
}
break;
}
case spv::CooperativeMatrixUse::MatrixBKHR: {
// result coopmat component type check
if (!_.IsIntNOrFP32OrFP16<8>(result_elt_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the result element type is one of 8-bit OpTypeInt "
"signed/unsigned, 16- or 32-bit OpTypeFloat"
<< " when result coopmat's use is MatrixBKHR";
}
// result coopmat row length check
unsigned n_rows = UINT_MAX;
bool status = _.GetConstantValueAs<unsigned>(res_row_id, n_rows);
bool is_res_row_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(res_row_id)->opcode());
if (!is_res_row_spec_const &&
(!status || (!(_.ContainsSizedIntOrFloatType(result_elt_type,
spv::Op::OpTypeInt, 8) &&
n_rows == 32) &&
!(_.ContainsSizedIntOrFloatType(
result_elt_type, spv::Op::OpTypeFloat, 16) &&
n_rows == 16) &&
!(_.ContainsSizedIntOrFloatType(
result_elt_type, spv::Op::OpTypeFloat, 32) &&
n_rows == 8)))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the rows of the result operand have the bit "
"length of 256"
<< " when result coopmat's use is MatrixBKHR";
}
// source array length check
if (!is_src_arr_len_spec_const &&
(!ar_len_status ||
(!(_.ContainsSizedIntOrFloatType(source_elt_type, spv::Op::OpTypeInt,
32) &&
_.IsUnsignedIntScalarType(source_elt_type) && (ar_len == 8)) &&
!(n_rows == ar_len)))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the source array length be 8 if its elt type is "
"32-bit unsigned OpTypeInt and be the result's number of "
"rows, otherwise"
<< " when result coopmat's use is MatrixBKHR";
}
break;
}
case spv::CooperativeMatrixUse::MatrixAccumulatorKHR: {
// result coopmat component type check
if (!_.IsIntNOrFP32OrFP16<32>(result_elt_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the result element type is one of 32-bit "
"OpTypeInt signed/unsigned, 16- or 32-bit OpTypeFloat"
<< " when result coopmat's use is MatrixAccumulatorKHR";
}
// source array length check
unsigned n_cols = UINT_MAX;
bool status = _.GetConstantValueAs<unsigned>(res_col_id, n_cols);
bool is_res_col_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(res_col_id)->opcode());
if (!is_res_col_spec_const && !is_src_arr_len_spec_const &&
(!status || !ar_len_status ||
(!(_.ContainsSizedIntOrFloatType(source_elt_type, spv::Op::OpTypeInt,
32) &&
_.IsUnsignedIntScalarType(source_elt_type) &&
(_.ContainsSizedIntOrFloatType(result_elt_type,
spv::Op::OpTypeFloat, 16)
? (n_cols / 2 == ar_len)
: n_cols == ar_len)) &&
(n_cols != ar_len)))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the source array length be a half of the number "
"of columns of the resulting cooerative matrix if the "
"matrix's componet type is 16-bit OpTypeFloat and be equal "
"to the number of columns, otherwise,"
<< " when result coopmat's use is MatrixAccumulatorKHR";
}
break;
}
default: {
bool is_cm_use_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(res_use_id)->opcode());
if (!is_cm_use_spec_const || !cm_use_status) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the the resulting cooerative matrix's use be "
<< " one of MatrixAKHR (== 0), MatrixBKHR (== 1), and "
"MatrixAccumulatorKHR (== 2)";
}
break;
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateCompositeExtractCoopMatQCOM(ValidationState_t& _,
const Instruction* inst) {
const auto result_type_inst = _.FindDef(inst->type_id());
if (!result_type_inst || result_type_inst->opcode() != spv::Op::OpTypeArray) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the input operand be an OpTypeArray.";
}
const auto source = _.FindDef(inst->GetOperandAs<uint32_t>(2u));
const auto source_type_inst = _.FindDef(source->type_id());
// Is the source of coop mat ?
if (!source_type_inst ||
source_type_inst->opcode() != spv::Op::OpTypeCooperativeMatrixKHR) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the source type be OpTypeCooperativeMatrixKHR";
}
// Is the scope Subgrouop ?
{
unsigned scope = UINT_MAX;
unsigned scope_id = source_type_inst->GetOperandAs<unsigned>(2u);
bool status = _.GetConstantValueAs<unsigned>(scope_id, scope);
bool is_scope_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(scope_id)->opcode());
if (!is_scope_spec_const &&
(!status || scope != static_cast<uint64_t>(spv::Scope::Subgroup))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the source type's scope be Subgroup.";
}
}
unsigned ar_len = UINT_MAX;
unsigned res_arr_len_id = result_type_inst->GetOperandAs<unsigned>(2u);
bool ar_len_status = _.GetConstantValueAs<unsigned>(res_arr_len_id, ar_len);
bool is_res_arr_len_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(res_arr_len_id)->opcode());
const auto source_elt_type = _.GetComponentType(source_type_inst->id());
const auto result_elt_type = result_type_inst->GetOperandAs<uint32_t>(1u);
unsigned src_row_id = source_type_inst->GetOperandAs<unsigned>(3u);
unsigned src_col_id = source_type_inst->GetOperandAs<unsigned>(4u);
unsigned src_use_id = source_type_inst->GetOperandAs<unsigned>(5u);
unsigned cm_use = UINT_MAX;
bool cm_use_status = _.GetConstantValueAs<unsigned>(src_use_id, cm_use);
switch (static_cast<spv::CooperativeMatrixUse>(cm_use)) {
case spv::CooperativeMatrixUse::MatrixAKHR: {
// source coopmat component type check
if (!_.IsIntNOrFP32OrFP16<8>(source_elt_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the source element type be one of 8-bit OpTypeInt "
"signed/unsigned, 16- or 32-bit OpTypeFloat"
<< " when source coopmat's use is MatrixAKHR";
}
// source coopmat column length check
unsigned n_cols = UINT_MAX;
bool status = _.GetConstantValueAs<unsigned>(src_col_id, n_cols);
bool is_src_col_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(src_col_id)->opcode());
if (!is_src_col_spec_const &&
(!status || (!(_.ContainsSizedIntOrFloatType(source_elt_type,
spv::Op::OpTypeInt, 8) &&
n_cols == 32) &&
!(_.ContainsSizedIntOrFloatType(
source_elt_type, spv::Op::OpTypeFloat, 16) &&
n_cols == 16) &&
!(_.ContainsSizedIntOrFloatType(
source_elt_type, spv::Op::OpTypeFloat, 32) &&
n_cols == 8)))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the columns of the source coopmat have the bit "
"length of 256"
<< " when source coopmat's use is MatrixAKHR";
}
// result type check
if (!is_res_arr_len_spec_const &&
!(source_elt_type == result_elt_type && (n_cols == ar_len)) &&
!(_.ContainsSizedIntOrFloatType(result_elt_type, spv::Op::OpTypeInt,
32) &&
_.IsUnsignedIntScalarType(result_elt_type) && (ar_len == 8))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires either the result element type be the same as the "
"source cooperative matrix's component type"
<< " and its length be the same as the number of columns of the "
"matrix or the result element type be"
<< " unsigned 32-bit OpTypeInt and the length be 8"
<< " when source coopmat's use is MatrixAKHR";
}
break;
}
case spv::CooperativeMatrixUse::MatrixBKHR: {
// source coopmat component type check
if (!_.IsIntNOrFP32OrFP16<8>(source_elt_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the source element type be one of 8-bit OpTypeInt "
"signed/unsigned, 16- or 32-bit OpTypeFloat"
<< " when source coopmat's use is MatrixBKHR";
}
// source coopmat row length check
unsigned n_rows = UINT_MAX;
bool status = _.GetConstantValueAs<unsigned>(src_row_id, n_rows);
bool is_src_row_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(src_row_id)->opcode());
if (!is_src_row_spec_const &&
(!status || (!(_.ContainsSizedIntOrFloatType(source_elt_type,
spv::Op::OpTypeInt, 8) &&
n_rows == 32) &&
!(_.ContainsSizedIntOrFloatType(
source_elt_type, spv::Op::OpTypeFloat, 16) &&
n_rows == 16) &&
!(_.ContainsSizedIntOrFloatType(
source_elt_type, spv::Op::OpTypeFloat, 32) &&
n_rows == 8)))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the rows of the source coopmat have the bit "
"length of 256"
<< " when source coopmat's use is MatrixBKHR";
}
// result type check
if (!is_res_arr_len_spec_const &&
!(source_elt_type == result_elt_type && (n_rows == ar_len)) &&
!(_.ContainsSizedIntOrFloatType(result_elt_type, spv::Op::OpTypeInt,
32) &&
_.IsUnsignedIntScalarType(result_elt_type) && (ar_len == 8))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires either the result element type be the same as the "
"source cooperative matrix's component type"
<< " and its length be the same as the number of rows of the "
"matrix or the result element type be"
<< " unsigned 32-bit OpTypeInt and the length be 8"
<< " when source coopmat's use is MatrixBKHR";
}
break;
}
case spv::CooperativeMatrixUse::MatrixAccumulatorKHR: {
// source coopmat component type check
if (!_.IsIntNOrFP32OrFP16<32>(source_elt_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the source element type be one of 32-bit "
"OpTypeInt signed/unsigned, 16- or 32-bit OpTypeFloat"
<< " when source coopmat's use is MatrixAccumulatorKHR";
}
// result type check
unsigned n_cols = UINT_MAX;
bool status = _.GetConstantValueAs<unsigned>(src_col_id, n_cols);
bool is_src_col_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(src_col_id)->opcode());
if (!is_src_col_spec_const && !is_res_arr_len_spec_const &&
(!status || !ar_len_status ||
(!(source_elt_type == result_elt_type && (n_cols == ar_len)) &&
!(_.ContainsSizedIntOrFloatType(result_elt_type, spv::Op::OpTypeInt,
32) &&
_.IsUnsignedIntScalarType(result_elt_type) &&
(_.ContainsSizedIntOrFloatType(source_elt_type,
spv::Op::OpTypeFloat, 16)
? (n_cols / 2 == ar_len)
: (n_cols == ar_len)))))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires either the result element type be the same as the "
"source cooperative matrix's component type"
<< " and its length be the same as the number of columns of the "
"matrix or the result element type be"
<< " unsigned 32-bit OpTypeInt and the length be the number of "
"the columns of the matrix if its component"
<< " type is 32-bit OpTypeFloat and be a half of the number of "
"the columns of the matrix if its component"
<< " type is 16-bit OpTypeFloat"
<< " when source coopmat's use is MatrixAccumulatorKHR";
}
break;
}
default: {
bool is_cm_use_spec_const =
spvOpcodeIsSpecConstant(_.FindDef(src_use_id)->opcode());
if (!is_cm_use_spec_const || !cm_use_status) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the the source cooerative matrix's use be "
<< " one of MatrixAKHR (== 0), MatrixBKHR (== 1), and "
"MatrixAccumulatorKHR (== 2)";
}
break;
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateExtractSubArrayQCOM(ValidationState_t& _,
const Instruction* inst) {
const auto result_type_inst = _.FindDef(inst->type_id());
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(inst->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());
// Do the input and result element types match?
if (source_elt_type != result_elt_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the input and result element types match.";
}
// Elt type must be one of int32_t/uint32_t/float32/float16
if (!_.IsIntNOrFP32OrFP16<32>(source_elt_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the element type be one of 32-bit OpTypeInt "
"(signed/unsigned), 32-bit OpTypeFloat and 16-bit OpTypeFloat";
}
const auto start_index = _.FindDef(inst->GetOperandAs<uint32_t>(3u));
if (!start_index || !_.ContainsSizedIntOrFloatType(start_index->type_id(),
spv::Op::OpTypeInt, 32)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Opcode " << spvOpcodeString(inst->opcode())
<< " requires the type of the start index operand be 32-bit "
"OpTypeInt";
}
return SPV_SUCCESS;
}
} // anonymous namespace
// Validates correctness of composite instructions.
spv_result_t CompositesPass(ValidationState_t& _, const Instruction* inst) {
switch (inst->opcode()) {
case spv::Op::OpVectorExtractDynamic:
return ValidateVectorExtractDynamic(_, inst);
case spv::Op::OpVectorInsertDynamic:
return ValidateVectorInsertDyanmic(_, inst);
case spv::Op::OpVectorShuffle:
return ValidateVectorShuffle(_, inst);
case spv::Op::OpCompositeConstruct:
return ValidateCompositeConstruct(_, inst);
case spv::Op::OpCompositeExtract:
return ValidateCompositeExtract(_, inst);
case spv::Op::OpCompositeInsert:
return ValidateCompositeInsert(_, inst);
case spv::Op::OpCopyObject:
return ValidateCopyObject(_, inst);
case spv::Op::OpTranspose:
return ValidateTranspose(_, inst);
case spv::Op::OpCopyLogical:
return ValidateCopyLogical(_, inst);
case spv::Op::OpCompositeConstructCoopMatQCOM:
return ValidateCompositeConstructCoopMatQCOM(_, inst);
case spv::Op::OpCompositeExtractCoopMatQCOM:
return ValidateCompositeExtractCoopMatQCOM(_, inst);
case spv::Op::OpExtractSubArrayQCOM:
return ValidateExtractSubArrayQCOM(_, inst);
default:
break;
}
return SPV_SUCCESS;
}
} // namespace val
} // namespace spvtools
Reference in New Issue View Git Blame Copy Permalink