AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-29 22:41:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
a0fcd06f8f
SPIRV-Tools/source/val/validate_extensions.cpp
Spencer Fricke d8a8af8e6d
spirv-val: Remove unused includes and code (#5176)
2023-03-28 14:18:19 -04:00

3716 lines
148 KiB
C++
Raw Blame History

// Copyright (c) 2018 Google 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.
// Validates correctness of extension SPIR-V instructions.
#include <cstdlib>
#include <sstream>
#include <string>
#include <vector>
#include "NonSemanticShaderDebugInfo100.h"
#include "OpenCLDebugInfo100.h"
#include "source/common_debug_info.h"
#include "source/enum_string_mapping.h"
#include "source/extensions.h"
#include "source/latest_version_glsl_std_450_header.h"
#include "source/latest_version_opencl_std_header.h"
#include "source/spirv_constant.h"
#include "source/val/instruction.h"
#include "source/val/validate.h"
#include "source/val/validation_state.h"
#include "spirv/unified1/NonSemanticClspvReflection.h"
namespace spvtools {
namespace val {
namespace {
std::string ReflectionInstructionName(ValidationState_t& _,
const Instruction* inst) {
spv_ext_inst_desc desc = nullptr;
if (_.grammar().lookupExtInst(SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION,
inst->word(4), &desc) != SPV_SUCCESS ||
!desc) {
return std::string("Unknown ExtInst");
}
std::ostringstream ss;
ss << desc->name;
return ss.str();
}
uint32_t GetSizeTBitWidth(const ValidationState_t& _) {
if (_.addressing_model() == spv::AddressingModel::Physical32) return 32;
if (_.addressing_model() == spv::AddressingModel::Physical64) return 64;
return 0;
}
bool IsIntScalar(ValidationState_t& _, uint32_t id, bool must_len32,
bool must_unsigned) {
auto type = _.FindDef(id);
if (!type || type->opcode() != spv::Op::OpTypeInt) {
return false;
}
if (must_len32 && type->GetOperandAs<uint32_t>(1) != 32) {
return false;
}
return !must_unsigned || type->GetOperandAs<uint32_t>(2) == 0;
}
bool IsUint32Constant(ValidationState_t& _, uint32_t id) {
auto inst = _.FindDef(id);
if (!inst || inst->opcode() != spv::Op::OpConstant) {
return false;
}
return IsIntScalar(_, inst->type_id(), true, true);
}
uint32_t GetUint32Constant(ValidationState_t& _, uint32_t id) {
auto inst = _.FindDef(id);
return inst->word(3);
}
// Check that the operand of a debug info instruction |inst| at |word_index|
// is a result id of an instruction with |expected_opcode|.
spv_result_t ValidateOperandForDebugInfo(
ValidationState_t& _, const std::string& operand_name,
spv::Op expected_opcode, const Instruction* inst, uint32_t word_index,
const std::function<std::string()>& ext_inst_name) {
auto* operand = _.FindDef(inst->word(word_index));
if (operand->opcode() != expected_opcode) {
spv_opcode_desc desc = nullptr;
if (_.grammar().lookupOpcode(expected_opcode, &desc) != SPV_SUCCESS ||
!desc) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand " << operand_name << " is invalid";
}
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand " << operand_name << " must be a result id of "
<< "Op" << desc->name;
}
return SPV_SUCCESS;
}
// For NonSemantic.Shader.DebugInfo.100 check that the operand of a debug info
// instruction |inst| at |word_index| is a result id of a 32-bit integer
// OpConstant instruction. For OpenCL.DebugInfo.100 the parameter is a literal
// word so cannot be validated.
spv_result_t ValidateUint32ConstantOperandForDebugInfo(
ValidationState_t& _, const std::string& operand_name,
const Instruction* inst, uint32_t word_index,
const std::function<std::string()>& ext_inst_name) {
if (!IsUint32Constant(_, inst->word(word_index))) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": expected operand " << operand_name
<< " must be a result id of 32-bit unsigned OpConstant";
}
return SPV_SUCCESS;
}
#define CHECK_OPERAND(NAME, opcode, index) \
do { \
auto result = ValidateOperandForDebugInfo(_, NAME, opcode, inst, index, \
ext_inst_name); \
if (result != SPV_SUCCESS) return result; \
} while (0)
#define CHECK_CONST_UINT_OPERAND(NAME, index) \
if (vulkanDebugInfo) { \
auto result = ValidateUint32ConstantOperandForDebugInfo( \
_, NAME, inst, index, ext_inst_name); \
if (result != SPV_SUCCESS) return result; \
}
// True if the operand of a debug info instruction |inst| at |word_index|
// satisfies |expectation| that is given as a function. Otherwise,
// returns false.
bool DoesDebugInfoOperandMatchExpectation(
const ValidationState_t& _,
const std::function<bool(CommonDebugInfoInstructions)>& expectation,
const Instruction* inst, uint32_t word_index) {
if (inst->words().size() <= word_index) return false;
auto* debug_inst = _.FindDef(inst->word(word_index));
if (debug_inst->opcode() != spv::Op::OpExtInst ||
(debug_inst->ext_inst_type() != SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 &&
debug_inst->ext_inst_type() !=
SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) ||
!expectation(CommonDebugInfoInstructions(debug_inst->word(4)))) {
return false;
}
return true;
}
// Overload for NonSemanticShaderDebugInfo100Instructions.
bool DoesDebugInfoOperandMatchExpectation(
const ValidationState_t& _,
const std::function<bool(NonSemanticShaderDebugInfo100Instructions)>&
expectation,
const Instruction* inst, uint32_t word_index) {
if (inst->words().size() <= word_index) return false;
auto* debug_inst = _.FindDef(inst->word(word_index));
if (debug_inst->opcode() != spv::Op::OpExtInst ||
(debug_inst->ext_inst_type() !=
SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) ||
!expectation(
NonSemanticShaderDebugInfo100Instructions(debug_inst->word(4)))) {
return false;
}
return true;
}
// Check that the operand of a debug info instruction |inst| at |word_index|
// is a result id of an debug info instruction whose debug instruction type
// is |expected_debug_inst|.
spv_result_t ValidateDebugInfoOperand(
ValidationState_t& _, const std::string& debug_inst_name,
CommonDebugInfoInstructions expected_debug_inst, const Instruction* inst,
uint32_t word_index, const std::function<std::string()>& ext_inst_name) {
std::function<bool(CommonDebugInfoInstructions)> expectation =
[expected_debug_inst](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst == expected_debug_inst;
};
if (DoesDebugInfoOperandMatchExpectation(_, expectation, inst, word_index))
return SPV_SUCCESS;
spv_ext_inst_desc desc = nullptr;
if (_.grammar().lookupExtInst(inst->ext_inst_type(), expected_debug_inst,
&desc) != SPV_SUCCESS ||
!desc) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand " << debug_inst_name << " is invalid";
}
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand " << debug_inst_name << " must be a result id of "
<< desc->name;
}
#define CHECK_DEBUG_OPERAND(NAME, debug_opcode, index) \
do { \
auto result = ValidateDebugInfoOperand(_, NAME, debug_opcode, inst, index, \
ext_inst_name); \
if (result != SPV_SUCCESS) return result; \
} while (0)
// Check that the operand of a debug info instruction |inst| at |word_index|
// is a result id of an debug info instruction with DebugTypeBasic.
spv_result_t ValidateOperandBaseType(
ValidationState_t& _, const Instruction* inst, uint32_t word_index,
const std::function<std::string()>& ext_inst_name) {
return ValidateDebugInfoOperand(_, "Base Type", CommonDebugInfoDebugTypeBasic,
inst, word_index, ext_inst_name);
}
// Check that the operand of a debug info instruction |inst| at |word_index|
// is a result id of a debug lexical scope instruction which is one of
// DebugCompilationUnit, DebugFunction, DebugLexicalBlock, or
// DebugTypeComposite.
spv_result_t ValidateOperandLexicalScope(
ValidationState_t& _, const std::string& debug_inst_name,
const Instruction* inst, uint32_t word_index,
const std::function<std::string()>& ext_inst_name) {
std::function<bool(CommonDebugInfoInstructions)> expectation =
[](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst == CommonDebugInfoDebugCompilationUnit ||
dbg_inst == CommonDebugInfoDebugFunction ||
dbg_inst == CommonDebugInfoDebugLexicalBlock ||
dbg_inst == CommonDebugInfoDebugTypeComposite;
};
if (DoesDebugInfoOperandMatchExpectation(_, expectation, inst, word_index))
return SPV_SUCCESS;
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand " << debug_inst_name
<< " must be a result id of a lexical scope";
}
// Check that the operand of a debug info instruction |inst| at |word_index|
// is a result id of a debug type instruction (See DebugTypeXXX in
// "4.3. Type instructions" section of OpenCL.DebugInfo.100 spec.
spv_result_t ValidateOperandDebugType(
ValidationState_t& _, const std::string& debug_inst_name,
const Instruction* inst, uint32_t word_index,
const std::function<std::string()>& ext_inst_name,
bool allow_template_param) {
// Check for NonSemanticShaderDebugInfo100 specific types.
if (inst->ext_inst_type() ==
SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) {
std::function<bool(NonSemanticShaderDebugInfo100Instructions)> expectation =
[](NonSemanticShaderDebugInfo100Instructions dbg_inst) {
return dbg_inst == NonSemanticShaderDebugInfo100DebugTypeMatrix;
};
if (DoesDebugInfoOperandMatchExpectation(_, expectation, inst, word_index))
return SPV_SUCCESS;
}
// Check for common types.
std::function<bool(CommonDebugInfoInstructions)> expectation =
[&allow_template_param](CommonDebugInfoInstructions dbg_inst) {
if (allow_template_param &&
(dbg_inst == CommonDebugInfoDebugTypeTemplateParameter ||
dbg_inst == CommonDebugInfoDebugTypeTemplateTemplateParameter)) {
return true;
}
return CommonDebugInfoDebugTypeBasic <= dbg_inst &&
dbg_inst <= CommonDebugInfoDebugTypeTemplate;
};
if (DoesDebugInfoOperandMatchExpectation(_, expectation, inst, word_index))
return SPV_SUCCESS;
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand " << debug_inst_name
<< " is not a valid debug type";
}
spv_result_t ValidateClspvReflectionKernel(ValidationState_t& _,
const Instruction* inst,
uint32_t version) {
const auto inst_name = ReflectionInstructionName(_, inst);
const auto kernel_id = inst->GetOperandAs<uint32_t>(4);
const auto kernel = _.FindDef(kernel_id);
if (kernel->opcode() != spv::Op::OpFunction) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< inst_name << " does not reference a function";
}
bool found_kernel = false;
for (auto entry_point : _.entry_points()) {
if (entry_point == kernel_id) {
found_kernel = true;
break;
}
}
if (!found_kernel) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< inst_name << " does not reference an entry-point";
}
const auto* exec_models = _.GetExecutionModels(kernel_id);
if (!exec_models || exec_models->empty()) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< inst_name << " does not reference an entry-point";
}
for (auto exec_model : *exec_models) {
if (exec_model != spv::ExecutionModel::GLCompute) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< inst_name << " must refer only to GLCompute entry-points";
}
}
auto name = _.FindDef(inst->GetOperandAs<uint32_t>(5));
if (!name || name->opcode() != spv::Op::OpString) {
return _.diag(SPV_ERROR_INVALID_ID, inst) << "Name must be an OpString";
}
const std::string name_str = name->GetOperandAs<std::string>(1);
bool found = false;
for (auto& desc : _.entry_point_descriptions(kernel_id)) {
if (name_str == desc.name) {
found = true;
break;
}
}
if (!found) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Name must match an entry-point for Kernel";
}
const auto num_operands = inst->operands().size();
if (version < 5 && num_operands > 6) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Version " << version << " of the " << inst_name
<< " instruction can only have 2 additional operands";
}
if (num_operands > 6) {
const auto num_args_id = inst->GetOperandAs<uint32_t>(6);
if (!IsUint32Constant(_, num_args_id)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "NumArguments must be a 32-bit unsigned integer OpConstant";
}
}
if (num_operands > 7) {
const auto flags_id = inst->GetOperandAs<uint32_t>(7);
if (!IsUint32Constant(_, flags_id)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Flags must be a 32-bit unsigned integer OpConstant";
}
}
if (num_operands > 8) {
const auto atts_id = inst->GetOperandAs<uint32_t>(8);
if (_.GetIdOpcode(atts_id) != spv::Op::OpString) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Attributes must be an OpString";
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionArgumentInfo(ValidationState_t& _,
const Instruction* inst) {
const auto num_operands = inst->operands().size();
if (_.GetIdOpcode(inst->GetOperandAs<uint32_t>(4)) != spv::Op::OpString) {
return _.diag(SPV_ERROR_INVALID_ID, inst) << "Name must be an OpString";
}
if (num_operands > 5) {
if (_.GetIdOpcode(inst->GetOperandAs<uint32_t>(5)) != spv::Op::OpString) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "TypeName must be an OpString";
}
}
if (num_operands > 6) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "AddressQualifier must be a 32-bit unsigned integer "
"OpConstant";
}
}
if (num_operands > 7) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(7))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "AccessQualifier must be a 32-bit unsigned integer "
"OpConstant";
}
}
if (num_operands > 8) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(8))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "TypeQualifier must be a 32-bit unsigned integer "
"OpConstant";
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateKernelDecl(ValidationState_t& _, const Instruction* inst) {
const auto decl_id = inst->GetOperandAs<uint32_t>(4);
const auto decl = _.FindDef(decl_id);
if (!decl || decl->opcode() != spv::Op::OpExtInst) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Kernel must be a Kernel extended instruction";
}
if (decl->GetOperandAs<uint32_t>(2) != inst->GetOperandAs<uint32_t>(2)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Kernel must be from the same extended instruction import";
}
const auto ext_inst =
decl->GetOperandAs<NonSemanticClspvReflectionInstructions>(3);
if (ext_inst != NonSemanticClspvReflectionKernel) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Kernel must be a Kernel extended instruction";
}
return SPV_SUCCESS;
}
spv_result_t ValidateArgInfo(ValidationState_t& _, const Instruction* inst,
uint32_t info_index) {
auto info = _.FindDef(inst->GetOperandAs<uint32_t>(info_index));
if (!info || info->opcode() != spv::Op::OpExtInst) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "ArgInfo must be an ArgumentInfo extended instruction";
}
if (info->GetOperandAs<uint32_t>(2) != inst->GetOperandAs<uint32_t>(2)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "ArgInfo must be from the same extended instruction import";
}
auto ext_inst = info->GetOperandAs<NonSemanticClspvReflectionInstructions>(3);
if (ext_inst != NonSemanticClspvReflectionArgumentInfo) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "ArgInfo must be an ArgumentInfo extended instruction";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionArgumentBuffer(ValidationState_t& _,
const Instruction* inst) {
const auto num_operands = inst->operands().size();
if (auto error = ValidateKernelDecl(_, inst)) {
return error;
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Ordinal must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "DescriptorSet must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(7))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Binding must be a 32-bit unsigned integer OpConstant";
}
if (num_operands == 9) {
if (auto error = ValidateArgInfo(_, inst, 8)) {
return error;
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionArgumentOffsetBuffer(ValidationState_t& _,
const Instruction* inst) {
const auto num_operands = inst->operands().size();
if (auto error = ValidateKernelDecl(_, inst)) {
return error;
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Ordinal must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "DescriptorSet must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(7))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Binding must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(8))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Offset must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(9))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Size must be a 32-bit unsigned integer OpConstant";
}
if (num_operands == 11) {
if (auto error = ValidateArgInfo(_, inst, 10)) {
return error;
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionArgumentPushConstant(
ValidationState_t& _, const Instruction* inst) {
const auto num_operands = inst->operands().size();
if (auto error = ValidateKernelDecl(_, inst)) {
return error;
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Ordinal must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Offset must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(7))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Size must be a 32-bit unsigned integer OpConstant";
}
if (num_operands == 9) {
if (auto error = ValidateArgInfo(_, inst, 8)) {
return error;
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionArgumentWorkgroup(ValidationState_t& _,
const Instruction* inst) {
const auto num_operands = inst->operands().size();
if (auto error = ValidateKernelDecl(_, inst)) {
return error;
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Ordinal must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "SpecId must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(7))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "ElemSize must be a 32-bit unsigned integer OpConstant";
}
if (num_operands == 9) {
if (auto error = ValidateArgInfo(_, inst, 8)) {
return error;
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionSpecConstantTriple(
ValidationState_t& _, const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "X must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Y must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Z must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionSpecConstantWorkDim(
ValidationState_t& _, const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Dim must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionPushConstant(ValidationState_t& _,
const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Offset must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Size must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionInitializedData(ValidationState_t& _,
const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "DescriptorSet must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Binding must be a 32-bit unsigned integer OpConstant";
}
if (_.GetIdOpcode(inst->GetOperandAs<uint32_t>(6)) != spv::Op::OpString) {
return _.diag(SPV_ERROR_INVALID_ID, inst) << "Data must be an OpString";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionSampler(ValidationState_t& _,
const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "DescriptorSet must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Binding must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Mask must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionPropertyRequiredWorkgroupSize(
ValidationState_t& _, const Instruction* inst) {
if (auto error = ValidateKernelDecl(_, inst)) {
return error;
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "X must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Y must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(7))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Z must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionSubgroupMaxSize(ValidationState_t& _,
const Instruction* inst) {
const auto size_id = inst->GetOperandAs<uint32_t>(4);
if (!IsUint32Constant(_, size_id)) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Size must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionPointerRelocation(ValidationState_t& _,
const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "ObjectOffset must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "PointerOffset must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "PointerSize must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionImageMetadataPushConstant(
ValidationState_t& _, const Instruction* inst) {
if (auto error = ValidateKernelDecl(_, inst)) {
return error;
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Ordinal must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Offset must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(7))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Size must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionImageMetadataUniform(
ValidationState_t& _, const Instruction* inst) {
if (auto error = ValidateKernelDecl(_, inst)) {
return error;
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Ordinal must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "DescriptorSet must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(7))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Binding must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(8))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Offset must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(9))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Size must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionPushConstantData(ValidationState_t& _,
const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Offset must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Size must be a 32-bit unsigned integer OpConstant";
}
if (_.GetIdOpcode(inst->GetOperandAs<uint32_t>(6)) != spv::Op::OpString) {
return _.diag(SPV_ERROR_INVALID_ID, inst) << "Data must be an OpString";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionPrintfInfo(ValidationState_t& _,
const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "PrintfID must be a 32-bit unsigned integer OpConstant";
}
if (_.GetIdOpcode(inst->GetOperandAs<uint32_t>(5)) != spv::Op::OpString) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "FormatString must be an OpString";
}
for (size_t i = 6; i < inst->operands().size(); ++i) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(i))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "ArgumentSizes must be a 32-bit unsigned integer OpConstant";
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionPrintfStorageBuffer(ValidationState_t& _,
const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "DescriptorSet must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Binding must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Size must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionPrintfPushConstant(ValidationState_t& _,
const Instruction* inst) {
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(4))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Offset must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(5))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Size must be a 32-bit unsigned integer OpConstant";
}
if (!IsUint32Constant(_, inst->GetOperandAs<uint32_t>(6))) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "BufferSize must be a 32-bit unsigned integer OpConstant";
}
return SPV_SUCCESS;
}
spv_result_t ValidateClspvReflectionInstruction(ValidationState_t& _,
const Instruction* inst,
uint32_t version) {
if (!_.IsVoidType(inst->type_id())) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< "Return Type must be OpTypeVoid";
}
uint32_t required_version = 0;
const auto ext_inst =
inst->GetOperandAs<NonSemanticClspvReflectionInstructions>(3);
switch (ext_inst) {
case NonSemanticClspvReflectionKernel:
case NonSemanticClspvReflectionArgumentInfo:
case NonSemanticClspvReflectionArgumentStorageBuffer:
case NonSemanticClspvReflectionArgumentUniform:
case NonSemanticClspvReflectionArgumentPodStorageBuffer:
case NonSemanticClspvReflectionArgumentPodUniform:
case NonSemanticClspvReflectionArgumentPodPushConstant:
case NonSemanticClspvReflectionArgumentSampledImage:
case NonSemanticClspvReflectionArgumentStorageImage:
case NonSemanticClspvReflectionArgumentSampler:
case NonSemanticClspvReflectionArgumentWorkgroup:
case NonSemanticClspvReflectionSpecConstantWorkgroupSize:
case NonSemanticClspvReflectionSpecConstantGlobalOffset:
case NonSemanticClspvReflectionSpecConstantWorkDim:
case NonSemanticClspvReflectionPushConstantGlobalOffset:
case NonSemanticClspvReflectionPushConstantEnqueuedLocalSize:
case NonSemanticClspvReflectionPushConstantGlobalSize:
case NonSemanticClspvReflectionPushConstantRegionOffset:
case NonSemanticClspvReflectionPushConstantNumWorkgroups:
case NonSemanticClspvReflectionPushConstantRegionGroupOffset:
case NonSemanticClspvReflectionConstantDataStorageBuffer:
case NonSemanticClspvReflectionConstantDataUniform:
case NonSemanticClspvReflectionLiteralSampler:
case NonSemanticClspvReflectionPropertyRequiredWorkgroupSize:
required_version = 1;
break;
case NonSemanticClspvReflectionSpecConstantSubgroupMaxSize:
required_version = 2;
break;
case NonSemanticClspvReflectionArgumentPointerPushConstant:
case NonSemanticClspvReflectionArgumentPointerUniform:
case NonSemanticClspvReflectionProgramScopeVariablesStorageBuffer:
case NonSemanticClspvReflectionProgramScopeVariablePointerRelocation:
case NonSemanticClspvReflectionImageArgumentInfoChannelOrderPushConstant:
case NonSemanticClspvReflectionImageArgumentInfoChannelDataTypePushConstant:
case NonSemanticClspvReflectionImageArgumentInfoChannelOrderUniform:
case NonSemanticClspvReflectionImageArgumentInfoChannelDataTypeUniform:
required_version = 3;
break;
case NonSemanticClspvReflectionArgumentStorageTexelBuffer:
case NonSemanticClspvReflectionArgumentUniformTexelBuffer:
required_version = 4;
break;
case NonSemanticClspvReflectionConstantDataPointerPushConstant:
case NonSemanticClspvReflectionProgramScopeVariablePointerPushConstant:
case NonSemanticClspvReflectionPrintfInfo:
case NonSemanticClspvReflectionPrintfBufferStorageBuffer:
case NonSemanticClspvReflectionPrintfBufferPointerPushConstant:
required_version = 5;
break;
default:
break;
}
if (version < required_version) {
return _.diag(SPV_ERROR_INVALID_ID, inst)
<< ReflectionInstructionName(_, inst) << " requires version "
<< required_version << ", but parsed version is " << version;
}
switch (ext_inst) {
case NonSemanticClspvReflectionKernel:
return ValidateClspvReflectionKernel(_, inst, version);
case NonSemanticClspvReflectionArgumentInfo:
return ValidateClspvReflectionArgumentInfo(_, inst);
case NonSemanticClspvReflectionArgumentStorageBuffer:
case NonSemanticClspvReflectionArgumentUniform:
case NonSemanticClspvReflectionArgumentSampledImage:
case NonSemanticClspvReflectionArgumentStorageImage:
case NonSemanticClspvReflectionArgumentSampler:
case NonSemanticClspvReflectionArgumentStorageTexelBuffer:
case NonSemanticClspvReflectionArgumentUniformTexelBuffer:
return ValidateClspvReflectionArgumentBuffer(_, inst);
case NonSemanticClspvReflectionArgumentPodStorageBuffer:
case NonSemanticClspvReflectionArgumentPodUniform:
case NonSemanticClspvReflectionArgumentPointerUniform:
return ValidateClspvReflectionArgumentOffsetBuffer(_, inst);
case NonSemanticClspvReflectionArgumentPodPushConstant:
case NonSemanticClspvReflectionArgumentPointerPushConstant:
return ValidateClspvReflectionArgumentPushConstant(_, inst);
case NonSemanticClspvReflectionArgumentWorkgroup:
return ValidateClspvReflectionArgumentWorkgroup(_, inst);
case NonSemanticClspvReflectionSpecConstantWorkgroupSize:
case NonSemanticClspvReflectionSpecConstantGlobalOffset:
return ValidateClspvReflectionSpecConstantTriple(_, inst);
case NonSemanticClspvReflectionSpecConstantWorkDim:
return ValidateClspvReflectionSpecConstantWorkDim(_, inst);
case NonSemanticClspvReflectionPushConstantGlobalOffset:
case NonSemanticClspvReflectionPushConstantEnqueuedLocalSize:
case NonSemanticClspvReflectionPushConstantGlobalSize:
case NonSemanticClspvReflectionPushConstantRegionOffset:
case NonSemanticClspvReflectionPushConstantNumWorkgroups:
case NonSemanticClspvReflectionPushConstantRegionGroupOffset:
return ValidateClspvReflectionPushConstant(_, inst);
case NonSemanticClspvReflectionConstantDataStorageBuffer:
case NonSemanticClspvReflectionConstantDataUniform:
case NonSemanticClspvReflectionProgramScopeVariablesStorageBuffer:
return ValidateClspvReflectionInitializedData(_, inst);
case NonSemanticClspvReflectionLiteralSampler:
return ValidateClspvReflectionSampler(_, inst);
case NonSemanticClspvReflectionPropertyRequiredWorkgroupSize:
return ValidateClspvReflectionPropertyRequiredWorkgroupSize(_, inst);
case NonSemanticClspvReflectionSpecConstantSubgroupMaxSize:
return ValidateClspvReflectionSubgroupMaxSize(_, inst);
case NonSemanticClspvReflectionProgramScopeVariablePointerRelocation:
return ValidateClspvReflectionPointerRelocation(_, inst);
case NonSemanticClspvReflectionImageArgumentInfoChannelOrderPushConstant:
case NonSemanticClspvReflectionImageArgumentInfoChannelDataTypePushConstant:
return ValidateClspvReflectionImageMetadataPushConstant(_, inst);
case NonSemanticClspvReflectionImageArgumentInfoChannelOrderUniform:
case NonSemanticClspvReflectionImageArgumentInfoChannelDataTypeUniform:
return ValidateClspvReflectionImageMetadataUniform(_, inst);
case NonSemanticClspvReflectionConstantDataPointerPushConstant:
case NonSemanticClspvReflectionProgramScopeVariablePointerPushConstant:
return ValidateClspvReflectionPushConstantData(_, inst);
case NonSemanticClspvReflectionPrintfInfo:
return ValidateClspvReflectionPrintfInfo(_, inst);
case NonSemanticClspvReflectionPrintfBufferStorageBuffer:
return ValidateClspvReflectionPrintfStorageBuffer(_, inst);
case NonSemanticClspvReflectionPrintfBufferPointerPushConstant:
return ValidateClspvReflectionPrintfPushConstant(_, inst);
default:
break;
}
return SPV_SUCCESS;
}
bool IsConstIntScalarTypeWith32Or64Bits(ValidationState_t& _,
Instruction* instr) {
if (instr->opcode() != spv::Op::OpConstant) return false;
if (!_.IsIntScalarType(instr->type_id())) return false;
uint32_t size_in_bits = _.GetBitWidth(instr->type_id());
return size_in_bits == 32 || size_in_bits == 64;
}
bool IsConstWithIntScalarType(ValidationState_t& _, const Instruction* inst,
uint32_t word_index) {
auto* int_scalar_const = _.FindDef(inst->word(word_index));
if (int_scalar_const->opcode() == spv::Op::OpConstant &&
_.IsIntScalarType(int_scalar_const->type_id())) {
return true;
}
return false;
}
bool IsDebugVariableWithIntScalarType(ValidationState_t& _,
const Instruction* inst,
uint32_t word_index) {
auto* dbg_int_scalar_var = _.FindDef(inst->word(word_index));
if (CommonDebugInfoInstructions(dbg_int_scalar_var->word(4)) ==
CommonDebugInfoDebugLocalVariable ||
CommonDebugInfoInstructions(dbg_int_scalar_var->word(4)) ==
CommonDebugInfoDebugGlobalVariable) {
auto* dbg_type = _.FindDef(dbg_int_scalar_var->word(6));
if (CommonDebugInfoInstructions(dbg_type->word(4)) ==
CommonDebugInfoDebugTypeBasic) {
const spv_ext_inst_type_t ext_inst_type =
spv_ext_inst_type_t(inst->ext_inst_type());
const bool vulkanDebugInfo =
ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100;
uint32_t encoding = dbg_type->word(7);
if (!vulkanDebugInfo || IsUint32Constant(_, encoding)) {
auto ocl_encoding = OpenCLDebugInfo100DebugBaseTypeAttributeEncoding(
vulkanDebugInfo ? GetUint32Constant(_, encoding) : encoding);
if (ocl_encoding == OpenCLDebugInfo100Signed ||
ocl_encoding == OpenCLDebugInfo100Unsigned) {
return true;
}
}
}
}
return false;
}
} // anonymous namespace
spv_result_t ValidateExtension(ValidationState_t& _, const Instruction* inst) {
if (_.version() < SPV_SPIRV_VERSION_WORD(1, 4)) {
std::string extension = GetExtensionString(&(inst->c_inst()));
if (extension ==
ExtensionToString(kSPV_KHR_workgroup_memory_explicit_layout) ||
extension == ExtensionToString(kSPV_EXT_mesh_shader) ||
extension == ExtensionToString(kSPV_NV_shader_invocation_reorder)) {
return _.diag(SPV_ERROR_WRONG_VERSION, inst)
<< extension << " extension requires SPIR-V version 1.4 or later.";
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateExtInstImport(ValidationState_t& _,
const Instruction* inst) {
const auto name_id = 1;
if (_.version() <= SPV_SPIRV_VERSION_WORD(1, 5) &&
!_.HasExtension(kSPV_KHR_non_semantic_info)) {
const std::string name = inst->GetOperandAs<std::string>(name_id);
if (name.find("NonSemantic.") == 0) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "NonSemantic extended instruction sets cannot be declared "
"without SPV_KHR_non_semantic_info.";
}
}
return SPV_SUCCESS;
}
spv_result_t ValidateExtInst(ValidationState_t& _, const Instruction* inst) {
const uint32_t result_type = inst->type_id();
const uint32_t num_operands = static_cast<uint32_t>(inst->operands().size());
const uint32_t ext_inst_set = inst->word(3);
const uint32_t ext_inst_index = inst->word(4);
const spv_ext_inst_type_t ext_inst_type =
spv_ext_inst_type_t(inst->ext_inst_type());
auto ext_inst_name = [&_, ext_inst_set, ext_inst_type, ext_inst_index]() {
spv_ext_inst_desc desc = nullptr;
if (_.grammar().lookupExtInst(ext_inst_type, ext_inst_index, &desc) !=
SPV_SUCCESS ||
!desc) {
return std::string("Unknown ExtInst");
}
auto* import_inst = _.FindDef(ext_inst_set);
assert(import_inst);
std::ostringstream ss;
ss << import_inst->GetOperandAs<std::string>(1);
ss << " ";
ss << desc->name;
return ss.str();
};
if (ext_inst_type == SPV_EXT_INST_TYPE_GLSL_STD_450) {
const GLSLstd450 ext_inst_key = GLSLstd450(ext_inst_index);
switch (ext_inst_key) {
case GLSLstd450Round:
case GLSLstd450RoundEven:
case GLSLstd450FAbs:
case GLSLstd450Trunc:
case GLSLstd450FSign:
case GLSLstd450Floor:
case GLSLstd450Ceil:
case GLSLstd450Fract:
case GLSLstd450Sqrt:
case GLSLstd450InverseSqrt:
case GLSLstd450FMin:
case GLSLstd450FMax:
case GLSLstd450FClamp:
case GLSLstd450FMix:
case GLSLstd450Step:
case GLSLstd450SmoothStep:
case GLSLstd450Fma:
case GLSLstd450Normalize:
case GLSLstd450FaceForward:
case GLSLstd450Reflect:
case GLSLstd450NMin:
case GLSLstd450NMax:
case GLSLstd450NClamp: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar or vector type";
}
for (uint32_t operand_index = 4; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (result_type != operand_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected types of all operands to be equal to Result "
"Type";
}
}
break;
}
case GLSLstd450SAbs:
case GLSLstd450SSign:
case GLSLstd450UMin:
case GLSLstd450SMin:
case GLSLstd450UMax:
case GLSLstd450SMax:
case GLSLstd450UClamp:
case GLSLstd450SClamp:
case GLSLstd450FindILsb:
case GLSLstd450FindUMsb:
case GLSLstd450FindSMsb: {
if (!_.IsIntScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be an int scalar or vector type";
}
const uint32_t result_type_bit_width = _.GetBitWidth(result_type);
const uint32_t result_type_dimension = _.GetDimension(result_type);
for (uint32_t operand_index = 4; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (!operand_type || !_.IsIntScalarOrVectorType(operand_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected all operands to be int scalars or vectors";
}
if (result_type_dimension != _.GetDimension(operand_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected all operands to have the same dimension as "
<< "Result Type";
}
if (result_type_bit_width != _.GetBitWidth(operand_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected all operands to have the same bit width as "
<< "Result Type";
}
if (ext_inst_key == GLSLstd450FindUMsb ||
ext_inst_key == GLSLstd450FindSMsb) {
if (result_type_bit_width != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "this instruction is currently limited to 32-bit width "
<< "components";
}
}
}
break;
}
case GLSLstd450Radians:
case GLSLstd450Degrees:
case GLSLstd450Sin:
case GLSLstd450Cos:
case GLSLstd450Tan:
case GLSLstd450Asin:
case GLSLstd450Acos:
case GLSLstd450Atan:
case GLSLstd450Sinh:
case GLSLstd450Cosh:
case GLSLstd450Tanh:
case GLSLstd450Asinh:
case GLSLstd450Acosh:
case GLSLstd450Atanh:
case GLSLstd450Exp:
case GLSLstd450Exp2:
case GLSLstd450Log:
case GLSLstd450Log2:
case GLSLstd450Atan2:
case GLSLstd450Pow: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a 16 or 32-bit scalar or "
"vector float type";
}
const uint32_t result_type_bit_width = _.GetBitWidth(result_type);
if (result_type_bit_width != 16 && result_type_bit_width != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a 16 or 32-bit scalar or "
"vector float type";
}
for (uint32_t operand_index = 4; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (result_type != operand_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected types of all operands to be equal to Result "
"Type";
}
}
break;
}
case GLSLstd450Determinant: {
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
uint32_t num_rows = 0;
uint32_t num_cols = 0;
uint32_t col_type = 0;
uint32_t component_type = 0;
if (!_.GetMatrixTypeInfo(x_type, &num_rows, &num_cols, &col_type,
&component_type) ||
num_rows != num_cols) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X to be a square matrix";
}
if (result_type != component_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X component type to be equal to "
<< "Result Type";
}
break;
}
case GLSLstd450MatrixInverse: {
uint32_t num_rows = 0;
uint32_t num_cols = 0;
uint32_t col_type = 0;
uint32_t component_type = 0;
if (!_.GetMatrixTypeInfo(result_type, &num_rows, &num_cols, &col_type,
&component_type) ||
num_rows != num_cols) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a square matrix";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
if (result_type != x_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X type to be equal to Result Type";
}
break;
}
case GLSLstd450Modf: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or vector float type";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
const uint32_t i_type = _.GetOperandTypeId(inst, 5);
if (x_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X type to be equal to Result Type";
}
spv::StorageClass i_storage_class;
uint32_t i_data_type = 0;
if (!_.GetPointerTypeInfo(i_type, &i_data_type, &i_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand I to be a pointer";
}
if (i_data_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand I data type to be equal to Result Type";
}
break;
}
case GLSLstd450ModfStruct: {
std::vector<uint32_t> result_types;
if (!_.GetStructMemberTypes(result_type, &result_types) ||
result_types.size() != 2 ||
!_.IsFloatScalarOrVectorType(result_types[0]) ||
result_types[1] != result_types[0]) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a struct with two identical "
<< "scalar or vector float type members";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
if (x_type != result_types[0]) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X type to be equal to members of "
<< "Result Type struct";
}
break;
}
case GLSLstd450Frexp: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or vector float type";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
const uint32_t exp_type = _.GetOperandTypeId(inst, 5);
if (x_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X type to be equal to Result Type";
}
spv::StorageClass exp_storage_class;
uint32_t exp_data_type = 0;
if (!_.GetPointerTypeInfo(exp_type, &exp_data_type,
&exp_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Exp to be a pointer";
}
if (!_.IsIntScalarOrVectorType(exp_data_type) ||
(!_.HasExtension(kSPV_AMD_gpu_shader_int16) &&
_.GetBitWidth(exp_data_type) != 32) ||
(_.HasExtension(kSPV_AMD_gpu_shader_int16) &&
_.GetBitWidth(exp_data_type) != 16 &&
_.GetBitWidth(exp_data_type) != 32)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Exp data type to be a "
<< (_.HasExtension(kSPV_AMD_gpu_shader_int16)
? "16-bit or 32-bit "
: "32-bit ")
<< "int scalar or vector type";
}
if (_.GetDimension(result_type) != _.GetDimension(exp_data_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Exp data type to have the same component "
<< "number as Result Type";
}
break;
}
case GLSLstd450Ldexp: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or vector float type";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
const uint32_t exp_type = _.GetOperandTypeId(inst, 5);
if (x_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X type to be equal to Result Type";
}
if (!_.IsIntScalarOrVectorType(exp_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Exp to be a 32-bit int scalar "
<< "or vector type";
}
if (_.GetDimension(result_type) != _.GetDimension(exp_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Exp to have the same component "
<< "number as Result Type";
}
break;
}
case GLSLstd450FrexpStruct: {
std::vector<uint32_t> result_types;
if (!_.GetStructMemberTypes(result_type, &result_types) ||
result_types.size() != 2 ||
!_.IsFloatScalarOrVectorType(result_types[0]) ||
!_.IsIntScalarOrVectorType(result_types[1]) ||
(!_.HasExtension(kSPV_AMD_gpu_shader_int16) &&
_.GetBitWidth(result_types[1]) != 32) ||
(_.HasExtension(kSPV_AMD_gpu_shader_int16) &&
_.GetBitWidth(result_types[1]) != 16 &&
_.GetBitWidth(result_types[1]) != 32) ||
_.GetDimension(result_types[0]) !=
_.GetDimension(result_types[1])) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a struct with two members, "
<< "first member a float scalar or vector, second member a "
<< (_.HasExtension(kSPV_AMD_gpu_shader_int16)
? "16-bit or 32-bit "
: "32-bit ")
<< "int scalar or vector with the same number of "
<< "components as the first member";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
if (x_type != result_types[0]) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X type to be equal to the first member "
<< "of Result Type struct";
}
break;
}
case GLSLstd450PackSnorm4x8:
case GLSLstd450PackUnorm4x8: {
if (!_.IsIntScalarType(result_type) ||
_.GetBitWidth(result_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be 32-bit int scalar type";
}
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 4 ||
_.GetBitWidth(v_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand V to be a 32-bit float vector of size 4";
}
break;
}
case GLSLstd450PackSnorm2x16:
case GLSLstd450PackUnorm2x16:
case GLSLstd450PackHalf2x16: {
if (!_.IsIntScalarType(result_type) ||
_.GetBitWidth(result_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be 32-bit int scalar type";
}
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 2 ||
_.GetBitWidth(v_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand V to be a 32-bit float vector of size 2";
}
break;
}
case GLSLstd450PackDouble2x32: {
if (!_.IsFloatScalarType(result_type) ||
_.GetBitWidth(result_type) != 64) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be 64-bit float scalar type";
}
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
if (!_.IsIntVectorType(v_type) || _.GetDimension(v_type) != 2 ||
_.GetBitWidth(v_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand V to be a 32-bit int vector of size 2";
}
break;
}
case GLSLstd450UnpackSnorm4x8:
case GLSLstd450UnpackUnorm4x8: {
if (!_.IsFloatVectorType(result_type) ||
_.GetDimension(result_type) != 4 ||
_.GetBitWidth(result_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a 32-bit float vector of size "
"4";
}
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P to be a 32-bit int scalar";
}
break;
}
case GLSLstd450UnpackSnorm2x16:
case GLSLstd450UnpackUnorm2x16:
case GLSLstd450UnpackHalf2x16: {
if (!_.IsFloatVectorType(result_type) ||
_.GetDimension(result_type) != 2 ||
_.GetBitWidth(result_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a 32-bit float vector of size "
"2";
}
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P to be a 32-bit int scalar";
}
break;
}
case GLSLstd450UnpackDouble2x32: {
if (!_.IsIntVectorType(result_type) ||
_.GetDimension(result_type) != 2 ||
_.GetBitWidth(result_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a 32-bit int vector of size "
"2";
}
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
if (!_.IsFloatScalarType(v_type) || _.GetBitWidth(v_type) != 64) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand V to be a 64-bit float scalar";
}
break;
}
case GLSLstd450Length: {
if (!_.IsFloatScalarType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar type";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
if (!_.IsFloatScalarOrVectorType(x_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X to be of float scalar or vector type";
}
if (result_type != _.GetComponentType(x_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X component type to be equal to Result "
"Type";
}
break;
}
case GLSLstd450Distance: {
if (!_.IsFloatScalarType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar type";
}
const uint32_t p0_type = _.GetOperandTypeId(inst, 4);
if (!_.IsFloatScalarOrVectorType(p0_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P0 to be of float scalar or vector type";
}
if (result_type != _.GetComponentType(p0_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P0 component type to be equal to "
<< "Result Type";
}
const uint32_t p1_type = _.GetOperandTypeId(inst, 5);
if (!_.IsFloatScalarOrVectorType(p1_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P1 to be of float scalar or vector type";
}
if (result_type != _.GetComponentType(p1_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P1 component type to be equal to "
<< "Result Type";
}
if (_.GetDimension(p0_type) != _.GetDimension(p1_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operands P0 and P1 to have the same number of "
<< "components";
}
break;
}
case GLSLstd450Cross: {
if (!_.IsFloatVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float vector type";
}
if (_.GetDimension(result_type) != 3) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to have 3 components";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
const uint32_t y_type = _.GetOperandTypeId(inst, 5);
if (x_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X type to be equal to Result Type";
}
if (y_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Y type to be equal to Result Type";
}
break;
}
case GLSLstd450Refract: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar or vector type";
}
const uint32_t i_type = _.GetOperandTypeId(inst, 4);
const uint32_t n_type = _.GetOperandTypeId(inst, 5);
const uint32_t eta_type = _.GetOperandTypeId(inst, 6);
if (result_type != i_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand I to be of type equal to Result Type";
}
if (result_type != n_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand N to be of type equal to Result Type";
}
if (!_.IsFloatScalarType(eta_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Eta to be a float scalar";
}
break;
}
case GLSLstd450InterpolateAtCentroid:
case GLSLstd450InterpolateAtSample:
case GLSLstd450InterpolateAtOffset: {
if (!_.HasCapability(spv::Capability::InterpolationFunction)) {
return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst)
<< ext_inst_name()
<< " requires capability InterpolationFunction";
}
if (!_.IsFloatScalarOrVectorType(result_type) ||
_.GetBitWidth(result_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a 32-bit float scalar "
<< "or vector type";
}
// If HLSL legalization and first operand is an OpLoad, use load
// pointer as the interpolant lvalue. Else use interpolate first
// operand.
uint32_t interp_id = inst->GetOperandAs<uint32_t>(4);
auto* interp_inst = _.FindDef(interp_id);
uint32_t interpolant_type = (_.options()->before_hlsl_legalization &&
interp_inst->opcode() == spv::Op::OpLoad)
? _.GetOperandTypeId(interp_inst, 2)
: _.GetOperandTypeId(inst, 4);
spv::StorageClass interpolant_storage_class;
uint32_t interpolant_data_type = 0;
if (!_.GetPointerTypeInfo(interpolant_type, &interpolant_data_type,
&interpolant_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Interpolant to be a pointer";
}
if (result_type != interpolant_data_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Interpolant data type to be equal to Result Type";
}
if (interpolant_storage_class != spv::StorageClass::Input) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Interpolant storage class to be Input";
}
if (ext_inst_key == GLSLstd450InterpolateAtSample) {
const uint32_t sample_type = _.GetOperandTypeId(inst, 5);
if (!_.IsIntScalarType(sample_type) ||
_.GetBitWidth(sample_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Sample to be 32-bit integer";
}
}
if (ext_inst_key == GLSLstd450InterpolateAtOffset) {
const uint32_t offset_type = _.GetOperandTypeId(inst, 5);
if (!_.IsFloatVectorType(offset_type) ||
_.GetDimension(offset_type) != 2 ||
_.GetBitWidth(offset_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Offset to be a vector of 2 32-bit floats";
}
}
_.function(inst->function()->id())
->RegisterExecutionModelLimitation(
spv::ExecutionModel::Fragment,
ext_inst_name() +
std::string(" requires Fragment execution model"));
break;
}
case GLSLstd450IMix: {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Extended instruction GLSLstd450IMix is not supported";
}
case GLSLstd450Bad: {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< "Encountered extended instruction GLSLstd450Bad";
}
case GLSLstd450Count: {
assert(0);
break;
}
}
} else if (ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_STD) {
const OpenCLLIB::Entrypoints ext_inst_key =
OpenCLLIB::Entrypoints(ext_inst_index);
switch (ext_inst_key) {
case OpenCLLIB::Acos:
case OpenCLLIB::Acosh:
case OpenCLLIB::Acospi:
case OpenCLLIB::Asin:
case OpenCLLIB::Asinh:
case OpenCLLIB::Asinpi:
case OpenCLLIB::Atan:
case OpenCLLIB::Atan2:
case OpenCLLIB::Atanh:
case OpenCLLIB::Atanpi:
case OpenCLLIB::Atan2pi:
case OpenCLLIB::Cbrt:
case OpenCLLIB::Ceil:
case OpenCLLIB::Copysign:
case OpenCLLIB::Cos:
case OpenCLLIB::Cosh:
case OpenCLLIB::Cospi:
case OpenCLLIB::Erfc:
case OpenCLLIB::Erf:
case OpenCLLIB::Exp:
case OpenCLLIB::Exp2:
case OpenCLLIB::Exp10:
case OpenCLLIB::Expm1:
case OpenCLLIB::Fabs:
case OpenCLLIB::Fdim:
case OpenCLLIB::Floor:
case OpenCLLIB::Fma:
case OpenCLLIB::Fmax:
case OpenCLLIB::Fmin:
case OpenCLLIB::Fmod:
case OpenCLLIB::Hypot:
case OpenCLLIB::Lgamma:
case OpenCLLIB::Log:
case OpenCLLIB::Log2:
case OpenCLLIB::Log10:
case OpenCLLIB::Log1p:
case OpenCLLIB::Logb:
case OpenCLLIB::Mad:
case OpenCLLIB::Maxmag:
case OpenCLLIB::Minmag:
case OpenCLLIB::Nextafter:
case OpenCLLIB::Pow:
case OpenCLLIB::Powr:
case OpenCLLIB::Remainder:
case OpenCLLIB::Rint:
case OpenCLLIB::Round:
case OpenCLLIB::Rsqrt:
case OpenCLLIB::Sin:
case OpenCLLIB::Sinh:
case OpenCLLIB::Sinpi:
case OpenCLLIB::Sqrt:
case OpenCLLIB::Tan:
case OpenCLLIB::Tanh:
case OpenCLLIB::Tanpi:
case OpenCLLIB::Tgamma:
case OpenCLLIB::Trunc:
case OpenCLLIB::Half_cos:
case OpenCLLIB::Half_divide:
case OpenCLLIB::Half_exp:
case OpenCLLIB::Half_exp2:
case OpenCLLIB::Half_exp10:
case OpenCLLIB::Half_log:
case OpenCLLIB::Half_log2:
case OpenCLLIB::Half_log10:
case OpenCLLIB::Half_powr:
case OpenCLLIB::Half_recip:
case OpenCLLIB::Half_rsqrt:
case OpenCLLIB::Half_sin:
case OpenCLLIB::Half_sqrt:
case OpenCLLIB::Half_tan:
case OpenCLLIB::Native_cos:
case OpenCLLIB::Native_divide:
case OpenCLLIB::Native_exp:
case OpenCLLIB::Native_exp2:
case OpenCLLIB::Native_exp10:
case OpenCLLIB::Native_log:
case OpenCLLIB::Native_log2:
case OpenCLLIB::Native_log10:
case OpenCLLIB::Native_powr:
case OpenCLLIB::Native_recip:
case OpenCLLIB::Native_rsqrt:
case OpenCLLIB::Native_sin:
case OpenCLLIB::Native_sqrt:
case OpenCLLIB::Native_tan:
case OpenCLLIB::FClamp:
case OpenCLLIB::Degrees:
case OpenCLLIB::FMax_common:
case OpenCLLIB::FMin_common:
case OpenCLLIB::Mix:
case OpenCLLIB::Radians:
case OpenCLLIB::Step:
case OpenCLLIB::Smoothstep:
case OpenCLLIB::Sign: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar or vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
for (uint32_t operand_index = 4; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (result_type != operand_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected types of all operands to be equal to Result "
"Type";
}
}
break;
}
case OpenCLLIB::Fract:
case OpenCLLIB::Modf:
case OpenCLLIB::Sincos: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar or vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
if (result_type != x_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected type of operand X to be equal to Result Type";
}
const uint32_t p_type = _.GetOperandTypeId(inst, 5);
spv::StorageClass p_storage_class;
uint32_t p_data_type = 0;
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected the last operand to be a pointer";
}
if (p_storage_class != spv::StorageClass::Generic &&
p_storage_class != spv::StorageClass::CrossWorkgroup &&
p_storage_class != spv::StorageClass::Workgroup &&
p_storage_class != spv::StorageClass::Function) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected storage class of the pointer to be Generic, "
"CrossWorkgroup, Workgroup or Function";
}
if (result_type != p_data_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected data type of the pointer to be equal to Result "
"Type";
}
break;
}
case OpenCLLIB::Frexp:
case OpenCLLIB::Lgamma_r:
case OpenCLLIB::Remquo: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar or vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
uint32_t operand_index = 4;
const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++);
if (result_type != x_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected type of operand X to be equal to Result Type";
}
if (ext_inst_key == OpenCLLIB::Remquo) {
const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++);
if (result_type != y_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected type of operand Y to be equal to Result Type";
}
}
const uint32_t p_type = _.GetOperandTypeId(inst, operand_index++);
spv::StorageClass p_storage_class;
uint32_t p_data_type = 0;
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected the last operand to be a pointer";
}
if (p_storage_class != spv::StorageClass::Generic &&
p_storage_class != spv::StorageClass::CrossWorkgroup &&
p_storage_class != spv::StorageClass::Workgroup &&
p_storage_class != spv::StorageClass::Function) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected storage class of the pointer to be Generic, "
"CrossWorkgroup, Workgroup or Function";
}
if (!_.IsIntScalarOrVectorType(p_data_type) ||
_.GetBitWidth(p_data_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected data type of the pointer to be a 32-bit int "
"scalar or vector type";
}
if (_.GetDimension(p_data_type) != num_components) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected data type of the pointer to have the same number "
"of components as Result Type";
}
break;
}
case OpenCLLIB::Ilogb: {
if (!_.IsIntScalarOrVectorType(result_type) ||
_.GetBitWidth(result_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a 32-bit int scalar or vector "
"type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
if (!_.IsFloatScalarOrVectorType(x_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X to be a float scalar or vector";
}
if (_.GetDimension(x_type) != num_components) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X to have the same number of components "
"as Result Type";
}
break;
}
case OpenCLLIB::Ldexp:
case OpenCLLIB::Pown:
case OpenCLLIB::Rootn: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar or vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
if (result_type != x_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected type of operand X to be equal to Result Type";
}
const uint32_t exp_type = _.GetOperandTypeId(inst, 5);
if (!_.IsIntScalarOrVectorType(exp_type) ||
_.GetBitWidth(exp_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected the exponent to be a 32-bit int scalar or vector";
}
if (_.GetDimension(exp_type) != num_components) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected the exponent to have the same number of "
"components as Result Type";
}
break;
}
case OpenCLLIB::Nan: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar or vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
const uint32_t nancode_type = _.GetOperandTypeId(inst, 4);
if (!_.IsIntScalarOrVectorType(nancode_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Nancode to be an int scalar or vector type";
}
if (_.GetDimension(nancode_type) != num_components) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Nancode to have the same number of components as "
"Result Type";
}
if (_.GetBitWidth(result_type) != _.GetBitWidth(nancode_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Nancode to have the same bit width as Result "
"Type";
}
break;
}
case OpenCLLIB::SAbs:
case OpenCLLIB::SAbs_diff:
case OpenCLLIB::SAdd_sat:
case OpenCLLIB::UAdd_sat:
case OpenCLLIB::SHadd:
case OpenCLLIB::UHadd:
case OpenCLLIB::SRhadd:
case OpenCLLIB::URhadd:
case OpenCLLIB::SClamp:
case OpenCLLIB::UClamp:
case OpenCLLIB::Clz:
case OpenCLLIB::Ctz:
case OpenCLLIB::SMad_hi:
case OpenCLLIB::UMad_sat:
case OpenCLLIB::SMad_sat:
case OpenCLLIB::SMax:
case OpenCLLIB::UMax:
case OpenCLLIB::SMin:
case OpenCLLIB::UMin:
case OpenCLLIB::SMul_hi:
case OpenCLLIB::Rotate:
case OpenCLLIB::SSub_sat:
case OpenCLLIB::USub_sat:
case OpenCLLIB::Popcount:
case OpenCLLIB::UAbs:
case OpenCLLIB::UAbs_diff:
case OpenCLLIB::UMul_hi:
case OpenCLLIB::UMad_hi: {
if (!_.IsIntScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be an int scalar or vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
for (uint32_t operand_index = 4; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (result_type != operand_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected types of all operands to be equal to Result "
"Type";
}
}
break;
}
case OpenCLLIB::U_Upsample:
case OpenCLLIB::S_Upsample: {
if (!_.IsIntScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be an int scalar or vector "
"type";
}
const uint32_t result_num_components = _.GetDimension(result_type);
if (result_num_components > 4 && result_num_components != 8 &&
result_num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
const uint32_t result_bit_width = _.GetBitWidth(result_type);
if (result_bit_width != 16 && result_bit_width != 32 &&
result_bit_width != 64) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected bit width of Result Type components to be 16, 32 "
"or 64";
}
const uint32_t hi_type = _.GetOperandTypeId(inst, 4);
const uint32_t lo_type = _.GetOperandTypeId(inst, 5);
if (hi_type != lo_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Hi and Lo operands to have the same type";
}
if (result_num_components != _.GetDimension(hi_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Hi and Lo operands to have the same number of "
"components as Result Type";
}
if (result_bit_width != 2 * _.GetBitWidth(hi_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected bit width of components of Hi and Lo operands to "
"be half of the bit width of components of Result Type";
}
break;
}
case OpenCLLIB::SMad24:
case OpenCLLIB::UMad24:
case OpenCLLIB::SMul24:
case OpenCLLIB::UMul24: {
if (!_.IsIntScalarOrVectorType(result_type) ||
_.GetBitWidth(result_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a 32-bit int scalar or vector "
"type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
for (uint32_t operand_index = 4; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (result_type != operand_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected types of all operands to be equal to Result "
"Type";
}
}
break;
}
case OpenCLLIB::Cross: {
if (!_.IsFloatVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components != 3 && num_components != 4) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to have 3 or 4 components";
}
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
const uint32_t y_type = _.GetOperandTypeId(inst, 5);
if (x_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X type to be equal to Result Type";
}
if (y_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Y type to be equal to Result Type";
}
break;
}
case OpenCLLIB::Distance:
case OpenCLLIB::Fast_distance: {
if (!_.IsFloatScalarType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar type";
}
const uint32_t p0_type = _.GetOperandTypeId(inst, 4);
if (!_.IsFloatScalarOrVectorType(p0_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P0 to be of float scalar or vector type";
}
const uint32_t num_components = _.GetDimension(p0_type);
if (num_components > 4) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P0 to have no more than 4 components";
}
if (result_type != _.GetComponentType(p0_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P0 component type to be equal to "
<< "Result Type";
}
const uint32_t p1_type = _.GetOperandTypeId(inst, 5);
if (p0_type != p1_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operands P0 and P1 to be of the same type";
}
break;
}
case OpenCLLIB::Length:
case OpenCLLIB::Fast_length: {
if (!_.IsFloatScalarType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar type";
}
const uint32_t p_type = _.GetOperandTypeId(inst, 4);
if (!_.IsFloatScalarOrVectorType(p_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P to be a float scalar or vector";
}
const uint32_t num_components = _.GetDimension(p_type);
if (num_components > 4) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P to have no more than 4 components";
}
if (result_type != _.GetComponentType(p_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P component type to be equal to Result "
"Type";
}
break;
}
case OpenCLLIB::Normalize:
case OpenCLLIB::Fast_normalize: {
if (!_.IsFloatScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar or vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to have no more than 4 components";
}
const uint32_t p_type = _.GetOperandTypeId(inst, 4);
if (p_type != result_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P type to be equal to Result Type";
}
break;
}
case OpenCLLIB::Bitselect: {
if (!_.IsFloatScalarOrVectorType(result_type) &&
!_.IsIntScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be an int or float scalar or "
"vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
for (uint32_t operand_index = 4; operand_index < num_operands;
++operand_index) {
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
if (result_type != operand_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected types of all operands to be equal to Result "
"Type";
}
}
break;
}
case OpenCLLIB::Select: {
if (!_.IsFloatScalarOrVectorType(result_type) &&
!_.IsIntScalarOrVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be an int or float scalar or "
"vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
const uint32_t a_type = _.GetOperandTypeId(inst, 4);
const uint32_t b_type = _.GetOperandTypeId(inst, 5);
const uint32_t c_type = _.GetOperandTypeId(inst, 6);
if (result_type != a_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand A type to be equal to Result Type";
}
if (result_type != b_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand B type to be equal to Result Type";
}
if (!_.IsIntScalarOrVectorType(c_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand C to be an int scalar or vector";
}
if (num_components != _.GetDimension(c_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand C to have the same number of components "
"as Result Type";
}
if (_.GetBitWidth(result_type) != _.GetBitWidth(c_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand C to have the same bit width as Result "
"Type";
}
break;
}
case OpenCLLIB::Vloadn: {
if (!_.IsFloatVectorType(result_type) &&
!_.IsIntVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be an int or float vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to have 2, 3, 4, 8 or 16 components";
}
const uint32_t offset_type = _.GetOperandTypeId(inst, 4);
const uint32_t p_type = _.GetOperandTypeId(inst, 5);
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
if (!size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name()
<< " can only be used with physical addressing models";
}
if (!_.IsIntScalarType(offset_type) ||
_.GetBitWidth(offset_type) != size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Offset to be of type size_t ("
<< size_t_bit_width
<< "-bit integer for the addressing model used in the module)";
}
spv::StorageClass p_storage_class;
uint32_t p_data_type = 0;
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P to be a pointer";
}
if (p_storage_class != spv::StorageClass::UniformConstant &&
p_storage_class != spv::StorageClass::Generic &&
p_storage_class != spv::StorageClass::CrossWorkgroup &&
p_storage_class != spv::StorageClass::Workgroup &&
p_storage_class != spv::StorageClass::Function) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P storage class to be UniformConstant, "
"Generic, CrossWorkgroup, Workgroup or Function";
}
if (_.GetComponentType(result_type) != p_data_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P data type to be equal to component "
"type of Result Type";
}
const uint32_t n_value = inst->word(7);
if (num_components != n_value) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected literal N to be equal to the number of "
"components of Result Type";
}
break;
}
case OpenCLLIB::Vstoren: {
if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": expected Result Type to be void";
}
const uint32_t data_type = _.GetOperandTypeId(inst, 4);
const uint32_t offset_type = _.GetOperandTypeId(inst, 5);
const uint32_t p_type = _.GetOperandTypeId(inst, 6);
if (!_.IsFloatVectorType(data_type) && !_.IsIntVectorType(data_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Data to be an int or float vector";
}
const uint32_t num_components = _.GetDimension(data_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Data to have 2, 3, 4, 8 or 16 components";
}
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
if (!size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name()
<< " can only be used with physical addressing models";
}
if (!_.IsIntScalarType(offset_type) ||
_.GetBitWidth(offset_type) != size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Offset to be of type size_t ("
<< size_t_bit_width
<< "-bit integer for the addressing model used in the module)";
}
spv::StorageClass p_storage_class;
uint32_t p_data_type = 0;
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P to be a pointer";
}
if (p_storage_class != spv::StorageClass::Generic &&
p_storage_class != spv::StorageClass::CrossWorkgroup &&
p_storage_class != spv::StorageClass::Workgroup &&
p_storage_class != spv::StorageClass::Function) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P storage class to be Generic, "
"CrossWorkgroup, Workgroup or Function";
}
if (_.GetComponentType(data_type) != p_data_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P data type to be equal to the type of "
"operand Data components";
}
break;
}
case OpenCLLIB::Vload_half: {
if (!_.IsFloatScalarType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float scalar type";
}
const uint32_t offset_type = _.GetOperandTypeId(inst, 4);
const uint32_t p_type = _.GetOperandTypeId(inst, 5);
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
if (!size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name()
<< " can only be used with physical addressing models";
}
if (!_.IsIntScalarType(offset_type) ||
_.GetBitWidth(offset_type) != size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Offset to be of type size_t ("
<< size_t_bit_width
<< "-bit integer for the addressing model used in the module)";
}
spv::StorageClass p_storage_class;
uint32_t p_data_type = 0;
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P to be a pointer";
}
if (p_storage_class != spv::StorageClass::UniformConstant &&
p_storage_class != spv::StorageClass::Generic &&
p_storage_class != spv::StorageClass::CrossWorkgroup &&
p_storage_class != spv::StorageClass::Workgroup &&
p_storage_class != spv::StorageClass::Function) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P storage class to be UniformConstant, "
"Generic, CrossWorkgroup, Workgroup or Function";
}
if (!_.IsFloatScalarType(p_data_type) ||
_.GetBitWidth(p_data_type) != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P data type to be 16-bit float scalar";
}
break;
}
case OpenCLLIB::Vload_halfn:
case OpenCLLIB::Vloada_halfn: {
if (!_.IsFloatVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a float vector type";
}
const uint32_t num_components = _.GetDimension(result_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to have 2, 3, 4, 8 or 16 components";
}
const uint32_t offset_type = _.GetOperandTypeId(inst, 4);
const uint32_t p_type = _.GetOperandTypeId(inst, 5);
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
if (!size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name()
<< " can only be used with physical addressing models";
}
if (!_.IsIntScalarType(offset_type) ||
_.GetBitWidth(offset_type) != size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Offset to be of type size_t ("
<< size_t_bit_width
<< "-bit integer for the addressing model used in the module)";
}
spv::StorageClass p_storage_class;
uint32_t p_data_type = 0;
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P to be a pointer";
}
if (p_storage_class != spv::StorageClass::UniformConstant &&
p_storage_class != spv::StorageClass::Generic &&
p_storage_class != spv::StorageClass::CrossWorkgroup &&
p_storage_class != spv::StorageClass::Workgroup &&
p_storage_class != spv::StorageClass::Function) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P storage class to be UniformConstant, "
"Generic, CrossWorkgroup, Workgroup or Function";
}
if (!_.IsFloatScalarType(p_data_type) ||
_.GetBitWidth(p_data_type) != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P data type to be 16-bit float scalar";
}
const uint32_t n_value = inst->word(7);
if (num_components != n_value) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected literal N to be equal to the number of "
"components of Result Type";
}
break;
}
case OpenCLLIB::Vstore_half:
case OpenCLLIB::Vstore_half_r:
case OpenCLLIB::Vstore_halfn:
case OpenCLLIB::Vstore_halfn_r:
case OpenCLLIB::Vstorea_halfn:
case OpenCLLIB::Vstorea_halfn_r: {
if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": expected Result Type to be void";
}
const uint32_t data_type = _.GetOperandTypeId(inst, 4);
const uint32_t offset_type = _.GetOperandTypeId(inst, 5);
const uint32_t p_type = _.GetOperandTypeId(inst, 6);
const uint32_t data_type_bit_width = _.GetBitWidth(data_type);
if (ext_inst_key == OpenCLLIB::Vstore_half ||
ext_inst_key == OpenCLLIB::Vstore_half_r) {
if (!_.IsFloatScalarType(data_type) ||
(data_type_bit_width != 32 && data_type_bit_width != 64)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Data to be a 32 or 64-bit float scalar";
}
} else {
if (!_.IsFloatVectorType(data_type) ||
(data_type_bit_width != 32 && data_type_bit_width != 64)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Data to be a 32 or 64-bit float vector";
}
const uint32_t num_components = _.GetDimension(data_type);
if (num_components > 4 && num_components != 8 &&
num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Data to have 2, 3, 4, 8 or 16 components";
}
}
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
if (!size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name()
<< " can only be used with physical addressing models";
}
if (!_.IsIntScalarType(offset_type) ||
_.GetBitWidth(offset_type) != size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Offset to be of type size_t ("
<< size_t_bit_width
<< "-bit integer for the addressing model used in the module)";
}
spv::StorageClass p_storage_class;
uint32_t p_data_type = 0;
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P to be a pointer";
}
if (p_storage_class != spv::StorageClass::Generic &&
p_storage_class != spv::StorageClass::CrossWorkgroup &&
p_storage_class != spv::StorageClass::Workgroup &&
p_storage_class != spv::StorageClass::Function) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P storage class to be Generic, "
"CrossWorkgroup, Workgroup or Function";
}
if (!_.IsFloatScalarType(p_data_type) ||
_.GetBitWidth(p_data_type) != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand P data type to be 16-bit float scalar";
}
// Rounding mode enum is checked by assembler.
break;
}
case OpenCLLIB::Shuffle:
case OpenCLLIB::Shuffle2: {
if (!_.IsFloatVectorType(result_type) &&
!_.IsIntVectorType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be an int or float vector type";
}
const uint32_t result_num_components = _.GetDimension(result_type);
if (result_num_components != 2 && result_num_components != 4 &&
result_num_components != 8 && result_num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to have 2, 4, 8 or 16 components";
}
uint32_t operand_index = 4;
const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++);
if (ext_inst_key == OpenCLLIB::Shuffle2) {
const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++);
if (x_type != y_type) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operands X and Y to be of the same type";
}
}
const uint32_t shuffle_mask_type =
_.GetOperandTypeId(inst, operand_index++);
if (!_.IsFloatVectorType(x_type) && !_.IsIntVectorType(x_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X to be an int or float vector";
}
const uint32_t x_num_components = _.GetDimension(x_type);
if (x_num_components != 2 && x_num_components != 4 &&
x_num_components != 8 && x_num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X to have 2, 4, 8 or 16 components";
}
const uint32_t result_component_type = _.GetComponentType(result_type);
if (result_component_type != _.GetComponentType(x_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand X and Result Type to have equal "
"component types";
}
if (!_.IsIntVectorType(shuffle_mask_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Shuffle Mask to be an int vector";
}
if (result_num_components != _.GetDimension(shuffle_mask_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Shuffle Mask to have the same number of "
"components as Result Type";
}
if (_.GetBitWidth(result_component_type) !=
_.GetBitWidth(shuffle_mask_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Shuffle Mask components to have the same "
"bit width as Result Type components";
}
break;
}
case OpenCLLIB::Printf: {
if (!_.IsIntScalarType(result_type) ||
_.GetBitWidth(result_type) != 32) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a 32-bit int type";
}
const uint32_t format_type = _.GetOperandTypeId(inst, 4);
spv::StorageClass format_storage_class;
uint32_t format_data_type = 0;
if (!_.GetPointerTypeInfo(format_type, &format_data_type,
&format_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Format to be a pointer";
}
if (format_storage_class != spv::StorageClass::UniformConstant) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Format storage class to be UniformConstant";
}
if (!_.IsIntScalarType(format_data_type) ||
_.GetBitWidth(format_data_type) != 8) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Format data type to be 8-bit int";
}
break;
}
case OpenCLLIB::Prefetch: {
if (_.GetIdOpcode(result_type) != spv::Op::OpTypeVoid) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": expected Result Type to be void";
}
const uint32_t p_type = _.GetOperandTypeId(inst, 4);
const uint32_t num_elements_type = _.GetOperandTypeId(inst, 5);
spv::StorageClass p_storage_class;
uint32_t p_data_type = 0;
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Ptr to be a pointer";
}
if (p_storage_class != spv::StorageClass::CrossWorkgroup) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Ptr storage class to be CrossWorkgroup";
}
if (!_.IsFloatScalarOrVectorType(p_data_type) &&
!_.IsIntScalarOrVectorType(p_data_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Ptr data type to be int or float scalar or "
"vector";
}
const uint32_t num_components = _.GetDimension(p_data_type);
if (num_components > 4 && num_components != 8 && num_components != 16) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected Result Type to be a scalar or a vector with 2, "
"3, 4, 8 or 16 components";
}
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
if (!size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name()
<< " can only be used with physical addressing models";
}
if (!_.IsIntScalarType(num_elements_type) ||
_.GetBitWidth(num_elements_type) != size_t_bit_width) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Num Elements to be of type size_t ("
<< size_t_bit_width
<< "-bit integer for the addressing model used in the module)";
}
break;
}
}
} else if (ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 ||
ext_inst_type ==
SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100) {
if (!_.IsVoidType(result_type)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected result type must be a result id of "
<< "OpTypeVoid";
}
const bool vulkanDebugInfo =
ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100;
auto num_words = inst->words().size();
// Handle any non-common NonSemanticShaderDebugInfo instructions.
if (vulkanDebugInfo) {
const NonSemanticShaderDebugInfo100Instructions ext_inst_key =
NonSemanticShaderDebugInfo100Instructions(ext_inst_index);
switch (ext_inst_key) {
// The following block of instructions will be handled by the common
// validation.
case NonSemanticShaderDebugInfo100DebugInfoNone:
case NonSemanticShaderDebugInfo100DebugCompilationUnit:
case NonSemanticShaderDebugInfo100DebugTypeBasic:
case NonSemanticShaderDebugInfo100DebugTypePointer:
case NonSemanticShaderDebugInfo100DebugTypeQualifier:
case NonSemanticShaderDebugInfo100DebugTypeArray:
case NonSemanticShaderDebugInfo100DebugTypeVector:
case NonSemanticShaderDebugInfo100DebugTypedef:
case NonSemanticShaderDebugInfo100DebugTypeFunction:
case NonSemanticShaderDebugInfo100DebugTypeEnum:
case NonSemanticShaderDebugInfo100DebugTypeComposite:
case NonSemanticShaderDebugInfo100DebugTypeMember:
case NonSemanticShaderDebugInfo100DebugTypeInheritance:
case NonSemanticShaderDebugInfo100DebugTypePtrToMember:
case NonSemanticShaderDebugInfo100DebugTypeTemplate:
case NonSemanticShaderDebugInfo100DebugTypeTemplateParameter:
case NonSemanticShaderDebugInfo100DebugTypeTemplateTemplateParameter:
case NonSemanticShaderDebugInfo100DebugTypeTemplateParameterPack:
case NonSemanticShaderDebugInfo100DebugGlobalVariable:
case NonSemanticShaderDebugInfo100DebugFunctionDeclaration:
case NonSemanticShaderDebugInfo100DebugFunction:
case NonSemanticShaderDebugInfo100DebugLexicalBlock:
case NonSemanticShaderDebugInfo100DebugLexicalBlockDiscriminator:
case NonSemanticShaderDebugInfo100DebugScope:
case NonSemanticShaderDebugInfo100DebugNoScope:
case NonSemanticShaderDebugInfo100DebugInlinedAt:
case NonSemanticShaderDebugInfo100DebugLocalVariable:
case NonSemanticShaderDebugInfo100DebugInlinedVariable:
case NonSemanticShaderDebugInfo100DebugDeclare:
case NonSemanticShaderDebugInfo100DebugValue:
case NonSemanticShaderDebugInfo100DebugOperation:
case NonSemanticShaderDebugInfo100DebugExpression:
case NonSemanticShaderDebugInfo100DebugMacroDef:
case NonSemanticShaderDebugInfo100DebugMacroUndef:
case NonSemanticShaderDebugInfo100DebugImportedEntity:
case NonSemanticShaderDebugInfo100DebugSource:
break;
case NonSemanticShaderDebugInfo100DebugTypeMatrix: {
CHECK_DEBUG_OPERAND("Vector Type", CommonDebugInfoDebugTypeVector, 5);
CHECK_CONST_UINT_OPERAND("Vector Count", 6);
uint32_t vector_count = inst->word(6);
uint64_t const_val;
if (!_.GetConstantValUint64(vector_count, &const_val)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name()
<< ": Vector Count must be 32-bit integer OpConstant";
}
vector_count = const_val & 0xffffffff;
if (!vector_count || vector_count > 4) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": Vector Count must be positive "
<< "integer less than or equal to 4";
}
break;
}
// TODO: Add validation rules for remaining cases as well.
case NonSemanticShaderDebugInfo100DebugFunctionDefinition:
case NonSemanticShaderDebugInfo100DebugSourceContinued:
case NonSemanticShaderDebugInfo100DebugLine:
case NonSemanticShaderDebugInfo100DebugNoLine:
case NonSemanticShaderDebugInfo100DebugBuildIdentifier:
case NonSemanticShaderDebugInfo100DebugStoragePath:
case NonSemanticShaderDebugInfo100DebugEntryPoint:
break;
case NonSemanticShaderDebugInfo100InstructionsMax:
assert(0);
break;
}
}
// Handle any non-common OpenCL insts, then common
if (ext_inst_type != SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100 ||
OpenCLDebugInfo100Instructions(ext_inst_index) !=
OpenCLDebugInfo100DebugModuleINTEL) {
const CommonDebugInfoInstructions ext_inst_key =
CommonDebugInfoInstructions(ext_inst_index);
switch (ext_inst_key) {
case CommonDebugInfoDebugInfoNone:
case CommonDebugInfoDebugNoScope:
break;
// The binary parser validates the opcode for DebugInfoNone,
// DebugNoScope, DebugOperation. We just check the parameters to
// DebugOperation are properly constants for vulkan debug info.
case CommonDebugInfoDebugOperation: {
CHECK_CONST_UINT_OPERAND("Operation", 5);
for (uint32_t i = 6; i < num_words; ++i) {
CHECK_CONST_UINT_OPERAND("Operand", i);
}
break;
}
case CommonDebugInfoDebugCompilationUnit: {
CHECK_CONST_UINT_OPERAND("Version", 5);
CHECK_CONST_UINT_OPERAND("DWARF Version", 6);
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7);
CHECK_CONST_UINT_OPERAND("Language", 8);
break;
}
case CommonDebugInfoDebugSource: {
CHECK_OPERAND("File", spv::Op::OpString, 5);
if (num_words == 7) CHECK_OPERAND("Text", spv::Op::OpString, 6);
break;
}
case CommonDebugInfoDebugTypeBasic: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
CHECK_OPERAND("Size", spv::Op::OpConstant, 6);
CHECK_CONST_UINT_OPERAND("Encoding", 7);
break;
}
case CommonDebugInfoDebugTypePointer: {
auto validate_base_type =
ValidateOperandBaseType(_, inst, 5, ext_inst_name);
if (validate_base_type != SPV_SUCCESS) return validate_base_type;
CHECK_CONST_UINT_OPERAND("Storage Class", 6);
CHECK_CONST_UINT_OPERAND("Flags", 7);
break;
}
case CommonDebugInfoDebugTypeQualifier: {
auto validate_base_type =
ValidateOperandBaseType(_, inst, 5, ext_inst_name);
if (validate_base_type != SPV_SUCCESS) return validate_base_type;
CHECK_CONST_UINT_OPERAND("Type Qualifier", 6);
break;
}
case CommonDebugInfoDebugTypeVector: {
auto validate_base_type =
ValidateOperandBaseType(_, inst, 5, ext_inst_name);
if (validate_base_type != SPV_SUCCESS) return validate_base_type;
CHECK_CONST_UINT_OPERAND("Component Count", 6);
uint32_t component_count = inst->word(6);
if (vulkanDebugInfo) {
uint64_t const_val;
if (!_.GetConstantValUint64(component_count, &const_val)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name()
<< ": Component Count must be 32-bit integer OpConstant";
}
component_count = const_val & 0xffffffff;
}
if (!component_count || component_count > 4) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": Component Count must be positive "
<< "integer less than or equal to 4";
}
break;
}
case CommonDebugInfoDebugTypeArray: {
auto validate_base_type = ValidateOperandDebugType(
_, "Base Type", inst, 5, ext_inst_name, false);
if (validate_base_type != SPV_SUCCESS) return validate_base_type;
for (uint32_t i = 6; i < num_words; ++i) {
bool invalid = false;
auto* component_count = _.FindDef(inst->word(i));
if (IsConstIntScalarTypeWith32Or64Bits(_, component_count)) {
// TODO: We need a spec discussion for the runtime array for
// OpenCL.
if (!vulkanDebugInfo && !component_count->word(3)) {
invalid = true;
}
} else if (component_count->words().size() > 6 &&
(CommonDebugInfoInstructions(component_count->word(4)) ==
CommonDebugInfoDebugLocalVariable ||
CommonDebugInfoInstructions(component_count->word(4)) ==
CommonDebugInfoDebugGlobalVariable)) {
auto* component_count_type = _.FindDef(component_count->word(6));
if (component_count_type->words().size() > 7) {
uint32_t encoding = component_count_type->word(7);
if (CommonDebugInfoInstructions(component_count_type->word(
4)) != CommonDebugInfoDebugTypeBasic ||
(vulkanDebugInfo && !IsUint32Constant(_, encoding)) ||
OpenCLDebugInfo100DebugBaseTypeAttributeEncoding(
vulkanDebugInfo
? GetUint32Constant(_, encoding)
: encoding) != OpenCLDebugInfo100Unsigned) {
invalid = true;
} else {
// DebugTypeBasic for DebugLocalVariable/DebugGlobalVariable
// must have Unsigned encoding and 32 or 64 as its size in
// bits.
Instruction* size_in_bits =
_.FindDef(component_count_type->word(6));
if (!_.IsIntScalarType(size_in_bits->type_id()) ||
(size_in_bits->word(3) != 32 &&
size_in_bits->word(3) != 64)) {
invalid = true;
}
}
} else {
invalid = true;
}
} else {
invalid = true;
}
if (invalid) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": Component Count must be "
<< "OpConstant with a 32- or 64-bits integer scalar type "
"or "
<< "DebugGlobalVariable or DebugLocalVariable with a 32- "
"or "
<< "64-bits unsigned integer scalar type";
}
}
break;
}
case CommonDebugInfoDebugTypedef: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
auto validate_base_type =
ValidateOperandBaseType(_, inst, 6, ext_inst_name);
if (validate_base_type != SPV_SUCCESS) return validate_base_type;
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7);
CHECK_CONST_UINT_OPERAND("Line", 8);
CHECK_CONST_UINT_OPERAND("Column", 9);
auto validate_parent =
ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name);
if (validate_parent != SPV_SUCCESS) return validate_parent;
break;
}
case CommonDebugInfoDebugTypeFunction: {
CHECK_CONST_UINT_OPERAND("Flags", 5);
auto* return_type = _.FindDef(inst->word(6));
// TODO: We need a spec discussion that we have to allow return and
// parameter types of a DebugTypeFunction to have template parameter.
if (return_type->opcode() != spv::Op::OpTypeVoid) {
auto validate_return = ValidateOperandDebugType(
_, "Return Type", inst, 6, ext_inst_name, true);
if (validate_return != SPV_SUCCESS) return validate_return;
}
for (uint32_t word_index = 7; word_index < num_words; ++word_index) {
auto validate_param = ValidateOperandDebugType(
_, "Parameter Types", inst, word_index, ext_inst_name, true);
if (validate_param != SPV_SUCCESS) return validate_param;
}
break;
}
case CommonDebugInfoDebugTypeEnum: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
if (!DoesDebugInfoOperandMatchExpectation(
_,
[](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst == CommonDebugInfoDebugInfoNone;
},
inst, 6)) {
auto validate_underlying_type = ValidateOperandDebugType(
_, "Underlying Types", inst, 6, ext_inst_name, false);
if (validate_underlying_type != SPV_SUCCESS)
return validate_underlying_type;
}
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7);
CHECK_CONST_UINT_OPERAND("Line", 8);
CHECK_CONST_UINT_OPERAND("Column", 9);
auto validate_parent =
ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name);
if (validate_parent != SPV_SUCCESS) return validate_parent;
CHECK_OPERAND("Size", spv::Op::OpConstant, 11);
auto* size = _.FindDef(inst->word(11));
if (!_.IsIntScalarType(size->type_id()) || !size->word(3)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": expected operand Size is a "
<< "positive integer";
}
CHECK_CONST_UINT_OPERAND("Flags", 12);
for (uint32_t word_index = 13; word_index + 1 < num_words;
word_index += 2) {
CHECK_OPERAND("Value", spv::Op::OpConstant, word_index);
CHECK_OPERAND("Name", spv::Op::OpString, word_index + 1);
}
break;
}
case CommonDebugInfoDebugTypeComposite: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7);
CHECK_CONST_UINT_OPERAND("Line", 8);
CHECK_CONST_UINT_OPERAND("Column", 9);
auto validate_parent =
ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name);
if (validate_parent != SPV_SUCCESS) return validate_parent;
CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11);
if (!DoesDebugInfoOperandMatchExpectation(
_,
[](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst == CommonDebugInfoDebugInfoNone;
},
inst, 12)) {
CHECK_OPERAND("Size", spv::Op::OpConstant, 12);
}
CHECK_CONST_UINT_OPERAND("Flags", 13);
for (uint32_t word_index = 14; word_index < num_words; ++word_index) {
if (!DoesDebugInfoOperandMatchExpectation(
_,
[](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst == CommonDebugInfoDebugTypeMember ||
dbg_inst == CommonDebugInfoDebugFunction ||
dbg_inst == CommonDebugInfoDebugTypeInheritance;
},
inst, word_index)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Members "
<< "must be DebugTypeMember, DebugFunction, or "
"DebugTypeInheritance";
}
}
break;
}
case CommonDebugInfoDebugTypeMember: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
// TODO: We need a spec discussion that we have to allow member types
// to have template parameter.
auto validate_type =
ValidateOperandDebugType(_, "Type", inst, 6, ext_inst_name, true);
if (validate_type != SPV_SUCCESS) return validate_type;
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7);
CHECK_CONST_UINT_OPERAND("Line", 8);
CHECK_CONST_UINT_OPERAND("Column", 9);
// NonSemantic.Shader.DebugInfo doesn't have the Parent operand
if (vulkanDebugInfo) {
CHECK_OPERAND("Offset", spv::Op::OpConstant, 10);
CHECK_OPERAND("Size", spv::Op::OpConstant, 11);
CHECK_CONST_UINT_OPERAND("Flags", 12);
if (num_words == 14)
CHECK_OPERAND("Value", spv::Op::OpConstant, 13);
} else {
CHECK_DEBUG_OPERAND("Parent", CommonDebugInfoDebugTypeComposite,
10);
CHECK_OPERAND("Offset", spv::Op::OpConstant, 11);
CHECK_OPERAND("Size", spv::Op::OpConstant, 12);
CHECK_CONST_UINT_OPERAND("Flags", 13);
if (num_words == 15)
CHECK_OPERAND("Value", spv::Op::OpConstant, 14);
}
break;
}
case CommonDebugInfoDebugTypeInheritance: {
CHECK_DEBUG_OPERAND("Child", CommonDebugInfoDebugTypeComposite, 5);
auto* debug_inst = _.FindDef(inst->word(5));
auto composite_type =
OpenCLDebugInfo100DebugCompositeType(debug_inst->word(6));
if (composite_type != OpenCLDebugInfo100Class &&
composite_type != OpenCLDebugInfo100Structure) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Child must be class or struct debug "
"type";
}
CHECK_DEBUG_OPERAND("Parent", CommonDebugInfoDebugTypeComposite, 6);
debug_inst = _.FindDef(inst->word(6));
composite_type =
OpenCLDebugInfo100DebugCompositeType(debug_inst->word(6));
if (composite_type != OpenCLDebugInfo100Class &&
composite_type != OpenCLDebugInfo100Structure) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Parent must be class or struct debug "
"type";
}
CHECK_OPERAND("Offset", spv::Op::OpConstant, 7);
CHECK_OPERAND("Size", spv::Op::OpConstant, 8);
CHECK_CONST_UINT_OPERAND("Flags", 9);
break;
}
case CommonDebugInfoDebugFunction: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
auto validate_type = ValidateOperandDebugType(_, "Type", inst, 6,
ext_inst_name, false);
if (validate_type != SPV_SUCCESS) return validate_type;
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7);
CHECK_CONST_UINT_OPERAND("Line", 8);
CHECK_CONST_UINT_OPERAND("Column", 9);
auto validate_parent =
ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name);
if (validate_parent != SPV_SUCCESS) return validate_parent;
CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11);
CHECK_CONST_UINT_OPERAND("Flags", 12);
CHECK_CONST_UINT_OPERAND("Scope Line", 13);
// NonSemantic.Shader.DebugInfo.100 doesn't include a reference to the
// OpFunction
if (vulkanDebugInfo) {
if (num_words == 15) {
CHECK_DEBUG_OPERAND("Declaration",
CommonDebugInfoDebugFunctionDeclaration, 14);
}
} else {
if (!DoesDebugInfoOperandMatchExpectation(
_,
[](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst == CommonDebugInfoDebugInfoNone;
},
inst, 14)) {
CHECK_OPERAND("Function", spv::Op::OpFunction, 14);
}
if (num_words == 16) {
CHECK_DEBUG_OPERAND("Declaration",
CommonDebugInfoDebugFunctionDeclaration, 15);
}
}
break;
}
case CommonDebugInfoDebugFunctionDeclaration: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
auto validate_type = ValidateOperandDebugType(_, "Type", inst, 6,
ext_inst_name, false);
if (validate_type != SPV_SUCCESS) return validate_type;
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7);
CHECK_CONST_UINT_OPERAND("Line", 8);
CHECK_CONST_UINT_OPERAND("Column", 9);
auto validate_parent =
ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name);
if (validate_parent != SPV_SUCCESS) return validate_parent;
CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11);
CHECK_CONST_UINT_OPERAND("Flags", 12);
break;
}
case CommonDebugInfoDebugLexicalBlock: {
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 5);
CHECK_CONST_UINT_OPERAND("Line", 6);
CHECK_CONST_UINT_OPERAND("Column", 7);
auto validate_parent =
ValidateOperandLexicalScope(_, "Parent", inst, 8, ext_inst_name);
if (validate_parent != SPV_SUCCESS) return validate_parent;
if (num_words == 10) CHECK_OPERAND("Name", spv::Op::OpString, 9);
break;
}
case CommonDebugInfoDebugScope: {
auto validate_scope =
ValidateOperandLexicalScope(_, "Scope", inst, 5, ext_inst_name);
if (validate_scope != SPV_SUCCESS) return validate_scope;
if (num_words == 7) {
CHECK_DEBUG_OPERAND("Inlined At", CommonDebugInfoDebugInlinedAt, 6);
}
break;
}
case CommonDebugInfoDebugLocalVariable: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
// TODO: We need a spec discussion that we have to allow local
// variable types to have template parameter.
auto validate_type =
ValidateOperandDebugType(_, "Type", inst, 6, ext_inst_name, true);
if (validate_type != SPV_SUCCESS) return validate_type;
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7);
CHECK_CONST_UINT_OPERAND("Line", 8);
CHECK_CONST_UINT_OPERAND("Column", 9);
auto validate_parent =
ValidateOperandLexicalScope(_, "Parent", inst, 10, ext_inst_name);
if (validate_parent != SPV_SUCCESS) return validate_parent;
CHECK_CONST_UINT_OPERAND("Flags", 11);
if (num_words == 13) {
CHECK_CONST_UINT_OPERAND("ArgNumber", 12);
}
break;
}
case CommonDebugInfoDebugDeclare: {
CHECK_DEBUG_OPERAND("Local Variable",
CommonDebugInfoDebugLocalVariable, 5);
auto* operand = _.FindDef(inst->word(6));
if (operand->opcode() != spv::Op::OpVariable &&
operand->opcode() != spv::Op::OpFunctionParameter) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Variable must be a result id of "
"OpVariable or OpFunctionParameter";
}
CHECK_DEBUG_OPERAND("Expression", CommonDebugInfoDebugExpression, 7);
if (vulkanDebugInfo) {
for (uint32_t word_index = 8; word_index < num_words;
++word_index) {
auto index_inst = _.FindDef(inst->word(word_index));
auto type_id = index_inst != nullptr ? index_inst->type_id() : 0;
if (type_id == 0 || !IsIntScalar(_, type_id, false, false))
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected index must be scalar integer";
}
}
break;
}
case CommonDebugInfoDebugExpression: {
for (uint32_t word_index = 5; word_index < num_words; ++word_index) {
CHECK_DEBUG_OPERAND("Operation", CommonDebugInfoDebugOperation,
word_index);
}
break;
}
case CommonDebugInfoDebugTypeTemplate: {
if (!DoesDebugInfoOperandMatchExpectation(
_,
[](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst == CommonDebugInfoDebugTypeComposite ||
dbg_inst == CommonDebugInfoDebugFunction;
},
inst, 5)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Target must be DebugTypeComposite "
<< "or DebugFunction";
}
for (uint32_t word_index = 6; word_index < num_words; ++word_index) {
if (!DoesDebugInfoOperandMatchExpectation(
_,
[](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst ==
CommonDebugInfoDebugTypeTemplateParameter ||
dbg_inst ==
CommonDebugInfoDebugTypeTemplateTemplateParameter;
},
inst, word_index)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Parameters must be "
<< "DebugTypeTemplateParameter or "
<< "DebugTypeTemplateTemplateParameter";
}
}
break;
}
case CommonDebugInfoDebugTypeTemplateParameter: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
auto validate_actual_type = ValidateOperandDebugType(
_, "Actual Type", inst, 6, ext_inst_name, false);
if (validate_actual_type != SPV_SUCCESS) return validate_actual_type;
if (!DoesDebugInfoOperandMatchExpectation(
_,
[](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst == CommonDebugInfoDebugInfoNone;
},
inst, 7)) {
CHECK_OPERAND("Value", spv::Op::OpConstant, 7);
}
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 8);
CHECK_CONST_UINT_OPERAND("Line", 9);
CHECK_CONST_UINT_OPERAND("Column", 10);
break;
}
case CommonDebugInfoDebugGlobalVariable: {
CHECK_OPERAND("Name", spv::Op::OpString, 5);
auto validate_type = ValidateOperandDebugType(_, "Type", inst, 6,
ext_inst_name, false);
if (validate_type != SPV_SUCCESS) return validate_type;
CHECK_DEBUG_OPERAND("Source", CommonDebugInfoDebugSource, 7);
CHECK_CONST_UINT_OPERAND("Line", 8);
CHECK_CONST_UINT_OPERAND("Column", 9);
auto validate_scope =
ValidateOperandLexicalScope(_, "Scope", inst, 10, ext_inst_name);
if (validate_scope != SPV_SUCCESS) return validate_scope;
CHECK_OPERAND("Linkage Name", spv::Op::OpString, 11);
if (!DoesDebugInfoOperandMatchExpectation(
_,
[](CommonDebugInfoInstructions dbg_inst) {
return dbg_inst == CommonDebugInfoDebugInfoNone;
},
inst, 12)) {
auto* operand = _.FindDef(inst->word(12));
if (operand->opcode() != spv::Op::OpVariable &&
operand->opcode() != spv::Op::OpConstant) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": "
<< "expected operand Variable must be a result id of "
"OpVariable or OpConstant or DebugInfoNone";
}
}
if (num_words == 15) {
CHECK_DEBUG_OPERAND("Static Member Declaration",
CommonDebugInfoDebugTypeMember, 14);
}
break;
}
case CommonDebugInfoDebugInlinedAt: {
CHECK_CONST_UINT_OPERAND("Line", 5);
auto validate_scope =
ValidateOperandLexicalScope(_, "Scope", inst, 6, ext_inst_name);
if (validate_scope != SPV_SUCCESS) return validate_scope;
if (num_words == 8) {
CHECK_DEBUG_OPERAND("Inlined", CommonDebugInfoDebugInlinedAt, 7);
}
break;
}
case CommonDebugInfoDebugValue: {
CHECK_DEBUG_OPERAND("Local Variable",
CommonDebugInfoDebugLocalVariable, 5);
CHECK_DEBUG_OPERAND("Expression", CommonDebugInfoDebugExpression, 7);
for (uint32_t word_index = 8; word_index < num_words; ++word_index) {
// TODO: The following code simply checks if it is a const int
// scalar or a DebugLocalVariable or DebugGlobalVariable, but we
// have to check it using the same validation for Indexes of
// OpAccessChain.
if (!IsConstWithIntScalarType(_, inst, word_index) &&
!IsDebugVariableWithIntScalarType(_, inst, word_index)) {
return _.diag(SPV_ERROR_INVALID_DATA, inst)
<< ext_inst_name() << ": expected operand Indexes is "
<< "OpConstant, DebugGlobalVariable, or "
<< "type is OpConstant with an integer scalar type";
}
}
break;
}
// TODO: Add validation rules for remaining cases as well.
case CommonDebugInfoDebugTypePtrToMember:
case CommonDebugInfoDebugTypeTemplateTemplateParameter:
case CommonDebugInfoDebugTypeTemplateParameterPack:
case CommonDebugInfoDebugLexicalBlockDiscriminator:
case CommonDebugInfoDebugInlinedVariable:
case CommonDebugInfoDebugMacroDef:
case CommonDebugInfoDebugMacroUndef:
case CommonDebugInfoDebugImportedEntity:
break;
case CommonDebugInfoInstructionsMax:
assert(0);
break;
}
}
} else if (ext_inst_type == SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION) {
auto import_inst = _.FindDef(inst->GetOperandAs<uint32_t>(2));
const std::string name = import_inst->GetOperandAs<std::string>(1);
const std::string reflection = "NonSemantic.ClspvReflection.";
char* end_ptr;
auto version_string = name.substr(reflection.size());
if (version_string.empty()) {
return _.diag(SPV_ERROR_INVALID_DATA, import_inst)
<< "Missing NonSemantic.ClspvReflection import version";
}
uint32_t version = static_cast<uint32_t>(
std::strtoul(version_string.c_str(), &end_ptr, 10));
if (end_ptr && *end_ptr != '\0') {
return _.diag(SPV_ERROR_INVALID_DATA, import_inst)
<< "NonSemantic.ClspvReflection import does not encode the "
"version correctly";
}
if (version == 0 || version > NonSemanticClspvReflectionRevision) {
return _.diag(SPV_ERROR_INVALID_DATA, import_inst)
<< "Unknown NonSemantic.ClspvReflection import version";
}
return ValidateClspvReflectionInstruction(_, inst, version);
}
return SPV_SUCCESS;
}
spv_result_t ExtensionPass(ValidationState_t& _, const Instruction* inst) {
const spv::Op opcode = inst->opcode();
if (opcode == spv::Op::OpExtension) return ValidateExtension(_, inst);
if (opcode == spv::Op::OpExtInstImport) return ValidateExtInstImport(_, inst);
if (opcode == spv::Op::OpExtInst) return ValidateExtInst(_, inst);
return SPV_SUCCESS;
}
} // namespace val
} // namespace spvtools
Reference in New Issue View Git Blame Copy Permalink