mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-11-26 21:30:07 +00:00
d02f68ae79
Updated readme. Note: The header advertises itself as Rev 1, but contains many (all?) the updates intended for Rev 2. We might need to update one more time before SPIR-V 1.0 Rev2 is published. Regenerated syntax tables for 1.0. Changed names: InputTriangles -> Triangles InputQuads -> Quads InputIsolines -> Isolines WorkgroupLocal -> Workgroup WorkgroupGlobal -> CrossWorkgroup PrivateGlobal -> Private (Dim) InputTarget -> SubpassData WorkgroupLocalMemoryMask -> WorkgroupMemoryMask WorkgroupGlobalMemoryMask -> CrossWorkgroupMemoryMask AsyncGroupCopy -> GroupAsyncCopy WaitGroupEvents -> GroupWaitEvents Remove: IndependentForwardProgress capability Smooth decoration FragColor BuiltIn WorkgroupLinearId in favour of LocalInvocationId ImageSRGBWrite capability Special OpenCL image instructions Add: image channel data type UnormInt101010_2 AcquireReleaseMask InputTargetIndex updates: InputTargetIndex -> InputAttachmentIndex InputAttachmentIndex depends on InputAttachment capability, and it takes a literal number argument. Capability StorageImageExtendedFormats updates: Enum value changed from 26 to 49. (Changes position in tables). Replaces AdvancedImageFormat capability. OpenCL source language -> OpenCL_C, OpenCL_CPP
2611 lines
92 KiB
C++
2611 lines
92 KiB
C++
// Copyright (c) 2015 The Khronos Group Inc.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and/or associated documentation files (the
|
|
// "Materials"), to deal in the Materials without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Materials, and to
|
|
// permit persons to whom the Materials are furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Materials.
|
|
//
|
|
// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
|
|
// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
|
|
// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
|
|
// https://www.khronos.org/registry/
|
|
//
|
|
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
|
|
|
|
#include <assert.h>
|
|
|
|
#include <iostream>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
#include "diagnostic.h"
|
|
#include "instruction.h"
|
|
#include "libspirv/libspirv.h"
|
|
#include "opcode.h"
|
|
#include "validate.h"
|
|
|
|
#define spvCheck(condition, action) \
|
|
if (condition) { \
|
|
action; \
|
|
}
|
|
|
|
namespace {
|
|
class idUsage {
|
|
public:
|
|
idUsage(const spv_opcode_table opcodeTable,
|
|
const spv_operand_table operandTable,
|
|
const spv_ext_inst_table extInstTable, const spv_id_info_t* pIdUses,
|
|
const uint64_t idUsesCount, const spv_id_info_t* pIdDefs,
|
|
const uint64_t idDefsCount, const spv_instruction_t* pInsts,
|
|
const uint64_t instCount, spv_position position,
|
|
spv_diagnostic* pDiagnostic)
|
|
: opcodeTable(opcodeTable),
|
|
operandTable(operandTable),
|
|
extInstTable(extInstTable),
|
|
firstInst(pInsts),
|
|
instCount(instCount),
|
|
position(position),
|
|
pDiagnostic(pDiagnostic) {
|
|
for (uint64_t idUsesIndex = 0; idUsesIndex < idUsesCount; ++idUsesIndex) {
|
|
idUses[pIdUses[idUsesIndex].id].push_back(pIdUses[idUsesIndex]);
|
|
}
|
|
for (uint64_t idDefsIndex = 0; idDefsIndex < idDefsCount; ++idDefsIndex) {
|
|
idDefs[pIdDefs[idDefsIndex].id] = pIdDefs[idDefsIndex];
|
|
}
|
|
}
|
|
|
|
bool isValid(const spv_instruction_t* inst);
|
|
|
|
template <SpvOp>
|
|
bool isValid(const spv_instruction_t* inst, const spv_opcode_desc);
|
|
|
|
std::unordered_map<uint32_t, spv_id_info_t>::iterator find(
|
|
const uint32_t& id) {
|
|
return idDefs.find(id);
|
|
}
|
|
std::unordered_map<uint32_t, spv_id_info_t>::const_iterator find(
|
|
const uint32_t& id) const {
|
|
return idDefs.find(id);
|
|
}
|
|
|
|
bool found(std::unordered_map<uint32_t, spv_id_info_t>::iterator item) {
|
|
return idDefs.end() != item;
|
|
}
|
|
bool found(std::unordered_map<uint32_t, spv_id_info_t>::const_iterator item) {
|
|
return idDefs.end() != item;
|
|
}
|
|
|
|
std::unordered_map<uint32_t, std::vector<spv_id_info_t>>::iterator findUses(
|
|
const uint32_t& id) {
|
|
return idUses.find(id);
|
|
}
|
|
std::unordered_map<uint32_t, std::vector<spv_id_info_t>>::const_iterator
|
|
findUses(const uint32_t& id) const {
|
|
return idUses.find(id);
|
|
}
|
|
|
|
bool foundUses(
|
|
std::unordered_map<uint32_t, std::vector<spv_id_info_t>>::iterator item) {
|
|
return idUses.end() != item;
|
|
}
|
|
bool foundUses(std::unordered_map<
|
|
uint32_t, std::vector<spv_id_info_t>>::const_iterator item) {
|
|
return idUses.end() != item;
|
|
}
|
|
|
|
private:
|
|
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;
|
|
spv_position position;
|
|
spv_diagnostic* pDiagnostic;
|
|
std::unordered_map<uint32_t, std::vector<spv_id_info_t>> idUses;
|
|
std::unordered_map<uint32_t, spv_id_info_t> idDefs;
|
|
};
|
|
|
|
#define DIAG(INDEX) \
|
|
position->index += INDEX; \
|
|
DIAGNOSTIC
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<SpvOpUndef>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc) {
|
|
assert(0 && "Unimplemented!");
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpName>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto targetIndex = 1;
|
|
auto target = find(inst->words[targetIndex]);
|
|
spvCheck(!found(target), DIAG(targetIndex) << "OpName Target <id> '"
|
|
<< inst->words[targetIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpMemberName>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto typeIndex = 1;
|
|
auto type = find(inst->words[typeIndex]);
|
|
spvCheck(!found(type), DIAG(typeIndex) << "OpMemberName Type <id> '"
|
|
<< inst->words[typeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeStruct != type->second.opcode,
|
|
DIAG(typeIndex) << "OpMemberName Type <id> '"
|
|
<< inst->words[typeIndex]
|
|
<< "' is not a struct type.";
|
|
return false);
|
|
auto memberIndex = 2;
|
|
auto member = inst->words[memberIndex];
|
|
auto memberCount = (uint32_t)(type->second.inst->words.size() - 2);
|
|
spvCheck(memberCount <= member, DIAG(memberIndex)
|
|
<< "OpMemberName Member <id> '"
|
|
<< inst->words[memberIndex]
|
|
<< "' index is larger than Type <id> '"
|
|
<< type->second.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 = find(inst->words[fileIndex]);
|
|
spvCheck(!found(file), DIAG(fileIndex) << "OpLine Target <id> '"
|
|
<< inst->words[fileIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpString != file->second.opcode,
|
|
DIAG(fileIndex) << "OpLine Target <id> '" << 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 targetIndex = 1;
|
|
auto target = find(inst->words[targetIndex]);
|
|
spvCheck(!found(target), DIAG(targetIndex) << "OpDecorate Target <id> '"
|
|
<< inst->words[targetIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpMemberDecorate>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto structTypeIndex = 1;
|
|
auto structType = find(inst->words[structTypeIndex]);
|
|
spvCheck(!found(structType), DIAG(structTypeIndex)
|
|
<< "OpMemberDecorate Structure type <id> '"
|
|
<< inst->words[structTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeStruct != structType->second.inst->opcode,
|
|
DIAG(structTypeIndex) << "OpMemberDecorate Structure type <id> '"
|
|
<< inst->words[structTypeIndex]
|
|
<< "' is not a struct type.";
|
|
return false);
|
|
auto memberIndex = 2;
|
|
auto member = inst->words[memberIndex];
|
|
auto memberCount = (uint32_t)(structType->second.inst->words.size() - 2);
|
|
spvCheck(memberCount < member, DIAG(memberIndex)
|
|
<< "OpMemberDecorate Structure type <id> '"
|
|
<< inst->words[memberIndex]
|
|
<< "' member count is less than Member";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpGroupDecorate>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto decorationGroupIndex = 1;
|
|
auto decorationGroup = find(inst->words[decorationGroupIndex]);
|
|
spvCheck(!found(decorationGroup),
|
|
DIAG(decorationGroupIndex)
|
|
<< "OpGroupDecorate Decoration group <id> '"
|
|
<< inst->words[decorationGroupIndex] << "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpDecorationGroup != decorationGroup->second.opcode,
|
|
DIAG(decorationGroupIndex)
|
|
<< "OpGroupDecorate Decoration group <id> '"
|
|
<< inst->words[decorationGroupIndex]
|
|
<< "' is not a decoration group.";
|
|
return false);
|
|
for (size_t targetIndex = 2; targetIndex < inst->words.size();
|
|
++targetIndex) {
|
|
auto target = find(inst->words[targetIndex]);
|
|
spvCheck(!found(target), DIAG(targetIndex)
|
|
<< "OpGroupDecorate Target <id> '"
|
|
<< inst->words[targetIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<SpvOpGroupMemberDecorate>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<SpvOpExtInst>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpEntryPoint>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto entryPointIndex = 2;
|
|
auto entryPoint = find(inst->words[entryPointIndex]);
|
|
spvCheck(!found(entryPoint), DIAG(entryPointIndex)
|
|
<< "OpEntryPoint Entry Point <id> '"
|
|
<< inst->words[entryPointIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpFunction != entryPoint->second.opcode,
|
|
DIAG(entryPointIndex) << "OpEntryPoint Entry Point <id> '"
|
|
<< inst->words[entryPointIndex]
|
|
<< "' is not a function.";
|
|
return false);
|
|
// TODO: Check the entry point signature is void main(void), may be subject
|
|
// to change
|
|
auto entryPointType = find(entryPoint->second.inst->words[4]);
|
|
spvCheck(!found(entryPointType), assert(0 && "Unreachable!"));
|
|
spvCheck(3 != entryPointType->second.inst->words.size(),
|
|
DIAG(entryPointIndex) << "OpEntryPoint Entry Point <id> '"
|
|
<< inst->words[entryPointIndex]
|
|
<< "'s function parameter count is not zero.";
|
|
return false);
|
|
auto returnType = find(entryPoint->second.inst->words[1]);
|
|
spvCheck(!found(returnType), assert(0 && "Unreachable!"));
|
|
spvCheck(SpvOpTypeVoid != returnType->second.opcode,
|
|
DIAG(entryPointIndex) << "OpEntryPoint Entry Point <id> '"
|
|
<< 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 entryPoint = find(inst->words[entryPointIndex]);
|
|
spvCheck(!found(entryPoint), DIAG(entryPointIndex)
|
|
<< "OpExecutionMode Entry Point <id> '"
|
|
<< inst->words[entryPointIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
auto entryPointUses = findUses(inst->words[entryPointIndex]);
|
|
spvCheck(!foundUses(entryPointUses), assert(0 && "Unreachable!"));
|
|
bool foundEntryPointUse = false;
|
|
for (auto use : entryPointUses->second) {
|
|
if (SpvOpEntryPoint == use.opcode) {
|
|
foundEntryPointUse = true;
|
|
}
|
|
}
|
|
spvCheck(!foundEntryPointUse, DIAG(entryPointIndex)
|
|
<< "OpExecutionMode Entry Point <id> '"
|
|
<< 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 = find(inst->words[componentIndex]);
|
|
spvCheck(!found(componentType), DIAG(componentIndex)
|
|
<< "OpTypeVector Component Type <id> '"
|
|
<< inst->words[componentIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsScalarType(componentType->second.opcode),
|
|
DIAG(componentIndex) << "OpTypeVector Component Type <id> '"
|
|
<< 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 = find(inst->words[columnTypeIndex]);
|
|
spvCheck(!found(columnType), DIAG(columnTypeIndex)
|
|
<< "OpTypeMatrix Column Type <id> '"
|
|
<< inst->words[columnTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeVector != columnType->second.opcode,
|
|
DIAG(columnTypeIndex) << "OpTypeMatrix Column Type <id> '"
|
|
<< 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;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpTypeArray>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto elementTypeIndex = 2;
|
|
auto elementType = find(inst->words[elementTypeIndex]);
|
|
spvCheck(!found(elementType), DIAG(elementTypeIndex)
|
|
<< "OpTypeArray Element Type <id> '"
|
|
<< inst->words[elementTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeGeneratesType(elementType->second.opcode),
|
|
DIAG(elementTypeIndex) << "OpTypeArray Element Type <id> '"
|
|
<< inst->words[elementTypeIndex]
|
|
<< "' is not a type.";
|
|
return false);
|
|
auto lengthIndex = 3;
|
|
auto length = find(inst->words[lengthIndex]);
|
|
spvCheck(!found(length), DIAG(lengthIndex) << "OpTypeArray Length <id> '"
|
|
<< inst->words[lengthIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpConstant != length->second.opcode &&
|
|
SpvOpSpecConstant != length->second.opcode,
|
|
DIAG(lengthIndex) << "OpTypeArray Length <id> '"
|
|
<< inst->words[lengthIndex]
|
|
<< "' is not a scalar constant type.";
|
|
return false);
|
|
|
|
// NOTE: Check the initialiser value of the constant
|
|
auto constInst = length->second.inst;
|
|
auto constResultTypeIndex = 1;
|
|
auto constResultType = find(constInst->words[constResultTypeIndex]);
|
|
spvCheck(!found(constResultType), DIAG(lengthIndex)
|
|
<< "OpTypeArray Length <id> '"
|
|
<< inst->words[constResultTypeIndex]
|
|
<< "' result type is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeInt != constResultType->second.opcode,
|
|
DIAG(lengthIndex) << "OpTypeArray Length <id> '"
|
|
<< inst->words[lengthIndex]
|
|
<< "' is not a constant integer type.";
|
|
return false);
|
|
if (4 == constInst->words.size()) {
|
|
spvCheck(1 > constInst->words[3], DIAG(lengthIndex)
|
|
<< "OpTypeArray Length <id> '"
|
|
<< inst->words[lengthIndex]
|
|
<< "' value must be at least 1.";
|
|
return false);
|
|
} else if (5 == constInst->words.size()) {
|
|
uint64_t value =
|
|
constInst->words[3] | ((uint64_t)constInst->words[4]) << 32;
|
|
bool signedness = constResultType->second.inst->words[3];
|
|
if (signedness) {
|
|
spvCheck(1 > (int64_t)value, DIAG(lengthIndex)
|
|
<< "OpTypeArray Length <id> '"
|
|
<< inst->words[lengthIndex]
|
|
<< "' value must be at least 1.";
|
|
return false);
|
|
} else {
|
|
spvCheck(1 > value, DIAG(lengthIndex) << "OpTypeArray Length <id> '"
|
|
<< inst->words[lengthIndex]
|
|
<< "' value must be at least 1.";
|
|
return false);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpTypeRuntimeArray>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto elementTypeIndex = 2;
|
|
auto elementType = find(inst->words[elementTypeIndex]);
|
|
spvCheck(!found(elementType), DIAG(elementTypeIndex)
|
|
<< "OpTypeRuntimeArray Element Type <id> '"
|
|
<< inst->words[elementTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeGeneratesType(elementType->second.opcode),
|
|
DIAG(elementTypeIndex) << "OpTypeRuntimeArray Element Type <id> '"
|
|
<< 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) {
|
|
for (size_t memberTypeIndex = 2; memberTypeIndex < inst->words.size();
|
|
++memberTypeIndex) {
|
|
auto memberType = find(inst->words[memberTypeIndex]);
|
|
spvCheck(!found(memberType), DIAG(memberTypeIndex)
|
|
<< "OpTypeStruct Member Type <id> '"
|
|
<< inst->words[memberTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeGeneratesType(memberType->second.opcode),
|
|
DIAG(memberTypeIndex) << "OpTypeStruct Member Type <id> '"
|
|
<< inst->words[memberTypeIndex]
|
|
<< "' is not a type.";
|
|
return false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpTypePointer>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto typeIndex = 3;
|
|
auto type = find(inst->words[typeIndex]);
|
|
spvCheck(!found(type), DIAG(typeIndex) << "OpTypePointer Type <id> '"
|
|
<< inst->words[typeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeGeneratesType(type->second.opcode),
|
|
DIAG(typeIndex) << "OpTypePointer Type <id> '"
|
|
<< 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 = find(inst->words[returnTypeIndex]);
|
|
spvCheck(!found(returnType), DIAG(returnTypeIndex)
|
|
<< "OpTypeFunction Return Type <id> '"
|
|
<< inst->words[returnTypeIndex]
|
|
<< "' is not defined";
|
|
return false);
|
|
spvCheck(!spvOpcodeGeneratesType(returnType->second.opcode),
|
|
DIAG(returnTypeIndex) << "OpTypeFunction Return Type <id> '"
|
|
<< inst->words[returnTypeIndex]
|
|
<< "' is not a type.";
|
|
return false);
|
|
for (size_t paramTypeIndex = 3; paramTypeIndex < inst->words.size();
|
|
++paramTypeIndex) {
|
|
auto paramType = find(inst->words[paramTypeIndex]);
|
|
spvCheck(!found(paramType), DIAG(paramTypeIndex)
|
|
<< "OpTypeFunction Parameter Type <id> '"
|
|
<< inst->words[paramTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeGeneratesType(paramType->second.opcode),
|
|
DIAG(paramTypeIndex) << "OpTypeFunction Parameter Type <id> '"
|
|
<< inst->words[paramTypeIndex]
|
|
<< "' is not a type.";
|
|
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 = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpConstantTrue Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeBool != resultType->second.opcode,
|
|
DIAG(resultTypeIndex) << "OpConstantTrue Result Type <id> '"
|
|
<< 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 = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpConstantFalse Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeBool != resultType->second.opcode,
|
|
DIAG(resultTypeIndex) << "OpConstantFalse Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not a boolean type.";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpConstant>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto resultTypeIndex = 1;
|
|
auto resultType = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpConstant Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsScalarType(resultType->second.opcode),
|
|
DIAG(resultTypeIndex)
|
|
<< "OpConstant Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not a scalar integer or floating point type.";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpConstantComposite>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto resultTypeIndex = 1;
|
|
auto resultType = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpConstantComposite Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsComposite(resultType->second.opcode),
|
|
DIAG(resultTypeIndex) << "OpConstantComposite Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not a composite type.";
|
|
return false);
|
|
|
|
uint32_t constituentCount = inst->words.size() - 3;
|
|
switch (resultType->second.opcode) {
|
|
case SpvOpTypeVector: {
|
|
auto componentCount = resultType->second.inst->words[3];
|
|
spvCheck(
|
|
componentCount != constituentCount,
|
|
// TODO: Output ID's on diagnostic
|
|
DIAG(inst->words.size() - 1)
|
|
<< "OpConstantComposite Constituent <id> count does not match "
|
|
"Result Type <id> '"
|
|
<< resultType->second.id << "'s vector component count.";
|
|
return false);
|
|
auto componentType = find(resultType->second.inst->words[2]);
|
|
spvCheck(!found(componentType), assert(0 && "Unreachable!"));
|
|
for (size_t constituentIndex = 3; constituentIndex < inst->words.size();
|
|
constituentIndex++) {
|
|
auto constituent = find(inst->words[constituentIndex]);
|
|
spvCheck(!found(constituent), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeIsConstant(constituent->second.opcode),
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex] << "' is not a constant.";
|
|
return false);
|
|
auto constituentResultType = find(constituent->second.inst->words[1]);
|
|
spvCheck(!found(constituentResultType), assert(0 && "Unreachable!"));
|
|
spvCheck(componentType->second.opcode !=
|
|
constituentResultType->second.opcode,
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex]
|
|
<< "'s type does not match Result Type <id> '"
|
|
<< resultType->second.id << "'s vector element type.";
|
|
return false);
|
|
}
|
|
} break;
|
|
case SpvOpTypeMatrix: {
|
|
auto columnCount = resultType->second.inst->words[3];
|
|
spvCheck(
|
|
columnCount != constituentCount,
|
|
// TODO: Output ID's on diagnostic
|
|
DIAG(inst->words.size() - 1)
|
|
<< "OpConstantComposite Constituent <id> count does not match "
|
|
"Result Type <id> '"
|
|
<< resultType->second.id << "'s matrix column count.";
|
|
return false);
|
|
|
|
auto columnType = find(resultType->second.inst->words[2]);
|
|
spvCheck(!found(columnType), assert(0 && "Unreachable!"));
|
|
auto componentCount = columnType->second.inst->words[3];
|
|
auto componentType = find(columnType->second.inst->words[2]);
|
|
spvCheck(!found(componentType), assert(0 && "Unreachable!"));
|
|
|
|
for (size_t constituentIndex = 3; constituentIndex < inst->words.size();
|
|
constituentIndex++) {
|
|
auto constituent = find(inst->words[constituentIndex]);
|
|
spvCheck(!found(constituent),
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex] << "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpConstantComposite != constituent->second.opcode,
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex]
|
|
<< "' is not a constant composite.";
|
|
return false);
|
|
auto vector = find(constituent->second.inst->words[1]);
|
|
spvCheck(!found(vector), assert(0 && "Unreachable!"));
|
|
spvCheck(columnType->second.opcode != vector->second.opcode,
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex]
|
|
<< "' type does not match Result Type <id> '"
|
|
<< resultType->second.id << "'s matrix column type.";
|
|
return false);
|
|
auto vectorComponentType = find(vector->second.inst->words[2]);
|
|
spvCheck(!found(vectorComponentType), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeAreTypesEqual(componentType->second.inst,
|
|
vectorComponentType->second.inst),
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex]
|
|
<< "' component type does not match Result Type <id> '"
|
|
<< resultType->second.id
|
|
<< "'s matrix column component type.";
|
|
return false);
|
|
spvCheck(
|
|
componentCount != vector->second.inst->words[3],
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex]
|
|
<< "' vector component count does not match Result Type <id> '"
|
|
<< resultType->second.id << "'s vector component count.";
|
|
return false);
|
|
}
|
|
} break;
|
|
case SpvOpTypeArray: {
|
|
auto elementType = find(resultType->second.inst->words[2]);
|
|
spvCheck(!found(elementType), assert(0 && "Unreachable!"));
|
|
auto length = find(resultType->second.inst->words[3]);
|
|
spvCheck(!found(length), assert(0 && "Unreachable!"));
|
|
spvCheck(length->second.inst->words[3] != constituentCount,
|
|
DIAG(inst->words.size() - 1)
|
|
<< "OpConstantComposite Constituent count does not match "
|
|
"Result Type <id> '"
|
|
<< resultType->second.id << "'s array length.";
|
|
return false);
|
|
for (size_t constituentIndex = 3; constituentIndex < inst->words.size();
|
|
constituentIndex++) {
|
|
auto constituent = find(inst->words[constituentIndex]);
|
|
spvCheck(!found(constituent),
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex] << "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsConstant(constituent->second.opcode),
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex] << "' is not a constant.";
|
|
return false);
|
|
auto constituentType = find(constituent->second.inst->words[1]);
|
|
spvCheck(!found(constituentType), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeAreTypesEqual(elementType->second.inst,
|
|
constituentType->second.inst),
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex]
|
|
<< "'s type does not match Result Type <id> '"
|
|
<< resultType->second.id << "'s array element type.";
|
|
return false);
|
|
}
|
|
} break;
|
|
case SpvOpTypeStruct: {
|
|
uint32_t memberCount = resultType->second.inst->words.size() - 2;
|
|
spvCheck(memberCount != constituentCount,
|
|
DIAG(resultTypeIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' count does not match Result Type <id> '"
|
|
<< resultType->second.id << "'s struct member count.";
|
|
return false);
|
|
for (uint32_t constituentIndex = 3, memberIndex = 2;
|
|
constituentIndex < inst->words.size();
|
|
constituentIndex++, memberIndex++) {
|
|
auto constituent = find(inst->words[constituentIndex]);
|
|
spvCheck(!found(constituent),
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex] << "' is not define.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsConstant(constituent->second.opcode),
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex] << "' is not a constant.";
|
|
return false);
|
|
auto constituentType = find(constituent->second.inst->words[1]);
|
|
spvCheck(!found(constituentType), assert(0 && "Unreachable!"));
|
|
|
|
auto memberType = find(resultType->second.inst->words[memberIndex]);
|
|
spvCheck(!found(memberType), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeAreTypesEqual(memberType->second.inst,
|
|
constituentType->second.inst),
|
|
DIAG(constituentIndex)
|
|
<< "OpConstantComposite Constituent <id> '"
|
|
<< inst->words[constituentIndex]
|
|
<< "' type does not match the Result Type <id> '"
|
|
<< resultType->second.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 = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpConstantSampler Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeSampler != resultType->second.opcode,
|
|
DIAG(resultTypeIndex) << "OpConstantSampler Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not a sampler type.";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpConstantNull>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto resultTypeIndex = 1;
|
|
auto resultType = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpConstantNull Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
switch (resultType->second.inst->opcode) {
|
|
default: {
|
|
spvCheck(!spvOpcodeIsBasicTypeNullable(resultType->second.inst->opcode),
|
|
DIAG(resultTypeIndex) << "OpConstantNull Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' can not be null.";
|
|
return false);
|
|
} break;
|
|
case SpvOpTypeVector: {
|
|
auto type = find(resultType->second.inst->words[2]);
|
|
spvCheck(!found(type), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeIsBasicTypeNullable(type->second.inst->opcode),
|
|
DIAG(resultTypeIndex)
|
|
<< "OpConstantNull Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "'s vector component type can not be null.";
|
|
return false);
|
|
} break;
|
|
case SpvOpTypeArray: {
|
|
auto type = find(resultType->second.inst->words[2]);
|
|
spvCheck(!found(type), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeIsBasicTypeNullable(type->second.inst->opcode),
|
|
DIAG(resultTypeIndex)
|
|
<< "OpConstantNull Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "'s array element type can not be null.";
|
|
return false);
|
|
} break;
|
|
case SpvOpTypeMatrix: {
|
|
auto columnType = find(resultType->second.inst->words[2]);
|
|
spvCheck(!found(columnType), assert(0 && "Unreachable!"));
|
|
auto type = find(columnType->second.inst->words[2]);
|
|
spvCheck(!found(type), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeIsBasicTypeNullable(type->second.inst->opcode),
|
|
DIAG(resultTypeIndex)
|
|
<< "OpConstantNull Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "'s matrix component type cna not be null.";
|
|
return false);
|
|
} break;
|
|
case SpvOpTypeStruct: {
|
|
for (size_t elementIndex = 2;
|
|
elementIndex < resultType->second.inst->words.size();
|
|
++elementIndex) {
|
|
auto element = find(resultType->second.inst->words[elementIndex]);
|
|
spvCheck(!found(element), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeIsBasicTypeNullable(element->second.inst->opcode),
|
|
DIAG(resultTypeIndex)
|
|
<< "OpConstantNull Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "'s struct element type can not be null.";
|
|
return false);
|
|
}
|
|
} break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpSpecConstantTrue>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto resultTypeIndex = 1;
|
|
auto resultType = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpSpecConstantTrue Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeBool != resultType->second.opcode,
|
|
DIAG(resultTypeIndex) << "OpSpecConstantTrue Result Type <id> '"
|
|
<< 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 = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpSpecConstantFalse Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeBool != resultType->second.opcode,
|
|
DIAG(resultTypeIndex) << "OpSpecConstantFalse Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not a boolean type.";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpSpecConstant>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto resultTypeIndex = 1;
|
|
auto resultType = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpSpecConstant Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsScalarType(resultType->second.opcode),
|
|
DIAG(resultTypeIndex) << "OpSpecConstant Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not a scalar type.";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<SpvOpSpecConstantComposite>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#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 opcodeEntry) {
|
|
auto resultTypeIndex = 1;
|
|
auto resultType = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpVariable Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypePointer != resultType->second.opcode,
|
|
DIAG(resultTypeIndex) << "OpVariable Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not a pointer type.";
|
|
return false);
|
|
if (opcodeEntry->numTypes < inst->words.size()) {
|
|
auto initialiserIndex = 4;
|
|
auto initialiser = find(inst->words[initialiserIndex]);
|
|
spvCheck(!found(initialiser), DIAG(initialiserIndex)
|
|
<< "OpVariable Initializer <id> '"
|
|
<< inst->words[initialiserIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsConstant(initialiser->second.opcode),
|
|
DIAG(initialiserIndex) << "OpVariable Initializer <id> '"
|
|
<< inst->words[initialiserIndex]
|
|
<< "' is not a constant.";
|
|
return false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpLoad>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto resultTypeIndex = 1;
|
|
auto resultType = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpLoad Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defind.";
|
|
return false);
|
|
auto pointerIndex = 3;
|
|
auto pointer = find(inst->words[pointerIndex]);
|
|
spvCheck(!found(pointer), DIAG(pointerIndex) << "OpLoad Pointer <id> '"
|
|
<< inst->words[pointerIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsPointer(pointer->second.opcode),
|
|
DIAG(pointerIndex) << "OpLoad Pointer <id> '"
|
|
<< inst->words[pointerIndex]
|
|
<< "' is not a pointer.";
|
|
return false);
|
|
auto type = find(pointer->second.inst->words[1]);
|
|
spvCheck(!found(type), assert(0 && "Unreachable!"));
|
|
spvCheck(resultType != type, DIAG(resultTypeIndex)
|
|
<< "OpLoad Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< " does not match Pointer <id> '"
|
|
<< pointer->second.id << "'s type.";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpStore>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto pointerIndex = 1;
|
|
auto pointer = find(inst->words[pointerIndex]);
|
|
spvCheck(!found(pointer), DIAG(pointerIndex) << "OpStore Pointer <id> '"
|
|
<< inst->words[pointerIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsPointer(pointer->second.opcode),
|
|
DIAG(pointerIndex) << "OpStore Pointer <id> '"
|
|
<< inst->words[pointerIndex]
|
|
<< "' is not a pointer.";
|
|
return false);
|
|
auto pointerType = find(pointer->second.inst->words[1]);
|
|
spvCheck(!found(pointerType), assert(0 && "Unreachable!"));
|
|
auto type = find(pointerType->second.inst->words[3]);
|
|
spvCheck(!found(type), assert(0 && "Unreachable!"));
|
|
spvCheck(SpvOpTypeVoid == type->second.opcode,
|
|
DIAG(pointerIndex) << "OpStore Pointer <id> '"
|
|
<< inst->words[pointerIndex]
|
|
<< "'s type is void.";
|
|
return false);
|
|
|
|
auto objectIndex = 2;
|
|
auto object = find(inst->words[objectIndex]);
|
|
spvCheck(!found(object), DIAG(objectIndex) << "OpStore Object <id> '"
|
|
<< inst->words[objectIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsObject(object->second.opcode),
|
|
DIAG(objectIndex) << "OpStore Object <id> '"
|
|
<< inst->words[objectIndex]
|
|
<< "' in not an object.";
|
|
return false);
|
|
auto objectType = find(object->second.inst->words[1]);
|
|
spvCheck(!found(objectType), assert(0 && "Unreachable!"));
|
|
spvCheck(SpvOpTypeVoid == objectType->second.opcode,
|
|
DIAG(objectIndex) << "OpStore Object <id> '"
|
|
<< inst->words[objectIndex] << "'s type is void.";
|
|
return false);
|
|
|
|
spvCheck(!spvOpcodeAreTypesEqual(type->second.inst, objectType->second.inst),
|
|
DIAG(pointerIndex) << "OpStore Pointer <id> '"
|
|
<< inst->words[pointerIndex]
|
|
<< "'s type does not match Object <id> '"
|
|
<< objectType->second.id << "'s type.";
|
|
return false);
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool idUsage::isValid<SpvOpCopyMemory>(const spv_instruction_t* inst,
|
|
const spv_opcode_desc) {
|
|
auto targetIndex = 1;
|
|
auto target = find(inst->words[targetIndex]);
|
|
spvCheck(!found(target), DIAG(targetIndex) << "OpCopyMemory Target <id> '"
|
|
<< inst->words[targetIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
auto sourceIndex = 2;
|
|
auto source = find(inst->words[sourceIndex]);
|
|
spvCheck(!found(source), DIAG(targetIndex) << "OpCopyMemory Source <id> '"
|
|
<< inst->words[targetIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
auto targetPointerType = find(target->second.inst->words[1]);
|
|
spvCheck(!found(targetPointerType), assert(0 && "Unreachable!"));
|
|
auto targetType = find(targetPointerType->second.inst->words[3]);
|
|
spvCheck(!found(targetType), assert(0 && "Unreachable!"));
|
|
auto sourcePointerType = find(source->second.inst->words[1]);
|
|
spvCheck(!found(sourcePointerType), assert(0 && "Unreachable!"));
|
|
auto sourceType = find(sourcePointerType->second.inst->words[3]);
|
|
spvCheck(!found(sourceType), assert(0 && "Unreachable!"));
|
|
spvCheck(
|
|
!spvOpcodeAreTypesEqual(targetType->second.inst, sourceType->second.inst),
|
|
DIAG(sourceIndex) << "OpCopyMemory Target <id> '"
|
|
<< inst->words[sourceIndex]
|
|
<< "'s type does not match Source <id> '"
|
|
<< sourceType->second.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 = find(inst->words[targetIndex]);
|
|
spvCheck(!found(target),
|
|
DIAG(targetIndex) << "OpCopyMemorySized Target <id> '"
|
|
<< inst->words[targetIndex] << "' is not defined.";
|
|
return false);
|
|
auto sourceIndex = 2;
|
|
auto source = find(inst->words[sourceIndex]);
|
|
spvCheck(!found(source),
|
|
DIAG(sourceIndex) << "OpCopyMemorySized Source <id> '"
|
|
<< inst->words[sourceIndex] << "' is not defined.";
|
|
return false);
|
|
auto sizeIndex = 3;
|
|
auto size = find(inst->words[sizeIndex]);
|
|
spvCheck(!found(size), DIAG(sizeIndex) << "OpCopyMemorySized, Size <id> '"
|
|
<< inst->words[sizeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
auto targetPointerType = find(target->second.inst->words[1]);
|
|
spvCheck(!found(targetPointerType), assert(0 && "Unreachable!"));
|
|
spvCheck(SpvOpTypePointer != targetPointerType->second.opcode,
|
|
DIAG(targetIndex) << "OpCopyMemorySized Target <id> '"
|
|
<< inst->words[targetIndex]
|
|
<< "' is not a pointer.";
|
|
return false);
|
|
auto sourcePointerType = find(source->second.inst->words[1]);
|
|
spvCheck(!found(sourcePointerType), assert(0 && "Unreachable!"));
|
|
spvCheck(SpvOpTypePointer != sourcePointerType->second.opcode,
|
|
DIAG(sourceIndex) << "OpCopyMemorySized Source <id> '"
|
|
<< inst->words[sourceIndex]
|
|
<< "' is not a pointer.";
|
|
return false);
|
|
switch (size->second.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 = find(size->second.inst->words[1]);
|
|
spvCheck(!found(sizeType), assert(0 && "Unreachable!"));
|
|
spvCheck(SpvOpTypeInt != sizeType->second.opcode,
|
|
DIAG(sizeIndex) << "OpCopyMemorySized Size <id> '"
|
|
<< inst->words[sizeIndex]
|
|
<< "'s type is not an integer type.";
|
|
return false);
|
|
} break;
|
|
case SpvOpVariable: {
|
|
auto pointerType = find(size->second.inst->words[1]);
|
|
spvCheck(!found(pointerType), assert(0 && "Unreachable!"));
|
|
auto sizeType = find(pointerType->second.inst->words[1]);
|
|
spvCheck(!found(sizeType), assert(0 && "Unreachable!"));
|
|
spvCheck(SpvOpTypeInt != sizeType->second.opcode,
|
|
DIAG(sizeIndex) << "OpCopyMemorySized Size <id> '"
|
|
<< inst->words[sizeIndex]
|
|
<< "'s variable type is not an integer type.";
|
|
return false);
|
|
} break;
|
|
default:
|
|
DIAG(sizeIndex) << "OpCopyMemorySized Size <id> '"
|
|
<< 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;
|
|
}
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<SpvOpAccessChain>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<SpvOpInBoundsAccessChain>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#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) {
|
|
auto resultTypeIndex = 1;
|
|
auto resultType = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpFunction Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
auto functionTypeIndex = 4;
|
|
auto functionType = find(inst->words[functionTypeIndex]);
|
|
spvCheck(!found(functionType), DIAG(functionTypeIndex)
|
|
<< "OpFunction Function Type <id> '"
|
|
<< inst->words[functionTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpTypeFunction != functionType->second.opcode,
|
|
DIAG(functionTypeIndex) << "OpFunction Function Type <id> '"
|
|
<< inst->words[functionTypeIndex]
|
|
<< "' is not a function type.";
|
|
return false);
|
|
auto returnType = find(functionType->second.inst->words[2]);
|
|
spvCheck(!found(returnType), assert(0 && "Unreachable!"));
|
|
spvCheck(returnType != resultType,
|
|
DIAG(resultTypeIndex) << "OpFunction Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' does not match the Function Type <id> '"
|
|
<< resultType->second.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 = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpFunctionParameter Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
auto function = inst - 1;
|
|
// NOTE: Find OpFunction & ensure OpFunctionParameter is not out of place.
|
|
size_t paramIndex = 0;
|
|
while (firstInst != function) {
|
|
spvCheck(SpvOpFunction != function->opcode &&
|
|
SpvOpFunctionParameter != function->opcode,
|
|
DIAG(0) << "OpFunctionParameter is not preceded by OpFunction or "
|
|
"OpFunctionParameter sequence.";
|
|
return false);
|
|
if (SpvOpFunction == function->opcode) {
|
|
break;
|
|
} else {
|
|
paramIndex++;
|
|
}
|
|
}
|
|
auto functionType = find(function->words[4]);
|
|
spvCheck(!found(functionType), assert(0 && "Unreachable!"));
|
|
auto paramType = find(functionType->second.inst->words[paramIndex + 3]);
|
|
spvCheck(!found(paramType), assert(0 && "Unreachable!"));
|
|
spvCheck(
|
|
!spvOpcodeAreTypesEqual(resultType->second.inst, paramType->second.inst),
|
|
DIAG(resultTypeIndex) << "OpFunctionParameter Result Type <id> '"
|
|
<< 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 = find(inst->words[resultTypeIndex]);
|
|
spvCheck(!found(resultType), DIAG(resultTypeIndex)
|
|
<< "OpFunctionCall Result Type <id> '"
|
|
<< inst->words[resultTypeIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
auto functionIndex = 3;
|
|
auto function = find(inst->words[functionIndex]);
|
|
spvCheck(!found(function), DIAG(functionIndex)
|
|
<< "OpFunctionCall Function <id> '"
|
|
<< inst->words[functionIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(SpvOpFunction != function->second.opcode,
|
|
DIAG(functionIndex) << "OpFunctionCall Function <id> '"
|
|
<< inst->words[functionIndex]
|
|
<< "' is not a function.";
|
|
return false);
|
|
auto returnType = find(function->second.inst->words[1]);
|
|
spvCheck(!found(returnType), assert(0 && "Unreachable!"));
|
|
spvCheck(
|
|
!spvOpcodeAreTypesEqual(returnType->second.inst, resultType->second.inst),
|
|
DIAG(resultTypeIndex)
|
|
<< "OpFunctionCall Result Type <id> '" << inst->words[resultTypeIndex]
|
|
<< "'s type does not match Function <id> '" << returnType->second.id
|
|
<< "'s return type.";
|
|
return false);
|
|
auto functionType = find(function->second.inst->words[4]);
|
|
spvCheck(!found(functionType), assert(0 && "Unreachable!"));
|
|
auto functionCallArgCount = inst->words.size() - 4;
|
|
auto functionParamCount = functionType->second.inst->words.size() - 3;
|
|
spvCheck(
|
|
functionParamCount != functionCallArgCount,
|
|
DIAG(inst->words.size() - 1)
|
|
<< "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 = find(inst->words[argumentIndex]);
|
|
spvCheck(!found(argument), DIAG(argumentIndex)
|
|
<< "OpFunctionCall Argument <id> '"
|
|
<< inst->words[argumentIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
auto argumentType = find(argument->second.inst->words[1]);
|
|
spvCheck(!found(argumentType), assert(0 && "Unreachable!"));
|
|
auto parameterType = find(functionType->second.inst->words[paramIndex]);
|
|
spvCheck(!found(parameterType), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeAreTypesEqual(argumentType->second.inst,
|
|
parameterType->second.inst),
|
|
DIAG(argumentIndex) << "OpFunctionCall Argument <id> '"
|
|
<< inst->words[argumentIndex]
|
|
<< "'s type does not match Function <id> '"
|
|
<< parameterType->second.id
|
|
<< "'s parameter type.";
|
|
return false);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpConvertUToF>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpConvertFToS>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpConvertSToF>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpConvertUToF>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpUConvert>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSConvert>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFConvert>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpConvertPtrToU>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpConvertUToPtr>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpPtrCastToGeneric>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpGenericCastToPtr>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpBitcast>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpGenericCastToPtrExplicit>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSatConvertSToU>(const spv_instruction_t *inst) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSatConvertUToS>(const spv_instruction_t *inst) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpVectorExtractDynamic>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpVectorInsertDynamic>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpVectorShuffle>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpCompositeConstruct>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpCompositeExtract>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpCompositeInsert>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpCopyObject>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpTranspose>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSNegate>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFNegate>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpNot>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpIAdd>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFAdd>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpISub>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFSub>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpIMul>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFMul>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpUDiv>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSDiv>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFDiv>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpUMod>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSRem>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSMod>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFRem>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFMod>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpVectorTimesScalar>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpMatrixTimesScalar>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpVectorTimesMatrix>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpMatrixTimesVector>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpMatrixTimesMatrix>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpOuterProduct>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpDot>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpShiftRightLogical>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpShiftRightArithmetic>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpShiftLeftLogical>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpBitwiseOr>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpBitwiseXor>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpBitwiseAnd>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpAny>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpAll>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpIsNan>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpIsInf>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpIsFinite>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpIsNormal>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSignBitSet>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpLessOrGreater>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpOrdered>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpUnordered>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpLogicalOr>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpLogicalXor>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpLogicalAnd>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSelect>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpIEqual>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFOrdEqual>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFUnordEqual>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpINotEqual>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFOrdNotEqual>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFUnordNotEqual>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpULessThan>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSLessThan>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFOrdLessThan>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFUnordLessThan>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpUGreaterThan>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSGreaterThan>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFOrdGreaterThan>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFUnordGreaterThan>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpULessThanEqual>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSLessThanEqual>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFOrdLessThanEqual>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFUnordLessThanEqual>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpUGreaterThanEqual>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpSGreaterThanEqual>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFOrdGreaterThanEqual>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFUnordGreaterThanEqual>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpDPdx>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpDPdy>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFWidth>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpDPdxFine>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpDPdyFine>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFwidthFine>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpDPdxCoarse>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpDPdyCoarse>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpFwidthCoarse>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpPhi>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#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
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpBranch>(const spv_instruction_t *inst,
|
|
const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#if 0
|
|
template <>
|
|
bool idUsage::isValid<OpBranchConditional>(
|
|
const spv_instruction_t *inst, const spv_opcode_desc opcodeEntry) {}
|
|
#endif
|
|
|
|
#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 = find(inst->words[valueIndex]);
|
|
spvCheck(!found(value), DIAG(valueIndex) << "OpReturnValue Value <id> '"
|
|
<< inst->words[valueIndex]
|
|
<< "' is not defined.";
|
|
return false);
|
|
spvCheck(!spvOpcodeIsValue(value->second.opcode),
|
|
DIAG(valueIndex) << "OpReturnValue Value <id> '"
|
|
<< inst->words[valueIndex]
|
|
<< "' does not represent a value.";
|
|
return false);
|
|
auto valueType = find(value->second.inst->words[1]);
|
|
spvCheck(!found(valueType), assert(0 && "Unreachable!"));
|
|
// NOTE: Find OpFunction
|
|
const spv_instruction_t* function = inst - 1;
|
|
while (firstInst != function) {
|
|
spvCheck(SpvOpFunction == function->opcode, break);
|
|
function--;
|
|
}
|
|
spvCheck(SpvOpFunction != function->opcode,
|
|
DIAG(valueIndex) << "OpReturnValue is not in a basic block.";
|
|
return false);
|
|
auto returnType = find(function->words[1]);
|
|
spvCheck(!found(returnType), assert(0 && "Unreachable!"));
|
|
if (SpvOpTypePointer == valueType->second.opcode) {
|
|
auto pointerValueType = find(valueType->second.inst->words[3]);
|
|
spvCheck(!found(pointerValueType), assert(0 && "Unreachable!"));
|
|
spvCheck(!spvOpcodeAreTypesEqual(returnType->second.inst,
|
|
pointerValueType->second.inst),
|
|
DIAG(valueIndex)
|
|
<< "OpReturnValue Value <id> '" << inst->words[valueIndex]
|
|
<< "'s pointer type does not match OpFunction's return type.";
|
|
return false);
|
|
} else {
|
|
spvCheck(!spvOpcodeAreTypesEqual(returnType->second.inst,
|
|
valueType->second.inst),
|
|
DIAG(valueIndex)
|
|
<< "OpReturnValue Value <id> '" << 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;
|
|
spvCheck(spvOpcodeTableValueLookup(opcodeTable, inst->opcode, &opcodeEntry),
|
|
return false);
|
|
#define CASE(OpCode) \
|
|
case Spv##OpCode: \
|
|
return isValid<Spv##OpCode>(inst, opcodeEntry);
|
|
#define FAIL(OpCode) \
|
|
case Spv##OpCode: \
|
|
std::cerr << "Not implemented: " << #OpCode << "\n"; \
|
|
return false;
|
|
switch (inst->opcode) {
|
|
FAIL(OpUndef)
|
|
CASE(OpName)
|
|
CASE(OpMemberName)
|
|
CASE(OpLine)
|
|
CASE(OpDecorate)
|
|
CASE(OpMemberDecorate)
|
|
CASE(OpGroupDecorate)
|
|
FAIL(OpGroupMemberDecorate)
|
|
FAIL(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(OpConstant)
|
|
CASE(OpConstantComposite)
|
|
CASE(OpConstantSampler)
|
|
CASE(OpConstantNull)
|
|
CASE(OpSpecConstantTrue)
|
|
CASE(OpSpecConstantFalse)
|
|
CASE(OpSpecConstant)
|
|
FAIL(OpSpecConstantComposite)
|
|
FAIL(OpSpecConstantOp)
|
|
CASE(OpVariable)
|
|
CASE(OpLoad)
|
|
CASE(OpStore)
|
|
CASE(OpCopyMemory)
|
|
CASE(OpCopyMemorySized)
|
|
FAIL(OpAccessChain)
|
|
FAIL(OpInBoundsAccessChain)
|
|
FAIL(OpArrayLength)
|
|
FAIL(OpGenericPtrMemSemantics)
|
|
CASE(OpFunction)
|
|
CASE(OpFunctionParameter)
|
|
CASE(OpFunctionCall)
|
|
FAIL(OpConvertUToF)
|
|
FAIL(OpConvertFToS)
|
|
FAIL(OpConvertSToF)
|
|
FAIL(OpUConvert)
|
|
FAIL(OpSConvert)
|
|
FAIL(OpFConvert)
|
|
FAIL(OpConvertPtrToU)
|
|
FAIL(OpConvertUToPtr)
|
|
FAIL(OpPtrCastToGeneric)
|
|
FAIL(OpGenericCastToPtr)
|
|
FAIL(OpBitcast)
|
|
FAIL(OpGenericCastToPtrExplicit)
|
|
FAIL(OpSatConvertSToU)
|
|
FAIL(OpSatConvertUToS)
|
|
FAIL(OpVectorExtractDynamic)
|
|
FAIL(OpVectorInsertDynamic)
|
|
FAIL(OpVectorShuffle)
|
|
FAIL(OpCompositeConstruct)
|
|
FAIL(OpCompositeExtract)
|
|
FAIL(OpCompositeInsert)
|
|
FAIL(OpCopyObject)
|
|
FAIL(OpTranspose)
|
|
FAIL(OpSNegate)
|
|
FAIL(OpFNegate)
|
|
FAIL(OpNot)
|
|
FAIL(OpIAdd)
|
|
FAIL(OpFAdd)
|
|
FAIL(OpISub)
|
|
FAIL(OpFSub)
|
|
FAIL(OpIMul)
|
|
FAIL(OpFMul)
|
|
FAIL(OpUDiv)
|
|
FAIL(OpSDiv)
|
|
FAIL(OpFDiv)
|
|
FAIL(OpUMod)
|
|
FAIL(OpSRem)
|
|
FAIL(OpSMod)
|
|
FAIL(OpFRem)
|
|
FAIL(OpFMod)
|
|
FAIL(OpVectorTimesScalar)
|
|
FAIL(OpMatrixTimesScalar)
|
|
FAIL(OpVectorTimesMatrix)
|
|
FAIL(OpMatrixTimesVector)
|
|
FAIL(OpMatrixTimesMatrix)
|
|
FAIL(OpOuterProduct)
|
|
FAIL(OpDot)
|
|
FAIL(OpShiftRightLogical)
|
|
FAIL(OpShiftRightArithmetic)
|
|
FAIL(OpShiftLeftLogical)
|
|
FAIL(OpBitwiseOr)
|
|
FAIL(OpBitwiseXor)
|
|
FAIL(OpBitwiseAnd)
|
|
FAIL(OpAny)
|
|
FAIL(OpAll)
|
|
FAIL(OpIsNan)
|
|
FAIL(OpIsInf)
|
|
FAIL(OpIsFinite)
|
|
FAIL(OpIsNormal)
|
|
FAIL(OpSignBitSet)
|
|
FAIL(OpLessOrGreater)
|
|
FAIL(OpOrdered)
|
|
FAIL(OpUnordered)
|
|
FAIL(OpLogicalOr)
|
|
FAIL(OpLogicalAnd)
|
|
FAIL(OpSelect)
|
|
FAIL(OpIEqual)
|
|
FAIL(OpFOrdEqual)
|
|
FAIL(OpFUnordEqual)
|
|
FAIL(OpINotEqual)
|
|
FAIL(OpFOrdNotEqual)
|
|
FAIL(OpFUnordNotEqual)
|
|
FAIL(OpULessThan)
|
|
FAIL(OpSLessThan)
|
|
FAIL(OpFOrdLessThan)
|
|
FAIL(OpFUnordLessThan)
|
|
FAIL(OpUGreaterThan)
|
|
FAIL(OpSGreaterThan)
|
|
FAIL(OpFOrdGreaterThan)
|
|
FAIL(OpFUnordGreaterThan)
|
|
FAIL(OpULessThanEqual)
|
|
FAIL(OpSLessThanEqual)
|
|
FAIL(OpFOrdLessThanEqual)
|
|
FAIL(OpFUnordLessThanEqual)
|
|
FAIL(OpUGreaterThanEqual)
|
|
FAIL(OpSGreaterThanEqual)
|
|
FAIL(OpFOrdGreaterThanEqual)
|
|
FAIL(OpFUnordGreaterThanEqual)
|
|
FAIL(OpDPdx)
|
|
FAIL(OpDPdy)
|
|
FAIL(OpFwidth)
|
|
FAIL(OpDPdxFine)
|
|
FAIL(OpDPdyFine)
|
|
FAIL(OpFwidthFine)
|
|
FAIL(OpDPdxCoarse)
|
|
FAIL(OpDPdyCoarse)
|
|
FAIL(OpFwidthCoarse)
|
|
FAIL(OpPhi)
|
|
FAIL(OpLoopMerge)
|
|
FAIL(OpSelectionMerge)
|
|
FAIL(OpBranch)
|
|
FAIL(OpBranchConditional)
|
|
FAIL(OpSwitch)
|
|
CASE(OpReturnValue)
|
|
FAIL(OpLifetimeStart)
|
|
FAIL(OpLifetimeStop)
|
|
FAIL(OpAtomicLoad)
|
|
FAIL(OpAtomicStore)
|
|
FAIL(OpAtomicExchange)
|
|
FAIL(OpAtomicCompareExchange)
|
|
FAIL(OpAtomicCompareExchangeWeak)
|
|
FAIL(OpAtomicIIncrement)
|
|
FAIL(OpAtomicIDecrement)
|
|
FAIL(OpAtomicIAdd)
|
|
FAIL(OpAtomicISub)
|
|
FAIL(OpAtomicUMin)
|
|
FAIL(OpAtomicUMax)
|
|
FAIL(OpAtomicAnd)
|
|
FAIL(OpAtomicOr)
|
|
FAIL(OpAtomicSMin)
|
|
FAIL(OpAtomicSMax)
|
|
FAIL(OpEmitStreamVertex)
|
|
FAIL(OpEndStreamPrimitive)
|
|
FAIL(OpGroupAsyncCopy)
|
|
FAIL(OpGroupWaitEvents)
|
|
FAIL(OpGroupAll)
|
|
FAIL(OpGroupAny)
|
|
FAIL(OpGroupBroadcast)
|
|
FAIL(OpGroupIAdd)
|
|
FAIL(OpGroupFAdd)
|
|
FAIL(OpGroupFMin)
|
|
FAIL(OpGroupUMin)
|
|
FAIL(OpGroupSMin)
|
|
FAIL(OpGroupFMax)
|
|
FAIL(OpGroupUMax)
|
|
FAIL(OpGroupSMax)
|
|
FAIL(OpEnqueueMarker)
|
|
FAIL(OpEnqueueKernel)
|
|
FAIL(OpGetKernelNDrangeSubGroupCount)
|
|
FAIL(OpGetKernelNDrangeMaxSubGroupSize)
|
|
FAIL(OpGetKernelWorkGroupSize)
|
|
FAIL(OpGetKernelPreferredWorkGroupSizeMultiple)
|
|
FAIL(OpRetainEvent)
|
|
FAIL(OpReleaseEvent)
|
|
FAIL(OpCreateUserEvent)
|
|
FAIL(OpIsValidEvent)
|
|
FAIL(OpSetUserEventStatus)
|
|
FAIL(OpCaptureEventProfilingInfo)
|
|
FAIL(OpGetDefaultQueue)
|
|
FAIL(OpBuildNDRange)
|
|
FAIL(OpReadPipe)
|
|
FAIL(OpWritePipe)
|
|
FAIL(OpReservedReadPipe)
|
|
FAIL(OpReservedWritePipe)
|
|
FAIL(OpReserveReadPipePackets)
|
|
FAIL(OpReserveWritePipePackets)
|
|
FAIL(OpCommitReadPipe)
|
|
FAIL(OpCommitWritePipe)
|
|
FAIL(OpIsValidReserveId)
|
|
FAIL(OpGetNumPipePackets)
|
|
FAIL(OpGetMaxPipePackets)
|
|
FAIL(OpGroupReserveReadPipePackets)
|
|
FAIL(OpGroupReserveWritePipePackets)
|
|
FAIL(OpGroupCommitReadPipe)
|
|
FAIL(OpGroupCommitWritePipe)
|
|
default:
|
|
return true;
|
|
}
|
|
#undef FAIL
|
|
#undef CASE
|
|
}
|
|
} // anonymous namespace
|
|
|
|
spv_result_t spvValidateInstructionIDs(
|
|
const spv_instruction_t* pInsts, const uint64_t instCount,
|
|
const spv_id_info_t* pIdUses, const uint64_t idUsesCount,
|
|
const spv_id_info_t* pIdDefs, const uint64_t idDefsCount,
|
|
const spv_opcode_table opcodeTable, const spv_operand_table operandTable,
|
|
const spv_ext_inst_table extInstTable, spv_position position,
|
|
spv_diagnostic* pDiag) {
|
|
idUsage idUsage(opcodeTable, operandTable, extInstTable, pIdUses, idUsesCount,
|
|
pIdDefs, idDefsCount, pInsts, instCount, position, pDiag);
|
|
for (uint64_t instIndex = 0; instIndex < instCount; ++instIndex) {
|
|
spvCheck(!idUsage.isValid(&pInsts[instIndex]), return SPV_ERROR_INVALID_ID);
|
|
position->index += pInsts[instIndex].words.size();
|
|
}
|
|
return SPV_SUCCESS;
|
|
}
|