| // Copyright (c) 2023-2025 Arm Ltd. |
| // |
| // 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 graph instructions. |
| |
| #include <deque> |
| |
| #include "source/opcode.h" |
| #include "source/val/validate.h" |
| #include "source/val/validation_state.h" |
| |
| namespace spvtools { |
| namespace val { |
| namespace { |
| |
| bool IsTensorArray(ValidationState_t& _, uint32_t id) { |
| auto def = _.FindDef(id); |
| if (!def || (def->opcode() != spv::Op::OpTypeArray && |
| def->opcode() != spv::Op::OpTypeRuntimeArray)) { |
| return false; |
| } |
| auto tdef = _.FindDef(def->word(2)); |
| if (!tdef || tdef->opcode() != spv::Op::OpTypeTensorARM) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool IsGraphInterfaceType(ValidationState_t& _, uint32_t id) { |
| return _.IsTensorType(id) || IsTensorArray(_, id); |
| } |
| |
| bool IsGraph(ValidationState_t& _, uint32_t id) { |
| auto def = _.FindDef(id); |
| if (!def || def->opcode() != spv::Op::OpGraphARM) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool IsGraphType(ValidationState_t& _, uint32_t id) { |
| auto def = _.FindDef(id); |
| if (!def || def->opcode() != spv::Op::OpTypeGraphARM) { |
| return false; |
| } |
| return true; |
| } |
| |
| const uint32_t kGraphTypeIOStartWord = 3; |
| |
| uint32_t GraphTypeInstNumIO(const Instruction* inst) { |
| return static_cast<uint32_t>(inst->words().size()) - kGraphTypeIOStartWord; |
| } |
| |
| uint32_t GraphTypeInstNumInputs(const Instruction* inst) { |
| return inst->word(2); |
| } |
| |
| uint32_t GraphTypeInstNumOutputs(const Instruction* inst) { |
| return GraphTypeInstNumIO(inst) - GraphTypeInstNumInputs(inst); |
| } |
| |
| uint32_t GraphTypeInstGetOutputAtIndex(const Instruction* inst, |
| uint64_t index) { |
| return inst->word(kGraphTypeIOStartWord + GraphTypeInstNumInputs(inst) + |
| static_cast<uint32_t>(index)); |
| } |
| |
| uint32_t GraphTypeInstGetInputAtIndex(const Instruction* inst, uint64_t index) { |
| return inst->word(kGraphTypeIOStartWord + static_cast<uint32_t>(index)); |
| } |
| |
| spv_result_t ValidateGraphType(ValidationState_t& _, const Instruction* inst) { |
| // Check there are at least NumInputs types |
| uint32_t NumInputs = GraphTypeInstNumInputs(inst); |
| size_t NumIOTypes = GraphTypeInstNumIO(inst); |
| if (NumIOTypes < NumInputs) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << NumIOTypes << " I/O types were provided but the graph has " |
| << NumInputs << " inputs."; |
| } |
| |
| // Check there is at least one output |
| if (NumIOTypes == NumInputs) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "A graph type must have at least one output."; |
| } |
| |
| // Check all I/O types are graph interface type |
| for (unsigned i = kGraphTypeIOStartWord; i < inst->words().size(); i++) { |
| auto tid = inst->word(i); |
| if (!IsGraphInterfaceType(_, tid)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "I/O type " << _.getIdName(tid) |
| << " is not a Graph Interface Type."; |
| } |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t ValidateGraphConstant(ValidationState_t& _, |
| const Instruction* inst) { |
| // Check Result Type |
| if (!_.IsTensorType(inst->type_id())) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) |
| << " must have a Result Type that is a tensor type."; |
| } |
| |
| // Check the instruction is not preceded by another OpGraphConstantARM with |
| // the same ID |
| const uint32_t cst_id = inst->word(3); |
| size_t inst_num = inst->LineNum() - 1; |
| while (--inst_num) { |
| auto prev_inst = &_.ordered_instructions()[inst_num]; |
| if (prev_inst->opcode() == spv::Op::OpGraphConstantARM) { |
| const uint32_t prev_cst_id = prev_inst->word(3); |
| if (prev_cst_id == cst_id) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "No two OpGraphConstantARM instructions may have the same " |
| "GraphConstantID"; |
| } |
| } |
| } |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t ValidateGraphEntryPoint(ValidationState_t& _, |
| const Instruction* inst) { |
| // Graph must be an OpGraphARM |
| uint32_t graph = inst->GetOperandAs<uint32_t>(0); |
| auto graph_inst = _.FindDef(graph); |
| if (!IsGraph(_, graph)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) |
| << " Graph must be a OpGraphARM but found " |
| << spvOpcodeString(graph_inst->opcode()) << "."; |
| } |
| |
| // Check number of Interface IDs matches number of I/Os of graph |
| auto graph_type_inst = _.FindDef(graph_inst->type_id()); |
| size_t graph_type_num_io = GraphTypeInstNumIO(graph_type_inst); |
| size_t graph_entry_point_num_interface_id = inst->operands().size() - 2; |
| if (graph_type_inst->opcode() != spv::Op::OpTypeGraphARM) { |
| // This is invalid but we want ValidateGraph to report a clear error |
| // so stop validating the graph entry point instruction |
| return SPV_SUCCESS; |
| } |
| if (graph_type_num_io != graph_entry_point_num_interface_id) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) << " Interface list contains " |
| << graph_entry_point_num_interface_id << " IDs but Graph's type " |
| << _.getIdName(graph_inst->type_id()) << " has " << graph_type_num_io |
| << " inputs and outputs."; |
| } |
| |
| // Check Interface IDs |
| for (uint32_t i = 2; i < inst->operands().size(); i++) { |
| uint32_t interface_id = inst->GetOperandAs<uint32_t>(i); |
| auto interface_inst = _.FindDef(interface_id); |
| |
| // Check interface IDs come from OpVariable |
| if ((interface_inst->opcode() != spv::Op::OpVariable) || |
| (interface_inst->GetOperandAs<spv::StorageClass>(2) != |
| spv::StorageClass::UniformConstant)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, interface_inst) |
| << spvOpcodeString(inst->opcode()) << " Interface ID " |
| << _.getIdName(interface_id) |
| << " must come from OpVariable with UniformConstant Storage " |
| "Class."; |
| } |
| |
| // Check type of interface variable matches type of the corresponding graph |
| // I/O |
| uint32_t corresponding_graph_io_type = |
| graph_type_inst->GetOperandAs<uint32_t>(i); |
| |
| uint32_t interface_ptr_type = interface_inst->type_id(); |
| auto interface_ptr_inst = _.FindDef(interface_ptr_type); |
| auto interface_pointee_type = interface_ptr_inst->GetOperandAs<uint32_t>(2); |
| if (interface_pointee_type != corresponding_graph_io_type) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) << " Interface ID type " |
| << _.getIdName(interface_pointee_type) |
| << " must match the type of the corresponding graph I/O " |
| << _.getIdName(corresponding_graph_io_type); |
| } |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t ValidateGraph(ValidationState_t& _, const Instruction* inst) { |
| // Result Type must be an OpTypeGraphARM |
| if (!IsGraphType(_, inst->type_id())) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) |
| << " Result Type must be an OpTypeGraphARM."; |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t ValidateGraphInput(ValidationState_t& _, const Instruction* inst) { |
| // Check type of InputIndex |
| auto input_index_inst = _.FindDef(inst->GetOperandAs<uint32_t>(2)); |
| if (!input_index_inst || |
| !_.IsIntScalarType(input_index_inst->type_id(), 32)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) |
| << " InputIndex must be a 32-bit integer."; |
| } |
| |
| bool has_element_index = inst->operands().size() > 3; |
| |
| // Check type of ElementIndex |
| if (has_element_index) { |
| auto element_index_inst = _.FindDef(inst->GetOperandAs<uint32_t>(3)); |
| if (!element_index_inst || |
| !_.IsIntScalarType(element_index_inst->type_id(), 32)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) |
| << " ElementIndex must be a 32-bit integer."; |
| } |
| } |
| |
| // Find graph definition |
| size_t inst_num = inst->LineNum() - 1; |
| auto graph_inst = &_.ordered_instructions()[inst_num]; |
| while (--inst_num) { |
| graph_inst = &_.ordered_instructions()[inst_num]; |
| if (graph_inst->opcode() == spv::Op::OpGraphARM) { |
| break; |
| } |
| } |
| |
| // Can the InputIndex be evaluated? |
| // If not, there's nothing more we can validate here. |
| uint64_t input_index; |
| if (!_.EvalConstantValUint64(inst->GetOperandAs<uint32_t>(2), &input_index)) { |
| return SPV_SUCCESS; |
| } |
| |
| auto const graph_type_inst = _.FindDef(graph_inst->type_id()); |
| size_t graph_type_num_inputs = graph_type_inst->GetOperandAs<uint32_t>(1); |
| |
| // Check InputIndex is in range |
| if (input_index >= graph_type_num_inputs) { |
| std::string disassembly = _.Disassemble(*inst); |
| return _.diag(SPV_ERROR_INVALID_DATA, nullptr) |
| << "Type " << _.getIdName(graph_type_inst->id()) << " for graph " |
| << _.getIdName(graph_inst->id()) << " has " << graph_type_num_inputs |
| << " inputs but found an OpGraphInputARM instruction with an " |
| "InputIndex that is " |
| << input_index << ": " << disassembly; |
| } |
| |
| uint32_t graph_type_input_type = |
| GraphTypeInstGetInputAtIndex(graph_type_inst, input_index); |
| |
| if (has_element_index) { |
| // Check ElementIndex is allowed |
| if (!IsTensorArray(_, graph_type_input_type)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "OpGraphInputARM ElementIndex not allowed when the graph input " |
| "selected by " |
| << "InputIndex is not an OpTypeArray or OpTypeRuntimeArray"; |
| } |
| |
| // Check ElementIndex is in range if it can be evaluated and the input is a |
| // fixed-sized array whose Length can be evaluated |
| uint64_t element_index; |
| if (_.IsArrayType(graph_type_input_type) && |
| _.EvalConstantValUint64(inst->GetOperandAs<uint32_t>(3), |
| &element_index)) { |
| uint64_t array_length; |
| auto graph_type_input_type_inst = _.FindDef(graph_type_input_type); |
| if (_.EvalConstantValUint64( |
| graph_type_input_type_inst->GetOperandAs<uint32_t>(2), |
| &array_length)) { |
| if (element_index >= array_length) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "OpGraphInputARM ElementIndex out of range. The type of " |
| "the graph input being accessed " |
| << _.getIdName(graph_type_input_type) << " is an array of " |
| << array_length << " elements but " << "ElementIndex is " |
| << element_index; |
| } |
| } |
| } |
| } |
| |
| // Check result type matches with graph type |
| if (has_element_index) { |
| uint32_t expected_type = _.GetComponentType(graph_type_input_type); |
| if (inst->type_id() != expected_type) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result Type " << _.getIdName(inst->type_id()) |
| << " of graph input instruction " << _.getIdName(inst->id()) |
| << " does not match the component type " |
| << _.getIdName(expected_type) << " of input " << input_index |
| << " in the graph type."; |
| } |
| } else { |
| if (inst->type_id() != graph_type_input_type) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "Result Type " << _.getIdName(inst->type_id()) |
| << " of graph input instruction " << _.getIdName(inst->id()) |
| << " does not match the type " |
| << _.getIdName(graph_type_input_type) << " of input " |
| << input_index << " in the graph type."; |
| } |
| } |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t ValidateGraphSetOutput(ValidationState_t& _, |
| const Instruction* inst) { |
| // Check type of OutputIndex |
| auto output_index_inst = _.FindDef(inst->GetOperandAs<uint32_t>(1)); |
| if (!output_index_inst || |
| !_.IsIntScalarType(output_index_inst->type_id(), 32)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) |
| << " OutputIndex must be a 32-bit integer."; |
| } |
| |
| bool has_element_index = inst->operands().size() > 2; |
| |
| // Check type of ElementIndex |
| if (has_element_index) { |
| auto element_index_inst = _.FindDef(inst->GetOperandAs<uint32_t>(2)); |
| if (!element_index_inst || |
| !_.IsIntScalarType(element_index_inst->type_id(), 32)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) |
| << " ElementIndex must be a 32-bit integer."; |
| } |
| } |
| |
| // Find graph definition |
| size_t inst_num = inst->LineNum() - 1; |
| auto graph_inst = &_.ordered_instructions()[inst_num]; |
| while (--inst_num) { |
| graph_inst = &_.ordered_instructions()[inst_num]; |
| if (graph_inst->opcode() == spv::Op::OpGraphARM) { |
| break; |
| } |
| } |
| |
| // Can the OutputIndex be evaluated? |
| // If not, there's nothing more we can validate here. |
| uint64_t output_index; |
| if (!_.EvalConstantValUint64(inst->GetOperandAs<uint32_t>(1), |
| &output_index)) { |
| return SPV_SUCCESS; |
| } |
| |
| // Check that the OutputIndex is valid with respect to the graph type |
| auto graph_type_inst = _.FindDef(graph_inst->type_id()); |
| size_t graph_type_num_outputs = GraphTypeInstNumOutputs(graph_type_inst); |
| |
| if (output_index >= graph_type_num_outputs) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << spvOpcodeString(inst->opcode()) << " setting OutputIndex " |
| << output_index << " but graph only has " << graph_type_num_outputs |
| << " outputs."; |
| } |
| |
| uint32_t graph_type_output_type = |
| GraphTypeInstGetOutputAtIndex(graph_type_inst, output_index); |
| |
| if (has_element_index) { |
| // Check ElementIndex is allowed |
| if (!IsTensorArray(_, graph_type_output_type)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "OpGraphSetOutputARM ElementIndex not allowed when the graph " |
| "output selected by " |
| << "OutputIndex is not an OpTypeArray or OpTypeRuntimeArray"; |
| } |
| |
| // Check ElementIndex is in range if it can be evaluated and the output is a |
| // fixed-sized array whose Length can be evaluated |
| uint64_t element_index; |
| if (_.IsArrayType(graph_type_output_type) && |
| _.EvalConstantValUint64(inst->GetOperandAs<uint32_t>(2), |
| &element_index)) { |
| uint64_t array_length; |
| auto graph_type_output_type_inst = _.FindDef(graph_type_output_type); |
| if (_.EvalConstantValUint64( |
| graph_type_output_type_inst->GetOperandAs<uint32_t>(2), |
| &array_length)) { |
| if (element_index >= array_length) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "OpGraphSetOutputARM ElementIndex out of range. The type " |
| "of the graph output being accessed " |
| << _.getIdName(graph_type_output_type) << " is an array of " |
| << array_length << " elements but " << "ElementIndex is " |
| << element_index; |
| } |
| } |
| } |
| } |
| |
| // Check Value's type matches with graph type |
| uint32_t value = inst->GetOperandAs<uint32_t>(0); |
| uint32_t value_type = _.FindDef(value)->type_id(); |
| if (has_element_index) { |
| uint32_t expected_type = _.GetComponentType(graph_type_output_type); |
| if (value_type != expected_type) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "The type " << _.getIdName(value_type) |
| << " of Value provided to the graph output instruction " |
| << _.getIdName(value) << " does not match the component type " |
| << _.getIdName(expected_type) << " of output " << output_index |
| << " in the graph type."; |
| } |
| } else { |
| if (value_type != graph_type_output_type) { |
| return _.diag(SPV_ERROR_INVALID_DATA, inst) |
| << "The type " << _.getIdName(value_type) |
| << " of Value provided to the graph output instruction " |
| << _.getIdName(value) << " does not match the type " |
| << _.getIdName(graph_type_output_type) << " of output " |
| << output_index << " in the graph type."; |
| } |
| } |
| return SPV_SUCCESS; |
| } |
| |
| bool InputOutputInstructionsHaveDuplicateIndices( |
| ValidationState_t& _, std::deque<const Instruction*>& inout_insts, |
| const Instruction** first_dup) { |
| std::set<std::pair<uint64_t, uint64_t>> inout_element_indices; |
| for (auto const inst : inout_insts) { |
| const bool is_input = inst->opcode() == spv::Op::OpGraphInputARM; |
| bool has_element_index = inst->operands().size() > (is_input ? 3 : 2); |
| uint64_t inout_index; |
| if (!_.EvalConstantValUint64(inst->GetOperandAs<uint32_t>(is_input ? 2 : 1), |
| &inout_index)) { |
| continue; |
| } |
| uint64_t element_index = -1; // -1 means no ElementIndex |
| if (has_element_index) { |
| if (!_.EvalConstantValUint64( |
| inst->GetOperandAs<uint32_t>(is_input ? 3 : 2), &element_index)) { |
| continue; |
| } |
| } |
| auto inout_element_pair = std::make_pair(inout_index, element_index); |
| auto inout_noelement_pair = std::make_pair(inout_index, -1); |
| if (inout_element_indices.count(inout_element_pair) || |
| inout_element_indices.count(inout_noelement_pair)) { |
| *first_dup = inst; |
| return true; |
| } |
| inout_element_indices.insert(inout_element_pair); |
| } |
| return false; |
| } |
| |
| spv_result_t ValidateGraphEnd(ValidationState_t& _, const Instruction* inst) { |
| size_t end_inst_num = inst->LineNum() - 1; |
| |
| // Gather OpGraphInputARM and OpGraphSetOutputARM instructions |
| std::deque<const Instruction*> graph_inputs, graph_outputs; |
| size_t in_inst_num = end_inst_num; |
| auto graph_inst = &_.ordered_instructions()[in_inst_num]; |
| while (--in_inst_num) { |
| graph_inst = &_.ordered_instructions()[in_inst_num]; |
| if (graph_inst->opcode() == spv::Op::OpGraphInputARM) { |
| graph_inputs.push_front(graph_inst); |
| continue; |
| } |
| if (graph_inst->opcode() == spv::Op::OpGraphSetOutputARM) { |
| graph_outputs.push_front(graph_inst); |
| continue; |
| } |
| if (graph_inst->opcode() == spv::Op::OpGraphARM) { |
| break; |
| } |
| } |
| |
| const Instruction* first_dup; |
| |
| // Check that there are no duplicate InputIndex and ElementIndex values |
| if (InputOutputInstructionsHaveDuplicateIndices(_, graph_inputs, |
| &first_dup)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, first_dup) |
| << "Two OpGraphInputARM instructions with the same InputIndex " |
| "must not be part of the same " |
| << "graph definition unless ElementIndex is present in both with " |
| "different values."; |
| } |
| |
| // Check that there are no duplicate OutputIndex and ElementIndex values |
| if (InputOutputInstructionsHaveDuplicateIndices(_, graph_outputs, |
| &first_dup)) { |
| return _.diag(SPV_ERROR_INVALID_DATA, first_dup) |
| << "Two OpGraphSetOutputARM instructions with the same " |
| "OutputIndex must not be part of the same " |
| << "graph definition unless ElementIndex is present in both with " |
| "different values."; |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| } // namespace |
| |
| // Validates correctness of graph instructions. |
| spv_result_t GraphPass(ValidationState_t& _, const Instruction* inst) { |
| switch (inst->opcode()) { |
| case spv::Op::OpTypeGraphARM: |
| return ValidateGraphType(_, inst); |
| case spv::Op::OpGraphConstantARM: |
| return ValidateGraphConstant(_, inst); |
| case spv::Op::OpGraphEntryPointARM: |
| return ValidateGraphEntryPoint(_, inst); |
| case spv::Op::OpGraphARM: |
| return ValidateGraph(_, inst); |
| case spv::Op::OpGraphInputARM: |
| return ValidateGraphInput(_, inst); |
| case spv::Op::OpGraphSetOutputARM: |
| return ValidateGraphSetOutput(_, inst); |
| case spv::Op::OpGraphEndARM: |
| return ValidateGraphEnd(_, inst); |
| default: |
| break; |
| } |
| return SPV_SUCCESS; |
| } |
| |
| } // namespace val |
| } // namespace spvtools |
