| // Copyright (c) 2015-2016 The Khronos Group 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. |
| |
| #include "validate.h" |
| |
| #include <cassert> |
| |
| #include <algorithm> |
| #include <iostream> |
| #include <iterator> |
| #include <stack> |
| #include <unordered_set> |
| #include <utility> |
| #include <vector> |
| |
| #include "diagnostic.h" |
| #include "instruction.h" |
| #include "message.h" |
| #include "opcode.h" |
| #include "operand.h" |
| #include "spirv-tools/libspirv.h" |
| #include "spirv_validator_options.h" |
| #include "val/function.h" |
| #include "val/validation_state.h" |
| |
| using std::function; |
| using std::ignore; |
| using std::make_pair; |
| using std::pair; |
| using std::unordered_set; |
| using std::vector; |
| |
| namespace spvtools { |
| namespace val { |
| namespace { |
| |
| class idUsage { |
| public: |
| idUsage(spv_const_context context, const spv_instruction_t* pInsts, |
| const uint64_t instCountArg, const SpvMemoryModel memoryModelArg, |
| const SpvAddressingModel addressingModelArg, |
| const ValidationState_t& module, const vector<uint32_t>& entry_points, |
| spv_position positionArg, const MessageConsumer& consumer) |
| : targetEnv(context->target_env), |
| opcodeTable(context->opcode_table), |
| operandTable(context->operand_table), |
| extInstTable(context->ext_inst_table), |
| firstInst(pInsts), |
| instCount(instCountArg), |
| memoryModel(memoryModelArg), |
| addressingModel(addressingModelArg), |
| position(positionArg), |
| consumer_(consumer), |
| module_(module), |
| entry_points_(entry_points) {} |
| |
| bool isValid(const spv_instruction_t* inst); |
| |
| template <SpvOp> |
| bool isValid(const spv_instruction_t* inst, const spv_opcode_desc); |
| |
| private: |
| const spv_target_env targetEnv; |
| const spv_opcode_table opcodeTable; |
| const spv_operand_table operandTable; |
| const spv_ext_inst_table extInstTable; |
| const spv_instruction_t* const firstInst; |
| const uint64_t instCount; |
| const SpvMemoryModel memoryModel; |
| const SpvAddressingModel addressingModel; |
| spv_position position; |
| const MessageConsumer& consumer_; |
| const ValidationState_t& module_; |
| vector<uint32_t> entry_points_; |
| |
| // Returns true if the two instructions represent structs that, as far as the |
| // validator can tell, have the exact same data layout. |
| bool AreLayoutCompatibleStructs(const Instruction* type1, |
| const Instruction* type2); |
| |
| // Returns true if the operands to the OpTypeStruct instruction defining the |
| // types are the same or are layout compatible types. |type1| and |type2| must |
| // be OpTypeStruct instructions. |
| bool HaveLayoutCompatibleMembers(const Instruction* type1, |
| const Instruction* type2); |
| |
| // Returns true if all decorations that affect the data layout of the struct |
| // (like Offset), are the same for the two types. |type1| and |type2| must be |
| // OpTypeStruct instructions. |
| bool HaveSameLayoutDecorations(const Instruction* type1, |
| const Instruction* type2); |
| bool HasConflictingMemberOffsets( |
| const vector<Decoration>& type1_decorations, |
| const vector<Decoration>& type2_decorations) const; |
| }; |
| |
| #define DIAG(inst) \ |
| position->index = inst ? inst->InstructionPosition() : -1; \ |
| std::string disassembly; \ |
| if (inst) { \ |
| disassembly = module_.Disassemble( \ |
| inst->words().data(), static_cast<uint16_t>(inst->words().size())); \ |
| } \ |
| DiagnosticStream helper(*position, consumer_, disassembly, \ |
| SPV_ERROR_INVALID_DIAGNOSTIC); \ |
| helper |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<SpvOpUndef>(const spv_instruction_t *inst, |
| const spv_opcode_desc) { |
| assert(0 && "Unimplemented!"); |
| return false; |
| } |
| #endif // 0 |
| |
| template <> |
| bool idUsage::isValid<SpvOpMemberName>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto typeIndex = 1; |
| auto type = module_.FindDef(inst->words[typeIndex]); |
| if (!type || SpvOpTypeStruct != type->opcode()) { |
| DIAG(type) << "OpMemberName Type <id> '" |
| << module_.getIdName(inst->words[typeIndex]) |
| << "' is not a struct type."; |
| return false; |
| } |
| auto memberIndex = 2; |
| auto member = inst->words[memberIndex]; |
| auto memberCount = (uint32_t)(type->words().size() - 2); |
| if (memberCount <= member) { |
| DIAG(module_.FindDef(member)) |
| << "OpMemberName Member <id> '" |
| << module_.getIdName(inst->words[memberIndex]) |
| << "' index is larger than Type <id> '" << module_.getIdName(type->id()) |
| << "'s member count."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpLine>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto fileIndex = 1; |
| auto file = module_.FindDef(inst->words[fileIndex]); |
| if (!file || SpvOpString != file->opcode()) { |
| DIAG(file) << "OpLine Target <id> '" |
| << module_.getIdName(inst->words[fileIndex]) |
| << "' is not an OpString."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpDecorate>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto decorationIndex = 2; |
| auto decoration = inst->words[decorationIndex]; |
| if (decoration == SpvDecorationSpecId) { |
| auto targetIndex = 1; |
| auto target = module_.FindDef(inst->words[targetIndex]); |
| if (!target || !spvOpcodeIsScalarSpecConstant(target->opcode())) { |
| DIAG(target) << "OpDecorate SpectId decoration target <id> '" |
| << module_.getIdName(inst->words[decorationIndex]) |
| << "' is not a scalar specialization constant."; |
| return false; |
| } |
| } |
| // TODO: Add validations for all decorations. |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpMemberDecorate>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto structTypeIndex = 1; |
| auto structType = module_.FindDef(inst->words[structTypeIndex]); |
| if (!structType || SpvOpTypeStruct != structType->opcode()) { |
| DIAG(structType) << "OpMemberDecorate Structure type <id> '" |
| << module_.getIdName(inst->words[structTypeIndex]) |
| << "' is not a struct type."; |
| return false; |
| } |
| auto memberIndex = 2; |
| auto member = inst->words[memberIndex]; |
| auto memberCount = static_cast<uint32_t>(structType->words().size() - 2); |
| if (memberCount < member) { |
| DIAG(structType) << "Index " << member |
| << " provided in OpMemberDecorate for struct <id> " |
| << module_.getIdName(inst->words[structTypeIndex]) |
| << " is out of bounds. The structure has " << memberCount |
| << " members. Largest valid index is " << memberCount - 1 |
| << "."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpDecorationGroup>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto decorationGroupIndex = 1; |
| auto decorationGroup = module_.FindDef(inst->words[decorationGroupIndex]); |
| |
| for (auto pair : decorationGroup->uses()) { |
| auto use = pair.first; |
| if (use->opcode() != SpvOpDecorate && use->opcode() != SpvOpGroupDecorate && |
| use->opcode() != SpvOpGroupMemberDecorate && |
| use->opcode() != SpvOpName) { |
| DIAG(decorationGroup) << "Result id of OpDecorationGroup can only " |
| << "be targeted by OpName, OpGroupDecorate, " |
| << "OpDecorate, and OpGroupMemberDecorate"; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpGroupDecorate>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto decorationGroupIndex = 1; |
| auto decorationGroup = module_.FindDef(inst->words[decorationGroupIndex]); |
| if (!decorationGroup || SpvOpDecorationGroup != decorationGroup->opcode()) { |
| DIAG(decorationGroup) << "OpGroupDecorate Decoration group <id> '" |
| << module_.getIdName( |
| inst->words[decorationGroupIndex]) |
| << "' is not a decoration group."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpGroupMemberDecorate>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto decorationGroupIndex = 1; |
| auto decorationGroup = module_.FindDef(inst->words[decorationGroupIndex]); |
| if (!decorationGroup || SpvOpDecorationGroup != decorationGroup->opcode()) { |
| DIAG(decorationGroup) << "OpGroupMemberDecorate Decoration group <id> '" |
| << module_.getIdName( |
| inst->words[decorationGroupIndex]) |
| << "' is not a decoration group."; |
| return false; |
| } |
| // Grammar checks ensures that the number of arguments to this instruction |
| // is an odd number: 1 decoration group + (id,literal) pairs. |
| for (size_t i = 2; i + 1 < inst->words.size(); i = i + 2) { |
| const uint32_t struct_id = inst->words[i]; |
| const uint32_t index = inst->words[i + 1]; |
| auto struct_instr = module_.FindDef(struct_id); |
| if (!struct_instr || SpvOpTypeStruct != struct_instr->opcode()) { |
| DIAG(struct_instr) << "OpGroupMemberDecorate Structure type <id> '" |
| << module_.getIdName(struct_id) |
| << "' is not a struct type."; |
| return false; |
| } |
| const uint32_t num_struct_members = |
| static_cast<uint32_t>(struct_instr->words().size() - 2); |
| if (index >= num_struct_members) { |
| DIAG(struct_instr) |
| << "Index " << index |
| << " provided in OpGroupMemberDecorate for struct <id> " |
| << module_.getIdName(struct_id) |
| << " is out of bounds. The structure has " << num_struct_members |
| << " members. Largest valid index is " << num_struct_members - 1 |
| << "."; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<SpvOpExtInst>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif // 0 |
| |
| template <> |
| bool idUsage::isValid<SpvOpEntryPoint>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto entryPointIndex = 2; |
| auto entryPoint = module_.FindDef(inst->words[entryPointIndex]); |
| if (!entryPoint || SpvOpFunction != entryPoint->opcode()) { |
| DIAG(entryPoint) << "OpEntryPoint Entry Point <id> '" |
| << module_.getIdName(inst->words[entryPointIndex]) |
| << "' is not a function."; |
| return false; |
| } |
| // don't check kernel function signatures |
| const SpvExecutionModel executionModel = SpvExecutionModel(inst->words[1]); |
| if (executionModel != SpvExecutionModelKernel) { |
| // TODO: Check the entry point signature is void main(void), may be subject |
| // to change |
| auto entryPointType = module_.FindDef(entryPoint->words()[4]); |
| if (!entryPointType || 3 != entryPointType->words().size()) { |
| DIAG(entryPoint) << "OpEntryPoint Entry Point <id> '" |
| << module_.getIdName(inst->words[entryPointIndex]) |
| << "'s function parameter count is not zero."; |
| return false; |
| } |
| } |
| |
| auto returnType = module_.FindDef(entryPoint->type_id()); |
| if (!returnType || SpvOpTypeVoid != returnType->opcode()) { |
| DIAG(entryPoint) << "OpEntryPoint Entry Point <id> '" |
| << module_.getIdName(inst->words[entryPointIndex]) |
| << "'s function return type is not void."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpExecutionMode>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto entryPointIndex = 1; |
| auto entryPointID = inst->words[entryPointIndex]; |
| auto found = |
| std::find(entry_points_.cbegin(), entry_points_.cend(), entryPointID); |
| if (found == entry_points_.cend()) { |
| DIAG(module_.FindDef(entryPointID)) |
| << "OpExecutionMode Entry Point <id> '" |
| << module_.getIdName(inst->words[entryPointIndex]) |
| << "' is not the Entry Point " |
| "operand of an OpEntryPoint."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpTypeVector>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto componentIndex = 2; |
| auto componentType = module_.FindDef(inst->words[componentIndex]); |
| if (!componentType || !spvOpcodeIsScalarType(componentType->opcode())) { |
| DIAG(componentType) << "OpTypeVector Component Type <id> '" |
| << module_.getIdName(inst->words[componentIndex]) |
| << "' is not a scalar type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpTypeMatrix>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto columnTypeIndex = 2; |
| auto columnType = module_.FindDef(inst->words[columnTypeIndex]); |
| if (!columnType || SpvOpTypeVector != columnType->opcode()) { |
| DIAG(columnType) << "OpTypeMatrix Column Type <id> '" |
| << module_.getIdName(inst->words[columnTypeIndex]) |
| << "' is not a vector."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpTypeSampler>(const spv_instruction_t*, |
| const spv_opcode_desc) { |
| // OpTypeSampler takes no arguments in Rev31 and beyond. |
| return true; |
| } |
| |
| // True if the integer constant is > 0. constWords are words of the |
| // constant-defining instruction (either OpConstant or |
| // OpSpecConstant). typeWords are the words of the constant's-type-defining |
| // OpTypeInt. |
| bool aboveZero(const vector<uint32_t>& constWords, |
| const vector<uint32_t>& typeWords) { |
| const uint32_t width = typeWords[2]; |
| const bool is_signed = typeWords[3] > 0; |
| const uint32_t loWord = constWords[3]; |
| if (width > 32) { |
| // The spec currently doesn't allow integers wider than 64 bits. |
| const uint32_t hiWord = constWords[4]; // Must exist, per spec. |
| if (is_signed && (hiWord >> 31)) return false; |
| return (loWord | hiWord) > 0; |
| } else { |
| if (is_signed && (loWord >> 31)) return false; |
| return loWord > 0; |
| } |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpTypeArray>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto elementTypeIndex = 2; |
| auto elementType = module_.FindDef(inst->words[elementTypeIndex]); |
| if (!elementType || !spvOpcodeGeneratesType(elementType->opcode())) { |
| DIAG(elementType) << "OpTypeArray Element Type <id> '" |
| << module_.getIdName(inst->words[elementTypeIndex]) |
| << "' is not a type."; |
| return false; |
| } |
| auto lengthIndex = 3; |
| auto length = module_.FindDef(inst->words[lengthIndex]); |
| if (!length || !spvOpcodeIsConstant(length->opcode())) { |
| DIAG(length) << "OpTypeArray Length <id> '" |
| << module_.getIdName(inst->words[lengthIndex]) |
| << "' is not a scalar constant type."; |
| return false; |
| } |
| |
| // NOTE: Check the initialiser value of the constant |
| auto constInst = length->words(); |
| auto constResultTypeIndex = 1; |
| auto constResultType = module_.FindDef(constInst[constResultTypeIndex]); |
| if (!constResultType || SpvOpTypeInt != constResultType->opcode()) { |
| DIAG(length) << "OpTypeArray Length <id> '" |
| << module_.getIdName(inst->words[lengthIndex]) |
| << "' is not a constant integer type."; |
| return false; |
| } |
| |
| switch (length->opcode()) { |
| case SpvOpSpecConstant: |
| case SpvOpConstant: |
| if (aboveZero(length->words(), constResultType->words())) break; |
| // Else fall through! |
| case SpvOpConstantNull: { |
| DIAG(length) << "OpTypeArray Length <id> '" |
| << module_.getIdName(inst->words[lengthIndex]) |
| << "' default value must be at least 1."; |
| return false; |
| } |
| case SpvOpSpecConstantOp: |
| // Assume it's OK, rather than try to evaluate the operation. |
| break; |
| default: |
| assert(0 && "bug in spvOpcodeIsConstant() or result type isn't int"); |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpTypeRuntimeArray>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto elementTypeIndex = 2; |
| auto elementType = module_.FindDef(inst->words[elementTypeIndex]); |
| if (!elementType || !spvOpcodeGeneratesType(elementType->opcode())) { |
| DIAG(elementType) << "OpTypeRuntimeArray Element Type <id> '" |
| << module_.getIdName(inst->words[elementTypeIndex]) |
| << "' is not a type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpTypeStruct>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| ValidationState_t& vstate = const_cast<ValidationState_t&>(module_); |
| const uint32_t struct_id = inst->words[1]; |
| auto structType = module_.FindDef(struct_id); |
| for (size_t memberTypeIndex = 2; memberTypeIndex < inst->words.size(); |
| ++memberTypeIndex) { |
| auto memberTypeId = inst->words[memberTypeIndex]; |
| auto memberType = module_.FindDef(memberTypeId); |
| if (!memberType || !spvOpcodeGeneratesType(memberType->opcode())) { |
| DIAG(memberType) << "OpTypeStruct Member Type <id> '" |
| << module_.getIdName(inst->words[memberTypeIndex]) |
| << "' is not a type."; |
| return false; |
| } |
| if (SpvOpTypeStruct == memberType->opcode() && |
| module_.IsStructTypeWithBuiltInMember(memberTypeId)) { |
| DIAG(memberType) |
| << "Structure <id> " << module_.getIdName(memberTypeId) |
| << " contains members with BuiltIn decoration. Therefore this " |
| "structure may not be contained as a member of another structure " |
| "type. Structure <id> " |
| << module_.getIdName(struct_id) << " contains structure <id> " |
| << module_.getIdName(memberTypeId) << "."; |
| return false; |
| } |
| if (module_.IsForwardPointer(memberTypeId)) { |
| if (memberType->opcode() != SpvOpTypePointer) { |
| DIAG(memberType) << "Found a forward reference to a non-pointer " |
| "type in OpTypeStruct instruction."; |
| return false; |
| } |
| // If we're dealing with a forward pointer: |
| // Find out the type that the pointer is pointing to (must be struct) |
| // word 3 is the <id> of the type being pointed to. |
| auto typePointingTo = module_.FindDef(memberType->words()[3]); |
| if (typePointingTo && typePointingTo->opcode() != SpvOpTypeStruct) { |
| // Forward declared operands of a struct may only point to a struct. |
| DIAG(memberType) |
| << "A forward reference operand in an OpTypeStruct must be an " |
| "OpTypePointer that points to an OpTypeStruct. " |
| "Found OpTypePointer that points to Op" |
| << spvOpcodeString(static_cast<SpvOp>(typePointingTo->opcode())) |
| << "."; |
| return false; |
| } |
| } |
| } |
| std::unordered_set<uint32_t> built_in_members; |
| for (auto decoration : vstate.id_decorations(struct_id)) { |
| if (decoration.dec_type() == SpvDecorationBuiltIn && |
| decoration.struct_member_index() != Decoration::kInvalidMember) { |
| built_in_members.insert(decoration.struct_member_index()); |
| } |
| } |
| int num_struct_members = static_cast<int>(inst->words.size() - 2); |
| int num_builtin_members = static_cast<int>(built_in_members.size()); |
| if (num_builtin_members > 0 && num_builtin_members != num_struct_members) { |
| DIAG(structType) |
| << "When BuiltIn decoration is applied to a structure-type member, " |
| "all members of that structure type must also be decorated with " |
| "BuiltIn (No allowed mixing of built-in variables and " |
| "non-built-in variables within a single structure). Structure id " |
| << struct_id << " does not meet this requirement."; |
| return false; |
| } |
| if (num_builtin_members > 0) { |
| vstate.RegisterStructTypeWithBuiltInMember(struct_id); |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpTypePointer>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto typeIndex = 3; |
| auto type = module_.FindDef(inst->words[typeIndex]); |
| if (!type || !spvOpcodeGeneratesType(type->opcode())) { |
| DIAG(type) << "OpTypePointer Type <id> '" |
| << module_.getIdName(inst->words[typeIndex]) |
| << "' is not a type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpTypeFunction>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto returnTypeIndex = 2; |
| auto returnType = module_.FindDef(inst->words[returnTypeIndex]); |
| if (!returnType || !spvOpcodeGeneratesType(returnType->opcode())) { |
| DIAG(returnType) << "OpTypeFunction Return Type <id> '" |
| << module_.getIdName(inst->words[returnTypeIndex]) |
| << "' is not a type."; |
| return false; |
| } |
| size_t num_args = 0; |
| for (size_t paramTypeIndex = 3; paramTypeIndex < inst->words.size(); |
| ++paramTypeIndex, ++num_args) { |
| auto paramType = module_.FindDef(inst->words[paramTypeIndex]); |
| if (!paramType || !spvOpcodeGeneratesType(paramType->opcode())) { |
| DIAG(paramType) << "OpTypeFunction Parameter Type <id> '" |
| << module_.getIdName(inst->words[paramTypeIndex]) |
| << "' is not a type."; |
| return false; |
| } |
| } |
| const uint32_t num_function_args_limit = |
| module_.options()->universal_limits_.max_function_args; |
| if (num_args > num_function_args_limit) { |
| DIAG(returnType) << "OpTypeFunction may not take more than " |
| << num_function_args_limit |
| << " arguments. OpTypeFunction <id> '" |
| << module_.getIdName(inst->words[1]) << "' has " |
| << num_args << " arguments."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpTypePipe>(const spv_instruction_t*, |
| const spv_opcode_desc) { |
| // OpTypePipe has no ID arguments. |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpConstantTrue>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || SpvOpTypeBool != resultType->opcode()) { |
| DIAG(resultType) << "OpConstantTrue Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' is not a boolean type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpConstantFalse>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || SpvOpTypeBool != resultType->opcode()) { |
| DIAG(resultType) << "OpConstantFalse Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' is not a boolean type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpConstantComposite>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || !spvOpcodeIsComposite(resultType->opcode())) { |
| DIAG(resultType) << "OpConstantComposite Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' is not a composite type."; |
| return false; |
| } |
| |
| auto constituentCount = inst->words.size() - 3; |
| switch (resultType->opcode()) { |
| case SpvOpTypeVector: { |
| auto componentCount = resultType->words()[3]; |
| if (componentCount != constituentCount) { |
| // TODO: Output ID's on diagnostic |
| DIAG(module_.FindDef(inst->words.back())) |
| << "OpConstantComposite Constituent <id> count does not match " |
| "Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s vector component count."; |
| return false; |
| } |
| auto componentType = module_.FindDef(resultType->words()[2]); |
| assert(componentType); |
| for (size_t constituentIndex = 3; constituentIndex < inst->words.size(); |
| constituentIndex++) { |
| auto constituent = module_.FindDef(inst->words[constituentIndex]); |
| if (!constituent || |
| !spvOpcodeIsConstantOrUndef(constituent->opcode())) { |
| DIAG(constituent) << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' is not a constant or undef."; |
| return false; |
| } |
| auto constituentResultType = module_.FindDef(constituent->type_id()); |
| if (!constituentResultType || |
| componentType->opcode() != constituentResultType->opcode()) { |
| DIAG(constituent) << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "'s type does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s vector element type."; |
| return false; |
| } |
| } |
| } break; |
| case SpvOpTypeMatrix: { |
| auto columnCount = resultType->words()[3]; |
| if (columnCount != constituentCount) { |
| // TODO: Output ID's on diagnostic |
| DIAG(module_.FindDef(inst->words.back())) |
| << "OpConstantComposite Constituent <id> count does not match " |
| "Result Type <id> '" |
| << module_.getIdName(resultType->id()) << "'s matrix column count."; |
| return false; |
| } |
| |
| auto columnType = module_.FindDef(resultType->words()[2]); |
| assert(columnType); |
| auto componentCount = columnType->words()[3]; |
| auto componentType = module_.FindDef(columnType->words()[2]); |
| assert(componentType); |
| |
| for (size_t constituentIndex = 3; constituentIndex < inst->words.size(); |
| constituentIndex++) { |
| auto constituent = module_.FindDef(inst->words[constituentIndex]); |
| if (!constituent || !(SpvOpConstantComposite == constituent->opcode() || |
| SpvOpUndef == constituent->opcode())) { |
| // The message says "... or undef" because the spec does not say |
| // undef is a constant. |
| DIAG(constituent) << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' is not a constant composite or undef."; |
| return false; |
| } |
| auto vector = module_.FindDef(constituent->type_id()); |
| assert(vector); |
| if (columnType->opcode() != vector->opcode()) { |
| DIAG(constituent) << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' type does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s matrix column type."; |
| return false; |
| } |
| auto vectorComponentType = module_.FindDef(vector->words()[2]); |
| assert(vectorComponentType); |
| if (componentType->id() != vectorComponentType->id()) { |
| DIAG(constituent) |
| << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' component type does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s matrix column component type."; |
| return false; |
| } |
| if (componentCount != vector->words()[3]) { |
| DIAG(constituent) |
| << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' vector component count does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s vector component count."; |
| return false; |
| } |
| } |
| } break; |
| case SpvOpTypeArray: { |
| auto elementType = module_.FindDef(resultType->words()[2]); |
| assert(elementType); |
| auto length = module_.FindDef(resultType->words()[3]); |
| assert(length); |
| if (length->words()[3] != constituentCount) { |
| DIAG(module_.FindDef(inst->words.back())) |
| << "OpConstantComposite Constituent count does not match " |
| "Result Type <id> '" |
| << module_.getIdName(resultType->id()) << "'s array length."; |
| return false; |
| } |
| for (size_t constituentIndex = 3; constituentIndex < inst->words.size(); |
| constituentIndex++) { |
| auto constituent = module_.FindDef(inst->words[constituentIndex]); |
| if (!constituent || |
| !spvOpcodeIsConstantOrUndef(constituent->opcode())) { |
| DIAG(constituent) << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' is not a constant or undef."; |
| return false; |
| } |
| auto constituentType = module_.FindDef(constituent->type_id()); |
| assert(constituentType); |
| if (elementType->id() != constituentType->id()) { |
| DIAG(constituent) << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "'s type does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s array element type."; |
| return false; |
| } |
| } |
| } break; |
| case SpvOpTypeStruct: { |
| auto memberCount = resultType->words().size() - 2; |
| if (memberCount != constituentCount) { |
| DIAG(resultType) << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' count does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s struct member count."; |
| return false; |
| } |
| for (uint32_t constituentIndex = 3, memberIndex = 2; |
| constituentIndex < inst->words.size(); |
| constituentIndex++, memberIndex++) { |
| auto constituent = module_.FindDef(inst->words[constituentIndex]); |
| if (!constituent || |
| !spvOpcodeIsConstantOrUndef(constituent->opcode())) { |
| DIAG(constituent) << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' is not a constant or undef."; |
| return false; |
| } |
| auto constituentType = module_.FindDef(constituent->type_id()); |
| assert(constituentType); |
| |
| auto memberType = module_.FindDef(resultType->words()[memberIndex]); |
| assert(memberType); |
| if (memberType->id() != constituentType->id()) { |
| DIAG(constituent) |
| << "OpConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' type does not match the Result Type <id> '" |
| << module_.getIdName(resultType->id()) << "'s member type."; |
| return false; |
| } |
| } |
| } break; |
| default: { assert(0 && "Unreachable!"); } break; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpConstantSampler>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || SpvOpTypeSampler != resultType->opcode()) { |
| DIAG(resultType) << "OpConstantSampler Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' is not a sampler type."; |
| return false; |
| } |
| return true; |
| } |
| |
| // True if instruction defines a type that can have a null value, as defined by |
| // the SPIR-V spec. Tracks composite-type components through module to check |
| // nullability transitively. |
| bool IsTypeNullable(const vector<uint32_t>& instruction, |
| const ValidationState_t& module) { |
| 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 SpvOpTypePointer: |
| case SpvOpTypeEvent: |
| case SpvOpTypeDeviceEvent: |
| case SpvOpTypeReserveId: |
| case SpvOpTypeQueue: |
| return true; |
| case SpvOpTypeArray: |
| case SpvOpTypeMatrix: |
| case SpvOpTypeVector: { |
| auto base_type = module.FindDef(instruction[2]); |
| return base_type && IsTypeNullable(base_type->words(), module); |
| } |
| case SpvOpTypeStruct: { |
| for (size_t elementIndex = 2; elementIndex < instruction.size(); |
| ++elementIndex) { |
| auto element = module.FindDef(instruction[elementIndex]); |
| if (!element || !IsTypeNullable(element->words(), module)) return false; |
| } |
| return true; |
| } |
| default: |
| return false; |
| } |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpConstantNull>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || !IsTypeNullable(resultType->words(), module_)) { |
| DIAG(resultType) << "OpConstantNull Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' cannot have a null value."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpSpecConstantTrue>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || SpvOpTypeBool != resultType->opcode()) { |
| DIAG(resultType) << "OpSpecConstantTrue Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' is not a boolean type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpSpecConstantFalse>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || SpvOpTypeBool != resultType->opcode()) { |
| DIAG(resultType) << "OpSpecConstantFalse Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' is not a boolean type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpSampledImage>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 2; |
| auto resultID = inst->words[resultTypeIndex]; |
| auto sampledImageInstr = module_.FindDef(resultID); |
| // We need to validate 2 things: |
| // * All OpSampledImage instructions must be in the same block in which their |
| // Result <id> are consumed. |
| // * Result <id> from OpSampledImage instructions must not appear as operands |
| // to OpPhi instructions or OpSelect instructions, or any instructions other |
| // than the image lookup and query instructions specified to take an operand |
| // whose type is OpTypeSampledImage. |
| std::vector<uint32_t> consumers = module_.getSampledImageConsumers(resultID); |
| if (!consumers.empty()) { |
| for (auto consumer_id : consumers) { |
| auto consumer_instr = module_.FindDef(consumer_id); |
| auto consumer_opcode = consumer_instr->opcode(); |
| if (consumer_instr->block() != sampledImageInstr->block()) { |
| DIAG(sampledImageInstr) |
| << "All OpSampledImage instructions must be in the same block in " |
| "which their Result <id> are consumed. OpSampledImage Result " |
| "Type <id> '" |
| << module_.getIdName(resultID) |
| << "' has a consumer in a different basic " |
| "block. The consumer instruction <id> is '" |
| << module_.getIdName(consumer_id) << "'."; |
| return false; |
| } |
| // TODO: The following check is incomplete. We should also check that the |
| // Sampled Image is not used by instructions that should not take |
| // SampledImage as an argument. We could find the list of valid |
| // instructions by scanning for "Sampled Image" in the operand description |
| // field in the grammar file. |
| if (consumer_opcode == SpvOpPhi || consumer_opcode == SpvOpSelect) { |
| DIAG(sampledImageInstr) |
| << "Result <id> from OpSampledImage instruction must not appear as " |
| "operands of Op" |
| << spvOpcodeString(static_cast<SpvOp>(consumer_opcode)) << "." |
| << " Found result <id> '" << module_.getIdName(resultID) |
| << "' as an operand of <id> '" << module_.getIdName(consumer_id) |
| << "'."; |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpSpecConstantComposite>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| // The result type must be a composite type. |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || !spvOpcodeIsComposite(resultType->opcode())) { |
| DIAG(resultType) << "OpSpecConstantComposite Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' is not a composite type."; |
| return false; |
| } |
| // Validation checks differ based on the type of composite type. |
| auto constituentCount = inst->words.size() - 3; |
| switch (resultType->opcode()) { |
| // For Vectors, the following must be met: |
| // * Number of constituents in the result type and the vector must match. |
| // * All the components of the vector must have the same type (or specialize |
| // to the same type). OpConstant and OpSpecConstant are allowed. |
| // To check that condition, we check each supplied value argument's type |
| // against the element type of the result type. |
| case SpvOpTypeVector: { |
| auto componentCount = resultType->words()[3]; |
| if (componentCount != constituentCount) { |
| DIAG(module_.FindDef(inst->words.back())) |
| << "OpSpecConstantComposite Constituent <id> count does not match " |
| "Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s vector component count."; |
| return false; |
| } |
| auto componentType = module_.FindDef(resultType->words()[2]); |
| assert(componentType); |
| for (size_t constituentIndex = 3; constituentIndex < inst->words.size(); |
| constituentIndex++) { |
| auto constituent = module_.FindDef(inst->words[constituentIndex]); |
| if (!constituent || |
| !spvOpcodeIsConstantOrUndef(constituent->opcode())) { |
| DIAG(constituent) << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' is not a constant or undef."; |
| return false; |
| } |
| auto constituentResultType = module_.FindDef(constituent->type_id()); |
| if (!constituentResultType || |
| componentType->opcode() != constituentResultType->opcode()) { |
| DIAG(constituent) << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "'s type does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s vector element type."; |
| return false; |
| } |
| } |
| break; |
| } |
| case SpvOpTypeMatrix: { |
| auto columnCount = resultType->words()[3]; |
| if (columnCount != constituentCount) { |
| DIAG(module_.FindDef(inst->words.back())) |
| << "OpSpecConstantComposite Constituent <id> count does not match " |
| "Result Type <id> '" |
| << module_.getIdName(resultType->id()) << "'s matrix column count."; |
| return false; |
| } |
| |
| auto columnType = module_.FindDef(resultType->words()[2]); |
| assert(columnType); |
| auto componentCount = columnType->words()[3]; |
| auto componentType = module_.FindDef(columnType->words()[2]); |
| assert(componentType); |
| |
| for (size_t constituentIndex = 3; constituentIndex < inst->words.size(); |
| constituentIndex++) { |
| auto constituent = module_.FindDef(inst->words[constituentIndex]); |
| auto constituentOpCode = constituent->opcode(); |
| if (!constituent || !(SpvOpSpecConstantComposite == constituentOpCode || |
| SpvOpConstantComposite == constituentOpCode || |
| SpvOpUndef == constituentOpCode)) { |
| // The message says "... or undef" because the spec does not say |
| // undef is a constant. |
| DIAG(constituent) << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' is not a constant composite or undef."; |
| return false; |
| } |
| auto vector = module_.FindDef(constituent->type_id()); |
| assert(vector); |
| if (columnType->opcode() != vector->opcode()) { |
| DIAG(constituent) << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' type does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s matrix column type."; |
| return false; |
| } |
| auto vectorComponentType = module_.FindDef(vector->words()[2]); |
| assert(vectorComponentType); |
| if (componentType->id() != vectorComponentType->id()) { |
| DIAG(constituent) |
| << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' component type does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s matrix column component type."; |
| return false; |
| } |
| if (componentCount != vector->words()[3]) { |
| DIAG(constituent) |
| << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' vector component count does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s vector component count."; |
| return false; |
| } |
| } |
| break; |
| } |
| case SpvOpTypeArray: { |
| auto elementType = module_.FindDef(resultType->words()[2]); |
| assert(elementType); |
| auto length = module_.FindDef(resultType->words()[3]); |
| assert(length); |
| if (length->words()[3] != constituentCount) { |
| DIAG(module_.FindDef(inst->words.back())) |
| << "OpSpecConstantComposite Constituent count does not match " |
| "Result Type <id> '" |
| << module_.getIdName(resultType->id()) << "'s array length."; |
| return false; |
| } |
| for (size_t constituentIndex = 3; constituentIndex < inst->words.size(); |
| constituentIndex++) { |
| auto constituent = module_.FindDef(inst->words[constituentIndex]); |
| if (!constituent || |
| !spvOpcodeIsConstantOrUndef(constituent->opcode())) { |
| DIAG(constituent) << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' is not a constant or undef."; |
| return false; |
| } |
| auto constituentType = module_.FindDef(constituent->type_id()); |
| assert(constituentType); |
| if (elementType->id() != constituentType->id()) { |
| DIAG(constituent) << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "'s type does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s array element type."; |
| return false; |
| } |
| } |
| break; |
| } |
| case SpvOpTypeStruct: { |
| auto memberCount = resultType->words().size() - 2; |
| if (memberCount != constituentCount) { |
| DIAG(resultType) << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' count does not match Result Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s struct member count."; |
| return false; |
| } |
| for (uint32_t constituentIndex = 3, memberIndex = 2; |
| constituentIndex < inst->words.size(); |
| constituentIndex++, memberIndex++) { |
| auto constituent = module_.FindDef(inst->words[constituentIndex]); |
| if (!constituent || |
| !spvOpcodeIsConstantOrUndef(constituent->opcode())) { |
| DIAG(constituent) << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' is not a constant or undef."; |
| return false; |
| } |
| auto constituentType = module_.FindDef(constituent->type_id()); |
| assert(constituentType); |
| |
| auto memberType = module_.FindDef(resultType->words()[memberIndex]); |
| assert(memberType); |
| if (memberType->id() != constituentType->id()) { |
| DIAG(constituent) |
| << "OpSpecConstantComposite Constituent <id> '" |
| << module_.getIdName(inst->words[constituentIndex]) |
| << "' type does not match the Result Type <id> '" |
| << module_.getIdName(resultType->id()) << "'s member type."; |
| return false; |
| } |
| } |
| break; |
| } |
| default: { assert(0 && "Unreachable!"); } break; |
| } |
| return true; |
| } |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<SpvOpSpecConstantOp>(const spv_instruction_t *inst) {} |
| #endif |
| |
| template <> |
| bool idUsage::isValid<SpvOpVariable>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || SpvOpTypePointer != resultType->opcode()) { |
| DIAG(resultType) << "OpVariable Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' is not a pointer type."; |
| return false; |
| } |
| const auto initialiserIndex = 4; |
| if (initialiserIndex < inst->words.size()) { |
| const auto initialiser = module_.FindDef(inst->words[initialiserIndex]); |
| const auto storageClassIndex = 3; |
| const auto is_module_scope_var = |
| initialiser && (initialiser->opcode() == SpvOpVariable) && |
| (initialiser->word(storageClassIndex) != SpvStorageClassFunction); |
| const auto is_constant = |
| initialiser && spvOpcodeIsConstant(initialiser->opcode()); |
| if (!initialiser || !(is_constant || is_module_scope_var)) { |
| DIAG(initialiser) << "OpVariable Initializer <id> '" |
| << module_.getIdName(inst->words[initialiserIndex]) |
| << "' is not a constant or module-scope variable."; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpLoad>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType) { |
| DIAG(resultType) << "OpLoad Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' is not defind."; |
| return false; |
| } |
| const bool uses_variable_pointer = |
| module_.features().variable_pointers || |
| module_.features().variable_pointers_storage_buffer; |
| auto pointerIndex = 3; |
| auto pointer = module_.FindDef(inst->words[pointerIndex]); |
| if (!pointer || |
| (addressingModel == SpvAddressingModelLogical && |
| ((!uses_variable_pointer && |
| !spvOpcodeReturnsLogicalPointer(pointer->opcode())) || |
| (uses_variable_pointer && |
| !spvOpcodeReturnsLogicalVariablePointer(pointer->opcode()))))) { |
| DIAG(pointer) << "OpLoad Pointer <id> '" |
| << module_.getIdName(inst->words[pointerIndex]) |
| << "' is not a logical pointer."; |
| return false; |
| } |
| auto pointerType = module_.FindDef(pointer->type_id()); |
| if (!pointerType || pointerType->opcode() != SpvOpTypePointer) { |
| DIAG(pointer) << "OpLoad type for pointer <id> '" |
| << module_.getIdName(inst->words[pointerIndex]) |
| << "' is not a pointer type."; |
| return false; |
| } |
| auto pointeeType = module_.FindDef(pointerType->words()[3]); |
| if (!pointeeType || resultType->id() != pointeeType->id()) { |
| DIAG(resultType) << "OpLoad Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' does not match Pointer <id> '" |
| << module_.getIdName(pointer->id()) << "'s type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpStore>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| const bool uses_variable_pointer = |
| module_.features().variable_pointers || |
| module_.features().variable_pointers_storage_buffer; |
| const auto pointerIndex = 1; |
| auto pointer = module_.FindDef(inst->words[pointerIndex]); |
| if (!pointer || |
| (addressingModel == SpvAddressingModelLogical && |
| ((!uses_variable_pointer && |
| !spvOpcodeReturnsLogicalPointer(pointer->opcode())) || |
| (uses_variable_pointer && |
| !spvOpcodeReturnsLogicalVariablePointer(pointer->opcode()))))) { |
| DIAG(pointer) << "OpStore Pointer <id> '" |
| << module_.getIdName(inst->words[pointerIndex]) |
| << "' is not a logical pointer."; |
| return false; |
| } |
| auto pointerType = module_.FindDef(pointer->type_id()); |
| if (!pointer || pointerType->opcode() != SpvOpTypePointer) { |
| DIAG(pointer) << "OpStore type for pointer <id> '" |
| << module_.getIdName(inst->words[pointerIndex]) |
| << "' is not a pointer type."; |
| return false; |
| } |
| auto type = module_.FindDef(pointerType->words()[3]); |
| assert(type); |
| if (SpvOpTypeVoid == type->opcode()) { |
| DIAG(pointer) << "OpStore Pointer <id> '" |
| << module_.getIdName(inst->words[pointerIndex]) |
| << "'s type is void."; |
| return false; |
| } |
| |
| // validate storage class |
| { |
| uint32_t dataType; |
| uint32_t storageClass; |
| if (!module_.GetPointerTypeInfo(pointerType->id(), &dataType, |
| &storageClass)) { |
| DIAG(pointer) << "OpStore Pointer <id> '" |
| << module_.getIdName(inst->words[pointerIndex]) |
| << "' is not pointer type"; |
| return false; |
| } |
| |
| if (storageClass == SpvStorageClassUniformConstant || |
| storageClass == SpvStorageClassInput || |
| storageClass == SpvStorageClassPushConstant) { |
| DIAG(pointer) << "OpStore Pointer <id> '" |
| << module_.getIdName(inst->words[pointerIndex]) |
| << "' storage class is read-only"; |
| return false; |
| } |
| } |
| |
| auto objectIndex = 2; |
| auto object = module_.FindDef(inst->words[objectIndex]); |
| if (!object || !object->type_id()) { |
| DIAG(object) << "OpStore Object <id> '" |
| << module_.getIdName(inst->words[objectIndex]) |
| << "' is not an object."; |
| return false; |
| } |
| auto objectType = module_.FindDef(object->type_id()); |
| assert(objectType); |
| if (SpvOpTypeVoid == objectType->opcode()) { |
| DIAG(object) << "OpStore Object <id> '" |
| << module_.getIdName(inst->words[objectIndex]) |
| << "'s type is void."; |
| return false; |
| } |
| |
| if (type->id() != objectType->id()) { |
| if (!module_.options()->relax_struct_store || |
| type->opcode() != SpvOpTypeStruct || |
| objectType->opcode() != SpvOpTypeStruct) { |
| DIAG(pointer) << "OpStore Pointer <id> '" |
| << module_.getIdName(inst->words[pointerIndex]) |
| << "'s type does not match Object <id> '" |
| << module_.getIdName(object->id()) << "'s type."; |
| return false; |
| } |
| |
| // TODO: Check for layout compatible matricies and arrays as well. |
| if (!AreLayoutCompatibleStructs(type, objectType)) { |
| DIAG(pointer) << "OpStore Pointer <id> '" |
| << module_.getIdName(inst->words[pointerIndex]) |
| << "'s layout does not match Object <id> '" |
| << module_.getIdName(object->id()) << "'s layout."; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpCopyMemory>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto targetIndex = 1; |
| auto target = module_.FindDef(inst->words[targetIndex]); |
| if (!target) return false; |
| auto sourceIndex = 2; |
| auto source = module_.FindDef(inst->words[sourceIndex]); |
| if (!source) return false; |
| auto targetPointerType = module_.FindDef(target->type_id()); |
| assert(targetPointerType); |
| auto targetType = module_.FindDef(targetPointerType->words()[3]); |
| assert(targetType); |
| auto sourcePointerType = module_.FindDef(source->type_id()); |
| assert(sourcePointerType); |
| auto sourceType = module_.FindDef(sourcePointerType->words()[3]); |
| assert(sourceType); |
| if (targetType->id() != sourceType->id()) { |
| DIAG(source) << "OpCopyMemory Target <id> '" |
| << module_.getIdName(inst->words[sourceIndex]) |
| << "'s type does not match Source <id> '" |
| << module_.getIdName(sourceType->id()) << "'s type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpCopyMemorySized>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto targetIndex = 1; |
| auto target = module_.FindDef(inst->words[targetIndex]); |
| if (!target) return false; |
| auto sourceIndex = 2; |
| auto source = module_.FindDef(inst->words[sourceIndex]); |
| if (!source) return false; |
| auto sizeIndex = 3; |
| auto size = module_.FindDef(inst->words[sizeIndex]); |
| if (!size) return false; |
| auto targetPointerType = module_.FindDef(target->type_id()); |
| if (!targetPointerType || SpvOpTypePointer != targetPointerType->opcode()) { |
| DIAG(target) << "OpCopyMemorySized Target <id> '" |
| << module_.getIdName(inst->words[targetIndex]) |
| << "' is not a pointer."; |
| return false; |
| } |
| auto sourcePointerType = module_.FindDef(source->type_id()); |
| if (!sourcePointerType || SpvOpTypePointer != sourcePointerType->opcode()) { |
| DIAG(source) << "OpCopyMemorySized Source <id> '" |
| << module_.getIdName(inst->words[sourceIndex]) |
| << "' is not a pointer."; |
| return false; |
| } |
| switch (size->opcode()) { |
| // TODO: The following opcode's are assumed to be valid, refer to the |
| // following bug https://cvs.khronos.org/bugzilla/show_bug.cgi?id=13871 for |
| // clarification |
| case SpvOpConstant: |
| case SpvOpSpecConstant: { |
| auto sizeType = module_.FindDef(size->type_id()); |
| assert(sizeType); |
| if (SpvOpTypeInt != sizeType->opcode()) { |
| DIAG(size) << "OpCopyMemorySized Size <id> '" |
| << module_.getIdName(inst->words[sizeIndex]) |
| << "'s type is not an integer type."; |
| return false; |
| } |
| } break; |
| case SpvOpVariable: { |
| auto pointerType = module_.FindDef(size->type_id()); |
| assert(pointerType); |
| auto sizeType = module_.FindDef(pointerType->type_id()); |
| if (!sizeType || SpvOpTypeInt != sizeType->opcode()) { |
| DIAG(size) << "OpCopyMemorySized Size <id> '" |
| << module_.getIdName(inst->words[sizeIndex]) |
| << "'s variable type is not an integer type."; |
| return false; |
| } |
| } break; |
| default: |
| DIAG(size) << "OpCopyMemorySized Size <id> '" |
| << module_.getIdName(inst->words[sizeIndex]) |
| << "' is not a constant or variable."; |
| return false; |
| } |
| // TODO: Check that consant is a least size 1, see the same bug as above for |
| // clarification? |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpAccessChain>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| std::string instr_name = |
| "Op" + std::string(spvOpcodeString(static_cast<SpvOp>(inst->opcode))); |
| |
| // The result type must be OpTypePointer. Result Type is at word 1. |
| auto resultTypeIndex = 1; |
| auto resultTypeInstr = module_.FindDef(inst->words[resultTypeIndex]); |
| if (SpvOpTypePointer != resultTypeInstr->opcode()) { |
| DIAG(resultTypeInstr) << "The Result Type of " << instr_name << " <id> '" |
| << module_.getIdName(inst->words[2]) |
| << "' must be OpTypePointer. Found Op" |
| << spvOpcodeString( |
| static_cast<SpvOp>(resultTypeInstr->opcode())) |
| << "."; |
| return false; |
| } |
| |
| // Result type is a pointer. Find out what it's pointing to. |
| // This will be used to make sure the indexing results in the same type. |
| // OpTypePointer word 3 is the type being pointed to. |
| auto resultTypePointedTo = module_.FindDef(resultTypeInstr->word(3)); |
| |
| // Base must be a pointer, pointing to the base of a composite object. |
| auto baseIdIndex = 3; |
| auto baseInstr = module_.FindDef(inst->words[baseIdIndex]); |
| auto baseTypeInstr = module_.FindDef(baseInstr->type_id()); |
| if (!baseTypeInstr || SpvOpTypePointer != baseTypeInstr->opcode()) { |
| DIAG(baseInstr) << "The Base <id> '" |
| << module_.getIdName(inst->words[baseIdIndex]) << "' in " |
| << instr_name << " instruction must be a pointer."; |
| return false; |
| } |
| |
| // The result pointer storage class and base pointer storage class must match. |
| // Word 2 of OpTypePointer is the Storage Class. |
| auto resultTypeStorageClass = resultTypeInstr->word(2); |
| auto baseTypeStorageClass = baseTypeInstr->word(2); |
| if (resultTypeStorageClass != baseTypeStorageClass) { |
| DIAG(resultTypeInstr) << "The result pointer storage class and base " |
| "pointer storage class in " |
| << instr_name << " do not match."; |
| return false; |
| } |
| |
| // The type pointed to by OpTypePointer (word 3) must be a composite type. |
| auto typePointedTo = module_.FindDef(baseTypeInstr->word(3)); |
| |
| // Check Universal Limit (SPIR-V Spec. Section 2.17). |
| // The number of indexes passed to OpAccessChain may not exceed 255 |
| // The instruction includes 4 words + N words (for N indexes) |
| const size_t num_indexes = inst->words.size() - 4; |
| const size_t num_indexes_limit = |
| module_.options()->universal_limits_.max_access_chain_indexes; |
| if (num_indexes > num_indexes_limit) { |
| DIAG(resultTypeInstr) << "The number of indexes in " << instr_name |
| << " may not exceed " << num_indexes_limit |
| << ". Found " << num_indexes << " indexes."; |
| return false; |
| } |
| // Indexes walk the type hierarchy to the desired depth, potentially down to |
| // scalar granularity. The first index in Indexes will select the top-level |
| // member/element/component/element of the base composite. All composite |
| // constituents use zero-based numbering, as described by their OpType... |
| // instruction. The second index will apply similarly to that result, and so |
| // on. Once any non-composite type is reached, there must be no remaining |
| // (unused) indexes. |
| for (size_t i = 4; i < inst->words.size(); ++i) { |
| const uint32_t cur_word = inst->words[i]; |
| // Earlier ID checks ensure that cur_word definition exists. |
| auto cur_word_instr = module_.FindDef(cur_word); |
| // The index must be a scalar integer type (See OpAccessChain in the Spec.) |
| auto indexTypeInstr = module_.FindDef(cur_word_instr->type_id()); |
| if (!indexTypeInstr || SpvOpTypeInt != indexTypeInstr->opcode()) { |
| DIAG(module_.FindDef(cur_word)) |
| << "Indexes passed to " << instr_name << " must be of type integer."; |
| return false; |
| } |
| switch (typePointedTo->opcode()) { |
| case SpvOpTypeMatrix: |
| case SpvOpTypeVector: |
| case SpvOpTypeArray: |
| case SpvOpTypeRuntimeArray: { |
| // In OpTypeMatrix, OpTypeVector, OpTypeArray, and OpTypeRuntimeArray, |
| // word 2 is the Element Type. |
| typePointedTo = module_.FindDef(typePointedTo->word(2)); |
| break; |
| } |
| case SpvOpTypeStruct: { |
| // In case of structures, there is an additional constraint on the |
| // index: the index must be an OpConstant. |
| if (SpvOpConstant != cur_word_instr->opcode()) { |
| DIAG(cur_word_instr) << "The <id> passed to " << instr_name |
| << " to index into a " |
| "structure must be an OpConstant."; |
| return false; |
| } |
| // Get the index value from the OpConstant (word 3 of OpConstant). |
| // OpConstant could be a signed integer. But it's okay to treat it as |
| // unsigned because a negative constant int would never be seen as |
| // correct as a struct offset, since structs can't have more than 2 |
| // billion members. |
| const uint32_t cur_index = cur_word_instr->word(3); |
| // The index points to the struct member we want, therefore, the index |
| // should be less than the number of struct members. |
| const uint32_t num_struct_members = |
| static_cast<uint32_t>(typePointedTo->words().size() - 2); |
| if (cur_index >= num_struct_members) { |
| DIAG(cur_word_instr) << "Index is out of bounds: " << instr_name |
| << " can not find index " << cur_index |
| << " into the structure <id> '" |
| << module_.getIdName(typePointedTo->id()) |
| << "'. This structure has " << num_struct_members |
| << " members. Largest valid index is " |
| << num_struct_members - 1 << "."; |
| return false; |
| } |
| // Struct members IDs start at word 2 of OpTypeStruct. |
| auto structMemberId = typePointedTo->word(cur_index + 2); |
| typePointedTo = module_.FindDef(structMemberId); |
| break; |
| } |
| default: { |
| // Give an error. reached non-composite type while indexes still remain. |
| DIAG(cur_word_instr) << instr_name |
| << " reached non-composite type while indexes " |
| "still remain to be traversed."; |
| return false; |
| } |
| } |
| } |
| // At this point, we have fully walked down from the base using the indeces. |
| // The type being pointed to should be the same as the result type. |
| if (typePointedTo->id() != resultTypePointedTo->id()) { |
| DIAG(resultTypeInstr) |
| << instr_name << " result type (Op" |
| << spvOpcodeString(static_cast<SpvOp>(resultTypePointedTo->opcode())) |
| << ") does not match the type that results from indexing into the base " |
| "<id> (Op" |
| << spvOpcodeString(static_cast<SpvOp>(typePointedTo->opcode())) << ")."; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpInBoundsAccessChain>( |
| const spv_instruction_t* inst, const spv_opcode_desc opcodeEntry) { |
| return isValid<SpvOpAccessChain>(inst, opcodeEntry); |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpPtrAccessChain>(const spv_instruction_t* inst, |
| const spv_opcode_desc opcodeEntry) { |
| // OpPtrAccessChain's validation rules are similar to OpAccessChain, with one |
| // difference: word 4 must be id of an integer (Element <id>). |
| // The grammar guarantees that there are at least 5 words in the instruction |
| // (i.e. if there are fewer than 5 words, the SPIR-V code will not compile.) |
| int elem_index = 4; |
| // We can remove the Element <id> from the instruction words, and simply call |
| // the validation code of OpAccessChain. |
| spv_instruction_t new_inst = *inst; |
| new_inst.words.erase(new_inst.words.begin() + elem_index); |
| return isValid<SpvOpAccessChain>(&new_inst, opcodeEntry); |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpInBoundsPtrAccessChain>( |
| const spv_instruction_t* inst, const spv_opcode_desc opcodeEntry) { |
| // Has the same validation rules as OpPtrAccessChain |
| return isValid<SpvOpPtrAccessChain>(inst, opcodeEntry); |
| } |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<SpvOpArrayLength>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<SpvOpImagePointer>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<SpvOpGenericPtrMemSemantics>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| template <> |
| bool idUsage::isValid<SpvOpFunction>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| const auto* thisInst = module_.FindDef(inst->words[2u]); |
| if (!thisInst) return false; |
| |
| for (uint32_t entryId : module_.FunctionEntryPoints(thisInst->id())) { |
| const Function* thisFunc = module_.function(thisInst->id()); |
| assert(thisFunc); |
| const auto* models = module_.GetExecutionModels(entryId); |
| if (models) { |
| assert(models->size()); |
| for (auto model : *models) { |
| std::string reason; |
| if (!thisFunc->IsCompatibleWithExecutionModel(model, &reason)) { |
| DIAG(module_.FindDef(inst->words[2])) |
| << "OpEntryPoint Entry Point <id> '" << module_.getIdName(entryId) |
| << "'s callgraph contains function <id> " |
| << module_.getIdName(thisInst->id()) |
| << ", which cannot be used with the current execution model:\n" |
| << reason; |
| return false; |
| } |
| } |
| } |
| } |
| |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType) return false; |
| auto functionTypeIndex = 4; |
| auto functionType = module_.FindDef(inst->words[functionTypeIndex]); |
| if (!functionType || SpvOpTypeFunction != functionType->opcode()) { |
| DIAG(functionType) << "OpFunction Function Type <id> '" |
| << module_.getIdName(inst->words[functionTypeIndex]) |
| << "' is not a function type."; |
| return false; |
| } |
| auto returnType = module_.FindDef(functionType->words()[2]); |
| assert(returnType); |
| if (returnType->id() != resultType->id()) { |
| DIAG(resultType) << "OpFunction Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' does not match the Function Type <id> '" |
| << module_.getIdName(resultType->id()) |
| << "'s return type."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpFunctionParameter>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType) return false; |
| // NOTE: Find OpFunction & ensure OpFunctionParameter is not out of place. |
| size_t paramIndex = 0; |
| assert(firstInst < inst && "Invalid instruction pointer"); |
| while (firstInst != --inst) { |
| if (SpvOpFunction == inst->opcode) { |
| break; |
| } else if (SpvOpFunctionParameter == inst->opcode) { |
| paramIndex++; |
| } |
| } |
| auto functionType = module_.FindDef(inst->words[4]); |
| assert(functionType); |
| if (paramIndex >= functionType->words().size() - 3) { |
| DIAG(module_.FindDef(inst->words[0])) |
| << "Too many OpFunctionParameters for " << inst->words[2] |
| << ": expected " << functionType->words().size() - 3 |
| << " based on the function's type"; |
| return false; |
| } |
| auto paramType = module_.FindDef(functionType->words()[paramIndex + 3]); |
| assert(paramType); |
| if (resultType->id() != paramType->id()) { |
| DIAG(resultType) << "OpFunctionParameter Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "' does not match the OpTypeFunction parameter " |
| "type of the same index."; |
| return false; |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpFunctionCall>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType) return false; |
| auto functionIndex = 3; |
| auto function = module_.FindDef(inst->words[functionIndex]); |
| if (!function || SpvOpFunction != function->opcode()) { |
| DIAG(function) << "OpFunctionCall Function <id> '" |
| << module_.getIdName(inst->words[functionIndex]) |
| << "' is not a function."; |
| return false; |
| } |
| auto returnType = module_.FindDef(function->type_id()); |
| assert(returnType); |
| if (returnType->id() != resultType->id()) { |
| DIAG(resultType) << "OpFunctionCall Result Type <id> '" |
| << module_.getIdName(inst->words[resultTypeIndex]) |
| << "'s type does not match Function <id> '" |
| << module_.getIdName(returnType->id()) |
| << "'s return type."; |
| return false; |
| } |
| auto functionType = module_.FindDef(function->words()[4]); |
| assert(functionType); |
| auto functionCallArgCount = inst->words.size() - 4; |
| auto functionParamCount = functionType->words().size() - 3; |
| if (functionParamCount != functionCallArgCount) { |
| DIAG(module_.FindDef(inst->words.back())) |
| << "OpFunctionCall Function <id>'s parameter count does not match " |
| "the argument count."; |
| return false; |
| } |
| for (size_t argumentIndex = 4, paramIndex = 3; |
| argumentIndex < inst->words.size(); argumentIndex++, paramIndex++) { |
| auto argument = module_.FindDef(inst->words[argumentIndex]); |
| if (!argument) return false; |
| auto argumentType = module_.FindDef(argument->type_id()); |
| assert(argumentType); |
| auto parameterType = module_.FindDef(functionType->words()[paramIndex]); |
| assert(parameterType); |
| if (argumentType->id() != parameterType->id()) { |
| DIAG(argument) << "OpFunctionCall Argument <id> '" |
| << module_.getIdName(inst->words[argumentIndex]) |
| << "'s type does not match Function <id> '" |
| << module_.getIdName(parameterType->id()) |
| << "'s parameter type."; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpVectorShuffle>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto instr_name = [&inst]() { |
| std::string name = |
| "Op" + std::string(spvOpcodeString(static_cast<SpvOp>(inst->opcode))); |
| return name; |
| }; |
| |
| // Result Type must be an OpTypeVector. |
| auto resultTypeIndex = 1; |
| auto resultType = module_.FindDef(inst->words[resultTypeIndex]); |
| if (!resultType || resultType->opcode() != SpvOpTypeVector) { |
| DIAG(resultType) << "The Result Type of " << instr_name() |
| << " must be OpTypeVector. Found Op" |
| << spvOpcodeString( |
| static_cast<SpvOp>(resultType->opcode())) |
| << "."; |
| return false; |
| } |
| |
| // The number of components in Result Type must be the same as the number of |
| // Component operands. |
| auto componentCount = inst->words.size() - 5; |
| auto vectorComponentCountIndex = 3; |
| auto resultVectorDimension = resultType->words()[vectorComponentCountIndex]; |
| if (componentCount != resultVectorDimension) { |
| DIAG(module_.FindDef(inst->words.back())) |
| << instr_name() |
| << " component literals count does not match " |
| "Result Type <id> '" |
| << module_.getIdName(resultType->id()) << "'s vector component count."; |
| return false; |
| } |
| |
| // Vector 1 and Vector 2 must both have vector types, with the same Component |
| // Type as Result Type. |
| auto vector1Index = 3; |
| auto vector1Object = module_.FindDef(inst->words[vector1Index]); |
| auto vector1Type = module_.FindDef(vector1Object->type_id()); |
| auto vector2Index = 4; |
| auto vector2Object = module_.FindDef(inst->words[vector2Index]); |
| auto vector2Type = module_.FindDef(vector2Object->type_id()); |
| if (!vector1Type || vector1Type->opcode() != SpvOpTypeVector) { |
| DIAG(vector1Object) << "The type of Vector 1 must be OpTypeVector."; |
| return false; |
| } |
| if (!vector2Type || vector2Type->opcode() != SpvOpTypeVector) { |
| DIAG(vector2Object) << "The type of Vector 2 must be OpTypeVector."; |
| return false; |
| } |
| auto vectorComponentTypeIndex = 2; |
| auto resultComponentType = resultType->words()[vectorComponentTypeIndex]; |
| auto vector1ComponentType = vector1Type->words()[vectorComponentTypeIndex]; |
| if (vector1ComponentType != resultComponentType) { |
| DIAG(vector1Object) << "The Component Type of Vector 1 must be the same " |
| "as ResultType."; |
| return false; |
| } |
| auto vector2ComponentType = vector2Type->words()[vectorComponentTypeIndex]; |
| if (vector2ComponentType != resultComponentType) { |
| DIAG(vector2Object) << "The Component Type of Vector 2 must be the same " |
| "as ResultType."; |
| return false; |
| } |
| |
| // All Component literals must either be FFFFFFFF or in [0, N - 1]. |
| auto vector1ComponentCount = vector1Type->words()[vectorComponentCountIndex]; |
| auto vector2ComponentCount = vector2Type->words()[vectorComponentCountIndex]; |
| auto N = vector1ComponentCount + vector2ComponentCount; |
| auto firstLiteralIndex = 5; |
| for (size_t i = firstLiteralIndex; i < inst->words.size(); ++i) { |
| auto literal = inst->words[i]; |
| if (literal != 0xFFFFFFFF && literal >= N) { |
| DIAG(module_.FindDef(inst->words[i])) |
| << "Component literal value " << literal << " is greater than " |
| << N - 1 << "."; |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| template <> |
| bool idUsage::isValid<SpvOpPhi>(const spv_instruction_t* inst, |
| const spv_opcode_desc /*opcodeEntry*/) { |
| auto thisInst = module_.FindDef(inst->words[2]); |
| SpvOp typeOp = module_.GetIdOpcode(thisInst->type_id()); |
| if (!spvOpcodeGeneratesType(typeOp)) { |
| DIAG(thisInst) << "OpPhi's type <id> " |
| << module_.getIdName(thisInst->type_id()) |
| << " is not a type instruction."; |
| return false; |
| } |
| |
| auto block = thisInst->block(); |
| size_t numInOps = inst->words.size() - 3; |
| if (numInOps % 2 != 0) { |
| DIAG(thisInst) |
| << "OpPhi does not have an equal number of incoming values and " |
| "basic blocks."; |
| return false; |
| } |
| |
| // Create a uniqued vector of predecessor ids for comparison against |
| // incoming values. OpBranchConditional %cond %label %label produces two |
| // predecessors in the CFG. |
| std::vector<uint32_t> predIds; |
| std::transform(block->predecessors()->begin(), block->predecessors()->end(), |
| std::back_inserter(predIds), |
| [](const BasicBlock* b) { return b->id(); }); |
| std::sort(predIds.begin(), predIds.end()); |
| predIds.erase(std::unique(predIds.begin(), predIds.end()), predIds.end()); |
| |
| size_t numEdges = numInOps / 2; |
| if (numEdges != predIds.size()) { |
| DIAG(thisInst) << "OpPhi's number of incoming blocks (" << numEdges |
| << ") does not match block's predecessor count (" |
| << block->predecessors()->size() << ")."; |
| return false; |
| } |
| |
| for (size_t i = 3; i < inst->words.size(); ++i) { |
| auto incId = inst->words[i]; |
| if (i % 2 == 1) { |
| // Incoming value type must match the phi result type. |
| auto incTypeId = module_.GetTypeId(incId); |
| if (thisInst->type_id() != incTypeId) { |
| DIAG(thisInst) << "OpPhi's result type <id> " |
| << module_.getIdName(thisInst->type_id()) |
| << " does not match incoming value <id> " |
| << module_.getIdName(incId) << " type <id> " |
| << module_.getIdName(incTypeId) << "."; |
| return false; |
| } |
| } else { |
| if (module_.GetIdOpcode(incId) != SpvOpLabel) { |
| DIAG(thisInst) << "OpPhi's incoming basic block <id> " |
| << module_.getIdName(incId) << " is not an OpLabel."; |
| return false; |
| } |
| |
| // Incoming basic block must be an immediate predecessor of the phi's |
| // block. |
| if (!std::binary_search(predIds.begin(), predIds.end(), incId)) { |
| DIAG(thisInst) << "OpPhi's incoming basic block <id> " |
| << module_.getIdName(incId) |
| << " is not a predecessor of <id> " |
| << module_.getIdName(block->id()) << "."; |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpLoopMerge>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpSelectionMerge>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| template <> |
| bool idUsage::isValid<SpvOpBranchConditional>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| const size_t numOperands = inst->words.size() - 1; |
| const size_t condOperandIndex = 1; |
| const size_t targetTrueIndex = 2; |
| const size_t targetFalseIndex = 3; |
| |
| // num_operands is either 3 or 5 --- if 5, the last two need to be literal |
| // integers |
| if (numOperands != 3 && numOperands != 5) { |
| Instruction* fake_inst = nullptr; |
| DIAG(fake_inst) << "OpBranchConditional requires either 3 or 5 parameters"; |
| return false; |
| } |
| |
| bool ret = true; |
| |
| // grab the condition operand and check that it is a bool |
| const auto condOp = module_.FindDef(inst->words[condOperandIndex]); |
| if (!condOp || !module_.IsBoolScalarType(condOp->type_id())) { |
| DIAG(condOp) |
| << "Condition operand for OpBranchConditional must be of boolean type"; |
| ret = false; |
| } |
| |
| // target operands must be OpLabel |
| // note that we don't need to check that the target labels are in the same |
| // function, |
| // PerformCfgChecks already checks for that |
| const auto targetOpTrue = module_.FindDef(inst->words[targetTrueIndex]); |
| if (!targetOpTrue || SpvOpLabel != targetOpTrue->opcode()) { |
| DIAG(targetOpTrue) |
| << "The 'True Label' operand for OpBranchConditional must be the " |
| "ID of an OpLabel instruction"; |
| ret = false; |
| } |
| |
| const auto targetOpFalse = module_.FindDef(inst->words[targetFalseIndex]); |
| if (!targetOpFalse || SpvOpLabel != targetOpFalse->opcode()) { |
| DIAG(targetOpFalse) |
| << "The 'False Label' operand for OpBranchConditional must be the " |
| "ID of an OpLabel instruction"; |
| ret = false; |
| } |
| |
| return ret; |
| } |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpSwitch>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| template <> |
| bool idUsage::isValid<SpvOpReturnValue>(const spv_instruction_t* inst, |
| const spv_opcode_desc) { |
| auto valueIndex = 1; |
| auto value = module_.FindDef(inst->words[valueIndex]); |
| if (!value || !value->type_id()) { |
| DIAG(value) << "OpReturnValue Value <id> '" |
| << module_.getIdName(inst->words[valueIndex]) |
| << "' does not represent a value."; |
| return false; |
| } |
| auto valueType = module_.FindDef(value->type_id()); |
| if (!valueType || SpvOpTypeVoid == valueType->opcode()) { |
| DIAG(value) << "OpReturnValue value's type <id> '" |
| << module_.getIdName(value->type_id()) |
| << "' is missing or void."; |
| return false; |
| } |
| |
| const bool uses_variable_pointer = |
| module_.features().variable_pointers || |
| module_.features().variable_pointers_storage_buffer; |
| |
| if (addressingModel == SpvAddressingModelLogical && |
| SpvOpTypePointer == valueType->opcode() && !uses_variable_pointer && |
| !module_.options()->relax_logical_pointer) { |
| DIAG(value) |
| << "OpReturnValue value's type <id> '" |
| << module_.getIdName(value->type_id()) |
| << "' is a pointer, which is invalid in the Logical addressing model."; |
| return false; |
| } |
| |
| // NOTE: Find OpFunction |
| const spv_instruction_t* function = inst - 1; |
| while (firstInst != function) { |
| if (SpvOpFunction == function->opcode) break; |
| function--; |
| } |
| if (SpvOpFunction != function->opcode) { |
| DIAG(value) << "OpReturnValue is not in a basic block."; |
| return false; |
| } |
| auto returnType = module_.FindDef(function->words[1]); |
| if (!returnType || returnType->id() != valueType->id()) { |
| DIAG(value) << "OpReturnValue Value <id> '" |
| << module_.getIdName(inst->words[valueIndex]) |
| << "'s type does not match OpFunction's return type."; |
| return false; |
| } |
| return true; |
| } |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpLifetimeStart>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) { |
| } |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpLifetimeStop>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicInit>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicLoad>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicStore>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicExchange>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicCompareExchange>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicCompareExchangeWeak>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicIIncrement>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicIDecrement>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicIAdd>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicISub>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicUMin>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicUMax>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicAnd>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicOr>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicXor>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicIMin>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpAtomicIMax>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpEmitStreamVertex>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpEndStreamPrimitive>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupAsyncCopy>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupWaitEvents>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupAll>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupAny>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupBroadcast>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupIAdd>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupFAdd>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupFMin>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupUMin>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupSMin>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupFMax>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupUMax>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupSMax>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpEnqueueMarker>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) { |
| } |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpEnqueueKernel>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) { |
| } |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGetKernelNDrangeSubGroupCount>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGetKernelNDrangeMaxSubGroupSize>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGetKernelWorkGroupSize>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGetKernelPreferredWorkGroupSizeMultiple>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpRetainEvent>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpReleaseEvent>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpCreateUserEvent>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpIsValidEvent>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpSetUserEventStatus>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpCaptureEventProfilingInfo>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGetDefaultQueue>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpBuildNDRange>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpReadPipe>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpWritePipe>(const spv_instruction_t *inst, |
| const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpReservedReadPipe>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpReservedWritePipe>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpReserveReadPipePackets>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpReserveWritePipePackets>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpCommitReadPipe>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpCommitWritePipe>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpIsValidReserveId>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGetNumPipePackets>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGetMaxPipePackets>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupReserveReadPipePackets>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupReserveWritePipePackets>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupCommitReadPipe>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #if 0 |
| template <> |
| bool idUsage::isValid<OpGroupCommitWritePipe>( |
| const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {} |
| #endif |
| |
| #undef DIAG |
| |
| bool idUsage::isValid(const spv_instruction_t* inst) { |
| spv_opcode_desc opcodeEntry = nullptr; |
| if (spvOpcodeTableValueLookup(targetEnv, opcodeTable, inst->opcode, |
| &opcodeEntry)) |
| return false; |
| #define CASE(OpCode) \ |
| case Spv##OpCode: \ |
| return isValid<Spv##OpCode>(inst, opcodeEntry); |
| #define TODO(OpCode) \ |
| case Spv##OpCode: \ |
| return true; |
| switch (inst->opcode) { |
| TODO(OpUndef) |
| CASE(OpMemberName) |
| CASE(OpLine) |
| CASE(OpDecorate) |
| CASE(OpMemberDecorate) |
| CASE(OpDecorationGroup) |
| CASE(OpGroupDecorate) |
| CASE(OpGroupMemberDecorate) |
| TODO(OpExtInst) |
| CASE(OpEntryPoint) |
| CASE(OpExecutionMode) |
| CASE(OpTypeVector) |
| CASE(OpTypeMatrix) |
| CASE(OpTypeSampler) |
| CASE(OpTypeArray) |
| CASE(OpTypeRuntimeArray) |
| CASE(OpTypeStruct) |
| CASE(OpTypePointer) |
| CASE(OpTypeFunction) |
| CASE(OpTypePipe) |
| CASE(OpConstantTrue) |
| CASE(OpConstantFalse) |
| CASE(OpConstantComposite) |
| CASE(OpConstantSampler) |
| CASE(OpConstantNull) |
| CASE(OpSpecConstantTrue) |
| CASE(OpSpecConstantFalse) |
| CASE(OpSpecConstantComposite) |
| CASE(OpSampledImage) |
| TODO(OpSpecConstantOp) |
| CASE(OpVariable) |
| CASE(OpLoad) |
| CASE(OpStore) |
| CASE(OpCopyMemory) |
| CASE(OpCopyMemorySized) |
| CASE(OpAccessChain) |
| CASE(OpInBoundsAccessChain) |
| CASE(OpPtrAccessChain) |
| CASE(OpInBoundsPtrAccessChain) |
| TODO(OpArrayLength) |
| TODO(OpGenericPtrMemSemantics) |
| CASE(OpFunction) |
| CASE(OpFunctionParameter) |
| CASE(OpFunctionCall) |
| // Conversion opcodes are validated in validate_conversion.cpp. |
| CASE(OpVectorShuffle) |
| // Other composite opcodes are validated in validate_composites.cpp. |
| // Arithmetic opcodes are validated in validate_arithmetics.cpp. |
| // Bitwise opcodes are validated in validate_bitwise.cpp. |
| // Logical opcodes are validated in validate_logicals.cpp. |
| // Derivative opcodes are validated in validate_derivatives.cpp. |
| CASE(OpPhi) |
| TODO(OpLoopMerge) |
| TODO(OpSelectionMerge) |
| // OpBranch is validated in validate_cfg.cpp. |
| // See tests in test/val/val_cfg_test.cpp. |
| CASE(OpBranchConditional) |
| TODO(OpSwitch) |
| CASE(OpReturnValue) |
| TODO(OpLifetimeStart) |
| TODO(OpLifetimeStop) |
| TODO(OpAtomicLoad) |
| TODO(OpAtomicStore) |
| TODO(OpAtomicExchange) |
| TODO(OpAtomicCompareExchange) |
| TODO(OpAtomicCompareExchangeWeak) |
| TODO(OpAtomicIIncrement) |
| TODO(OpAtomicIDecrement) |
| TODO(OpAtomicIAdd) |
| TODO(OpAtomicISub) |
| TODO(OpAtomicUMin) |
| TODO(OpAtomicUMax) |
| TODO(OpAtomicAnd) |
| TODO(OpAtomicOr) |
| TODO(OpAtomicSMin) |
| TODO(OpAtomicSMax) |
| TODO(OpEmitStreamVertex) |
| TODO(OpEndStreamPrimitive) |
| TODO(OpGroupAsyncCopy) |
| TODO(OpGroupWaitEvents) |
| TODO(OpGroupAll) |
| TODO(OpGroupAny) |
| TODO(OpGroupBroadcast) |
| TODO(OpGroupIAdd) |
| TODO(OpGroupFAdd) |
| TODO(OpGroupFMin) |
| TODO(OpGroupUMin) |
| TODO(OpGroupSMin) |
| TODO(OpGroupFMax) |
| TODO(OpGroupUMax) |
| TODO(OpGroupSMax) |
| TODO(OpEnqueueMarker) |
| TODO(OpEnqueueKernel) |
| TODO(OpGetKernelNDrangeSubGroupCount) |
| TODO(OpGetKernelNDrangeMaxSubGroupSize) |
| TODO(OpGetKernelWorkGroupSize) |
| TODO(OpGetKernelPreferredWorkGroupSizeMultiple) |
| TODO(OpRetainEvent) |
| TODO(OpReleaseEvent) |
| TODO(OpCreateUserEvent) |
| TODO(OpIsValidEvent) |
| TODO(OpSetUserEventStatus) |
| TODO(OpCaptureEventProfilingInfo) |
| TODO(OpGetDefaultQueue) |
| TODO(OpBuildNDRange) |
| TODO(OpReadPipe) |
| TODO(OpWritePipe) |
| TODO(OpReservedReadPipe) |
| TODO(OpReservedWritePipe) |
| TODO(OpReserveReadPipePackets) |
| TODO(OpReserveWritePipePackets) |
| TODO(OpCommitReadPipe) |
| TODO(OpCommitWritePipe) |
| TODO(OpIsValidReserveId) |
| TODO(OpGetNumPipePackets) |
| TODO(OpGetMaxPipePackets) |
| TODO(OpGroupReserveReadPipePackets) |
| TODO(OpGroupReserveWritePipePackets) |
| TODO(OpGroupCommitReadPipe) |
| TODO(OpGroupCommitWritePipe) |
| default: |
| return true; |
| } |
| #undef TODO |
| #undef CASE |
| } |
| |
| bool idUsage::AreLayoutCompatibleStructs(const Instruction* type1, |
| const Instruction* type2) { |
| if (type1->opcode() != SpvOpTypeStruct) { |
| return false; |
| } |
| if (type2->opcode() != SpvOpTypeStruct) { |
| return false; |
| } |
| |
| if (!HaveLayoutCompatibleMembers(type1, type2)) return false; |
| |
| return HaveSameLayoutDecorations(type1, type2); |
| } |
| |
| bool idUsage::HaveLayoutCompatibleMembers(const Instruction* type1, |
| const Instruction* type2) { |
| assert(type1->opcode() == SpvOpTypeStruct && |
| "type1 must be and OpTypeStruct instruction."); |
| assert(type2->opcode() == SpvOpTypeStruct && |
| "type2 must be and OpTypeStruct instruction."); |
| const auto& type1_operands = type1->operands(); |
| const auto& type2_operands = type2->operands(); |
| if (type1_operands.size() != type2_operands.size()) { |
| return false; |
| } |
| |
| for (size_t operand = 2; operand < type1_operands.size(); ++operand) { |
| if (type1->word(operand) != type2->word(operand)) { |
| auto def1 = module_.FindDef(type1->word(operand)); |
| auto def2 = module_.FindDef(type2->word(operand)); |
| if (!AreLayoutCompatibleStructs(def1, def2)) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| bool idUsage::HaveSameLayoutDecorations(const Instruction* type1, |
| const Instruction* type2) { |
| assert(type1->opcode() == SpvOpTypeStruct && |
| "type1 must be and OpTypeStruct instruction."); |
| assert(type2->opcode() == SpvOpTypeStruct && |
| "type2 must be and OpTypeStruct instruction."); |
| const std::vector<Decoration>& type1_decorations = |
| module_.id_decorations(type1->id()); |
| const std::vector<Decoration>& type2_decorations = |
| module_.id_decorations(type2->id()); |
| |
| // TODO: Will have to add other check for arrays an matricies if we want to |
| // handle them. |
| if (HasConflictingMemberOffsets(type1_decorations, type2_decorations)) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool idUsage::HasConflictingMemberOffsets( |
| const vector<Decoration>& type1_decorations, |
| const vector<Decoration>& type2_decorations) const { |
| { |
| // We are interested in conflicting decoration. If a decoration is in one |
| // list but not the other, then we will assume the code is correct. We are |
| // looking for things we know to be wrong. |
| // |
| // We do not have to traverse type2_decoration because, after traversing |
| // type1_decorations, anything new will not be found in |
| // type1_decoration. Therefore, it cannot lead to a conflict. |
| for (const Decoration& decoration : type1_decorations) { |
| switch (decoration.dec_type()) { |
| case SpvDecorationOffset: { |
| // Since these affect the layout of the struct, they must be present |
| // in both structs. |
| auto compare = [&decoration](const Decoration& rhs) { |
| if (rhs.dec_type() != SpvDecorationOffset) return false; |
| return decoration.struct_member_index() == |
| rhs.struct_member_index(); |
| }; |
| auto i = find_if(type2_decorations.begin(), type2_decorations.end(), |
| compare); |
| if (i != type2_decorations.end() && |
| decoration.params().front() != i->params().front()) { |
| return true; |
| } |
| } break; |
| default: |
| // This decoration does not affect the layout of the structure, so |
| // just moving on. |
| break; |
| } |
| } |
| } |
| return false; |
| } |
| |
| } // namespace |
| |
| spv_result_t UpdateIdUse(ValidationState_t& _) { |
| for (const auto& inst : _.ordered_instructions()) { |
| for (auto& operand : inst.operands()) { |
| const spv_operand_type_t& type = operand.type; |
| const uint32_t operand_id = inst.word(operand.offset); |
| if (spvIsIdType(type) && type != SPV_OPERAND_TYPE_RESULT_ID) { |
| if (auto def = _.FindDef(operand_id)) |
| def->RegisterUse(&inst, operand.offset); |
| } |
| } |
| } |
| return SPV_SUCCESS; |
| } |
| |
| /// This function checks all ID definitions dominate their use in the CFG. |
| /// |
| /// This function will iterate over all ID definitions that are defined in the |
| /// functions of a module and make sure that the definitions appear in a |
| /// block that dominates their use. |
| /// |
| /// NOTE: This function does NOT check module scoped functions which are |
| /// checked during the initial binary parse in the IdPass below |
| spv_result_t CheckIdDefinitionDominateUse(const ValidationState_t& _) { |
| unordered_set<const Instruction*> phi_instructions; |
| for (const auto& definition : _.all_definitions()) { |
| // Check only those definitions defined in a function |
| if (const Function* func = definition.second->function()) { |
| if (const BasicBlock* block = definition.second->block()) { |
| if (!block->reachable()) continue; |
| // If the Id is defined within a block then make sure all references to |
| // that Id appear in a blocks that are dominated by the defining block |
| for (auto& use_index_pair : definition.second->uses()) { |
| const Instruction* use = use_index_pair.first; |
| if (const BasicBlock* use_block = use->block()) { |
| if (use_block->reachable() == false) continue; |
| if (use->opcode() == SpvOpPhi) { |
| phi_instructions.insert(use); |
| } else if (!block->dominates(*use->block())) { |
| return _.diag(SPV_ERROR_INVALID_ID) |
| << "ID " << _.getIdName(definition.first) |
| << " defined in block " << _.getIdName(block->id()) |
| << " does not dominate its use in block " |
| << _.getIdName(use_block->id()); |
| } |
| } |
| } |
| } else { |
| // If the Ids defined within a function but not in a block(i.e. function |
| // parameters, block ids), then make sure all references to that Id |
| // appear within the same function |
| for (auto use : definition.second->uses()) { |
| const Instruction* inst = use.first; |
| if (inst->function() && inst->function() != func) { |
| return _.diag(SPV_ERROR_INVALID_ID) |
| << "ID " << _.getIdName(definition.first) |
| << " used in function " |
| << _.getIdName(inst->function()->id()) |
| << " is used outside of it's defining function " |
| << _.getIdName(func->id()); |
| } |
| } |
| } |
| } |
| // NOTE: Ids defined outside of functions must appear before they are used |
| // This check is being performed in the IdPass function |
| } |
| |
| // Check all OpPhi parent blocks are dominated by the variable's defining |
| // blocks |
| for (const Instruction* phi : phi_instructions) { |
| if (phi->block()->reachable() == false) continue; |
| for (size_t i = 3; i < phi->operands().size(); i += 2) { |
| const Instruction* variable = _.FindDef(phi->word(i)); |
| const BasicBlock* parent = |
| phi->function()->GetBlock(phi->word(i + 1)).first; |
| if (variable->block() && parent->reachable() && |
| !variable->block()->dominates(*parent)) { |
| return _.diag(SPV_ERROR_INVALID_ID) |
| << "In OpPhi instruction " << _.getIdName(phi->id()) << ", ID " |
| << _.getIdName(variable->id()) |
| << " definition does not dominate its parent " |
| << _.getIdName(parent->id()); |
| } |
| } |
| } |
| |
| return SPV_SUCCESS; |
| } |
| |
| // Performs SSA validation on the IDs of an instruction. The |
| // can_have_forward_declared_ids functor should return true if the |
| // instruction operand's ID can be forward referenced. |
| spv_result_t IdPass(ValidationState_t& _, |
| const spv_parsed_instruction_t* inst) { |
| auto can_have_forward_declared_ids = |
| spvOperandCanBeForwardDeclaredFunction(static_cast<SpvOp>(inst->opcode)); |
| |
| // Keep track of a result id defined by this instruction. 0 means it |
| // does not define an id. |
| uint32_t result_id = 0; |
| |
| for (unsigned i = 0; i < inst->num_operands; i++) { |
| const spv_parsed_operand_t& operand = inst->operands[i]; |
| const spv_operand_type_t& type = operand.type; |
| // We only care about Id operands, which are a single word. |
| const uint32_t operand_word = inst->words[operand.offset]; |
| |
| auto ret = SPV_ERROR_INTERNAL; |
| switch (type) { |
| case SPV_OPERAND_TYPE_RESULT_ID: |
| // NOTE: Multiple Id definitions are being checked by the binary parser. |
| // |
| // Defer undefined-forward-reference removal until after we've analyzed |
| // the remaining operands to this instruction. Deferral only matters |
| // for |
| // OpPhi since it's the only case where it defines its own forward |
| // reference. Other instructions that can have forward references |
| // either don't define a value or the forward reference is to a function |
| // Id (and hence defined outside of a function body). |
| result_id = operand_word; |
| // NOTE: The result Id is added (in RegisterInstruction) *after* all of |
| // the other Ids have been checked to avoid premature use in the same |
| // instruction. |
| ret = SPV_SUCCESS; |
| break; |
| case SPV_OPERAND_TYPE_ID: |
| case SPV_OPERAND_TYPE_TYPE_ID: |
| case SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID: |
| case SPV_OPERAND_TYPE_SCOPE_ID: |
| if (_.IsDefinedId(operand_word)) { |
| ret = SPV_SUCCESS; |
| } else if (can_have_forward_declared_ids(i)) { |
| ret = _.ForwardDeclareId(operand_word); |
| } else { |
| ret = _.diag(SPV_ERROR_INVALID_ID) |
| << "ID " << _.getIdName(operand_word) |
| << " has not been defined"; |
| } |
| break; |
| default: |
| ret = SPV_SUCCESS; |
| break; |
| } |
| if (SPV_SUCCESS != ret) { |
| return ret; |
| } |
| } |
| if (result_id) { |
| _.RemoveIfForwardDeclared(result_id); |
| } |
| _.RegisterInstruction(*inst); |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t spvValidateInstructionIDs(const spv_instruction_t* pInsts, |
| const uint64_t instCount, |
| const ValidationState_t& state, |
| spv_position position) { |
| idUsage idUsage(state.context(), pInsts, instCount, state.memory_model(), |
| state.addressing_model(), state, state.entry_points(), |
| position, state.context()->consumer); |
| for (uint64_t instIndex = 0; instIndex < instCount; ++instIndex) { |
| if (!idUsage.isValid(&pInsts[instIndex])) return SPV_ERROR_INVALID_ID; |
| } |
| return SPV_SUCCESS; |
| } |
| |
| } // namespace val |
| } // namespace spvtools |
