You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1741 lines
57 KiB
1741 lines
57 KiB
// Copyright (c) 2015-2016 The Khronos Group Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "source/val/validation_state.h"
|
|
|
|
#include <cassert>
|
|
#include <stack>
|
|
#include <utility>
|
|
|
|
#include "source/opcode.h"
|
|
#include "source/spirv_constant.h"
|
|
#include "source/spirv_target_env.h"
|
|
#include "source/val/basic_block.h"
|
|
#include "source/val/construct.h"
|
|
#include "source/val/function.h"
|
|
#include "spirv-tools/libspirv.h"
|
|
|
|
namespace spvtools {
|
|
namespace val {
|
|
namespace {
|
|
|
|
ModuleLayoutSection InstructionLayoutSection(
|
|
ModuleLayoutSection current_section, SpvOp op) {
|
|
// See Section 2.4
|
|
if (spvOpcodeGeneratesType(op) || spvOpcodeIsConstant(op))
|
|
return kLayoutTypes;
|
|
|
|
switch (op) {
|
|
case SpvOpCapability:
|
|
return kLayoutCapabilities;
|
|
case SpvOpExtension:
|
|
return kLayoutExtensions;
|
|
case SpvOpExtInstImport:
|
|
return kLayoutExtInstImport;
|
|
case SpvOpMemoryModel:
|
|
return kLayoutMemoryModel;
|
|
case SpvOpEntryPoint:
|
|
return kLayoutEntryPoint;
|
|
case SpvOpExecutionMode:
|
|
case SpvOpExecutionModeId:
|
|
return kLayoutExecutionMode;
|
|
case SpvOpSourceContinued:
|
|
case SpvOpSource:
|
|
case SpvOpSourceExtension:
|
|
case SpvOpString:
|
|
return kLayoutDebug1;
|
|
case SpvOpName:
|
|
case SpvOpMemberName:
|
|
return kLayoutDebug2;
|
|
case SpvOpModuleProcessed:
|
|
return kLayoutDebug3;
|
|
case SpvOpDecorate:
|
|
case SpvOpMemberDecorate:
|
|
case SpvOpGroupDecorate:
|
|
case SpvOpGroupMemberDecorate:
|
|
case SpvOpDecorationGroup:
|
|
case SpvOpDecorateId:
|
|
case SpvOpDecorateStringGOOGLE:
|
|
case SpvOpMemberDecorateStringGOOGLE:
|
|
return kLayoutAnnotations;
|
|
case SpvOpTypeForwardPointer:
|
|
return kLayoutTypes;
|
|
case SpvOpVariable:
|
|
if (current_section == kLayoutTypes) return kLayoutTypes;
|
|
return kLayoutFunctionDefinitions;
|
|
case SpvOpExtInst:
|
|
// SpvOpExtInst is only allowed in types section for certain extended
|
|
// instruction sets. This will be checked separately.
|
|
if (current_section == kLayoutTypes) return kLayoutTypes;
|
|
return kLayoutFunctionDefinitions;
|
|
case SpvOpLine:
|
|
case SpvOpNoLine:
|
|
case SpvOpUndef:
|
|
if (current_section == kLayoutTypes) return kLayoutTypes;
|
|
return kLayoutFunctionDefinitions;
|
|
case SpvOpFunction:
|
|
case SpvOpFunctionParameter:
|
|
case SpvOpFunctionEnd:
|
|
if (current_section == kLayoutFunctionDeclarations)
|
|
return kLayoutFunctionDeclarations;
|
|
return kLayoutFunctionDefinitions;
|
|
default:
|
|
break;
|
|
}
|
|
return kLayoutFunctionDefinitions;
|
|
}
|
|
|
|
bool IsInstructionInLayoutSection(ModuleLayoutSection layout, SpvOp op) {
|
|
return layout == InstructionLayoutSection(layout, op);
|
|
}
|
|
|
|
// Counts the number of instructions and functions in the file.
|
|
spv_result_t CountInstructions(void* user_data,
|
|
const spv_parsed_instruction_t* inst) {
|
|
ValidationState_t& _ = *(reinterpret_cast<ValidationState_t*>(user_data));
|
|
if (inst->opcode == SpvOpFunction) _.increment_total_functions();
|
|
_.increment_total_instructions();
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t setHeader(void* user_data, spv_endianness_t, uint32_t,
|
|
uint32_t version, uint32_t generator, uint32_t id_bound,
|
|
uint32_t) {
|
|
ValidationState_t& vstate =
|
|
*(reinterpret_cast<ValidationState_t*>(user_data));
|
|
vstate.setIdBound(id_bound);
|
|
vstate.setGenerator(generator);
|
|
vstate.setVersion(version);
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
// Add features based on SPIR-V core version number.
|
|
void UpdateFeaturesBasedOnSpirvVersion(ValidationState_t::Feature* features,
|
|
uint32_t version) {
|
|
assert(features);
|
|
if (version >= SPV_SPIRV_VERSION_WORD(1, 4)) {
|
|
features->select_between_composites = true;
|
|
features->copy_memory_permits_two_memory_accesses = true;
|
|
features->uconvert_spec_constant_op = true;
|
|
features->nonwritable_var_in_function_or_private = true;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
ValidationState_t::ValidationState_t(const spv_const_context ctx,
|
|
const spv_const_validator_options opt,
|
|
const uint32_t* words,
|
|
const size_t num_words,
|
|
const uint32_t max_warnings)
|
|
: context_(ctx),
|
|
options_(opt),
|
|
words_(words),
|
|
num_words_(num_words),
|
|
unresolved_forward_ids_{},
|
|
operand_names_{},
|
|
current_layout_section_(kLayoutCapabilities),
|
|
module_functions_(),
|
|
module_capabilities_(),
|
|
module_extensions_(),
|
|
ordered_instructions_(),
|
|
all_definitions_(),
|
|
global_vars_(),
|
|
local_vars_(),
|
|
struct_nesting_depth_(),
|
|
struct_has_nested_blockorbufferblock_struct_(),
|
|
grammar_(ctx),
|
|
addressing_model_(SpvAddressingModelMax),
|
|
memory_model_(SpvMemoryModelMax),
|
|
pointer_size_and_alignment_(0),
|
|
in_function_(false),
|
|
num_of_warnings_(0),
|
|
max_num_of_warnings_(max_warnings) {
|
|
assert(opt && "Validator options may not be Null.");
|
|
|
|
const auto env = context_->target_env;
|
|
|
|
if (spvIsVulkanEnv(env)) {
|
|
// Vulkan 1.1 includes VK_KHR_relaxed_block_layout in core.
|
|
if (env != SPV_ENV_VULKAN_1_0) {
|
|
features_.env_relaxed_block_layout = true;
|
|
}
|
|
}
|
|
|
|
// Only attempt to count if we have words, otherwise let the other validation
|
|
// fail and generate an error.
|
|
if (num_words > 0) {
|
|
// Count the number of instructions in the binary.
|
|
// This parse should not produce any error messages. Hijack the context and
|
|
// replace the message consumer so that we do not pollute any state in input
|
|
// consumer.
|
|
spv_context_t hijacked_context = *ctx;
|
|
hijacked_context.consumer = [](spv_message_level_t, const char*,
|
|
const spv_position_t&, const char*) {};
|
|
spvBinaryParse(&hijacked_context, this, words, num_words, setHeader,
|
|
CountInstructions,
|
|
/* diagnostic = */ nullptr);
|
|
preallocateStorage();
|
|
}
|
|
UpdateFeaturesBasedOnSpirvVersion(&features_, version_);
|
|
|
|
friendly_mapper_ = spvtools::MakeUnique<spvtools::FriendlyNameMapper>(
|
|
context_, words_, num_words_);
|
|
name_mapper_ = friendly_mapper_->GetNameMapper();
|
|
}
|
|
|
|
void ValidationState_t::preallocateStorage() {
|
|
ordered_instructions_.reserve(total_instructions_);
|
|
module_functions_.reserve(total_functions_);
|
|
}
|
|
|
|
spv_result_t ValidationState_t::ForwardDeclareId(uint32_t id) {
|
|
unresolved_forward_ids_.insert(id);
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t ValidationState_t::RemoveIfForwardDeclared(uint32_t id) {
|
|
unresolved_forward_ids_.erase(id);
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t ValidationState_t::RegisterForwardPointer(uint32_t id) {
|
|
forward_pointer_ids_.insert(id);
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
bool ValidationState_t::IsForwardPointer(uint32_t id) const {
|
|
return (forward_pointer_ids_.find(id) != forward_pointer_ids_.end());
|
|
}
|
|
|
|
void ValidationState_t::AssignNameToId(uint32_t id, std::string name) {
|
|
operand_names_[id] = name;
|
|
}
|
|
|
|
std::string ValidationState_t::getIdName(uint32_t id) const {
|
|
const std::string id_name = name_mapper_(id);
|
|
|
|
std::stringstream out;
|
|
out << id << "[%" << id_name << "]";
|
|
return out.str();
|
|
}
|
|
|
|
size_t ValidationState_t::unresolved_forward_id_count() const {
|
|
return unresolved_forward_ids_.size();
|
|
}
|
|
|
|
std::vector<uint32_t> ValidationState_t::UnresolvedForwardIds() const {
|
|
std::vector<uint32_t> out(std::begin(unresolved_forward_ids_),
|
|
std::end(unresolved_forward_ids_));
|
|
return out;
|
|
}
|
|
|
|
bool ValidationState_t::IsDefinedId(uint32_t id) const {
|
|
return all_definitions_.find(id) != std::end(all_definitions_);
|
|
}
|
|
|
|
const Instruction* ValidationState_t::FindDef(uint32_t id) const {
|
|
auto it = all_definitions_.find(id);
|
|
if (it == all_definitions_.end()) return nullptr;
|
|
return it->second;
|
|
}
|
|
|
|
Instruction* ValidationState_t::FindDef(uint32_t id) {
|
|
auto it = all_definitions_.find(id);
|
|
if (it == all_definitions_.end()) return nullptr;
|
|
return it->second;
|
|
}
|
|
|
|
ModuleLayoutSection ValidationState_t::current_layout_section() const {
|
|
return current_layout_section_;
|
|
}
|
|
|
|
void ValidationState_t::ProgressToNextLayoutSectionOrder() {
|
|
// Guard against going past the last element(kLayoutFunctionDefinitions)
|
|
if (current_layout_section_ <= kLayoutFunctionDefinitions) {
|
|
current_layout_section_ =
|
|
static_cast<ModuleLayoutSection>(current_layout_section_ + 1);
|
|
}
|
|
}
|
|
|
|
bool ValidationState_t::IsOpcodeInPreviousLayoutSection(SpvOp op) {
|
|
ModuleLayoutSection section =
|
|
InstructionLayoutSection(current_layout_section_, op);
|
|
return section < current_layout_section_;
|
|
}
|
|
|
|
bool ValidationState_t::IsOpcodeInCurrentLayoutSection(SpvOp op) {
|
|
return IsInstructionInLayoutSection(current_layout_section_, op);
|
|
}
|
|
|
|
DiagnosticStream ValidationState_t::diag(spv_result_t error_code,
|
|
const Instruction* inst) {
|
|
if (error_code == SPV_WARNING) {
|
|
if (num_of_warnings_ == max_num_of_warnings_) {
|
|
DiagnosticStream({0, 0, 0}, context_->consumer, "", error_code)
|
|
<< "Other warnings have been suppressed.\n";
|
|
}
|
|
if (num_of_warnings_ >= max_num_of_warnings_) {
|
|
return DiagnosticStream({0, 0, 0}, nullptr, "", error_code);
|
|
}
|
|
++num_of_warnings_;
|
|
}
|
|
|
|
std::string disassembly;
|
|
if (inst) disassembly = Disassemble(*inst);
|
|
|
|
return DiagnosticStream({0, 0, inst ? inst->LineNum() : 0},
|
|
context_->consumer, disassembly, error_code);
|
|
}
|
|
|
|
std::vector<Function>& ValidationState_t::functions() {
|
|
return module_functions_;
|
|
}
|
|
|
|
Function& ValidationState_t::current_function() {
|
|
assert(in_function_body());
|
|
return module_functions_.back();
|
|
}
|
|
|
|
const Function& ValidationState_t::current_function() const {
|
|
assert(in_function_body());
|
|
return module_functions_.back();
|
|
}
|
|
|
|
const Function* ValidationState_t::function(uint32_t id) const {
|
|
const auto it = id_to_function_.find(id);
|
|
if (it == id_to_function_.end()) return nullptr;
|
|
return it->second;
|
|
}
|
|
|
|
Function* ValidationState_t::function(uint32_t id) {
|
|
auto it = id_to_function_.find(id);
|
|
if (it == id_to_function_.end()) return nullptr;
|
|
return it->second;
|
|
}
|
|
|
|
bool ValidationState_t::in_function_body() const { return in_function_; }
|
|
|
|
bool ValidationState_t::in_block() const {
|
|
return module_functions_.empty() == false &&
|
|
module_functions_.back().current_block() != nullptr;
|
|
}
|
|
|
|
void ValidationState_t::RegisterCapability(SpvCapability cap) {
|
|
// Avoid redundant work. Otherwise the recursion could induce work
|
|
// quadrdatic in the capability dependency depth. (Ok, not much, but
|
|
// it's something.)
|
|
if (module_capabilities_.Contains(cap)) return;
|
|
|
|
module_capabilities_.Add(cap);
|
|
spv_operand_desc desc;
|
|
if (SPV_SUCCESS ==
|
|
grammar_.lookupOperand(SPV_OPERAND_TYPE_CAPABILITY, cap, &desc)) {
|
|
CapabilitySet(desc->numCapabilities, desc->capabilities)
|
|
.ForEach([this](SpvCapability c) { RegisterCapability(c); });
|
|
}
|
|
|
|
switch (cap) {
|
|
case SpvCapabilityKernel:
|
|
features_.group_ops_reduce_and_scans = true;
|
|
break;
|
|
case SpvCapabilityInt8:
|
|
features_.use_int8_type = true;
|
|
features_.declare_int8_type = true;
|
|
break;
|
|
case SpvCapabilityStorageBuffer8BitAccess:
|
|
case SpvCapabilityUniformAndStorageBuffer8BitAccess:
|
|
case SpvCapabilityStoragePushConstant8:
|
|
case SpvCapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR:
|
|
features_.declare_int8_type = true;
|
|
break;
|
|
case SpvCapabilityInt16:
|
|
features_.declare_int16_type = true;
|
|
break;
|
|
case SpvCapabilityFloat16:
|
|
case SpvCapabilityFloat16Buffer:
|
|
features_.declare_float16_type = true;
|
|
break;
|
|
case SpvCapabilityStorageUniformBufferBlock16:
|
|
case SpvCapabilityStorageUniform16:
|
|
case SpvCapabilityStoragePushConstant16:
|
|
case SpvCapabilityStorageInputOutput16:
|
|
case SpvCapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR:
|
|
features_.declare_int16_type = true;
|
|
features_.declare_float16_type = true;
|
|
features_.free_fp_rounding_mode = true;
|
|
break;
|
|
case SpvCapabilityVariablePointers:
|
|
features_.variable_pointers = true;
|
|
features_.variable_pointers_storage_buffer = true;
|
|
break;
|
|
case SpvCapabilityVariablePointersStorageBuffer:
|
|
features_.variable_pointers_storage_buffer = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ValidationState_t::RegisterExtension(Extension ext) {
|
|
if (module_extensions_.Contains(ext)) return;
|
|
|
|
module_extensions_.Add(ext);
|
|
|
|
switch (ext) {
|
|
case kSPV_AMD_gpu_shader_half_float:
|
|
case kSPV_AMD_gpu_shader_half_float_fetch:
|
|
// SPV_AMD_gpu_shader_half_float enables float16 type.
|
|
// https://github.com/KhronosGroup/SPIRV-Tools/issues/1375
|
|
features_.declare_float16_type = true;
|
|
break;
|
|
case kSPV_AMD_gpu_shader_int16:
|
|
// This is not yet in the extension, but it's recommended for it.
|
|
// See https://github.com/KhronosGroup/glslang/issues/848
|
|
features_.uconvert_spec_constant_op = true;
|
|
break;
|
|
case kSPV_AMD_shader_ballot:
|
|
// The grammar doesn't encode the fact that SPV_AMD_shader_ballot
|
|
// enables the use of group operations Reduce, InclusiveScan,
|
|
// and ExclusiveScan. Enable it manually.
|
|
// https://github.com/KhronosGroup/SPIRV-Tools/issues/991
|
|
features_.group_ops_reduce_and_scans = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool ValidationState_t::HasAnyOfCapabilities(
|
|
const CapabilitySet& capabilities) const {
|
|
return module_capabilities_.HasAnyOf(capabilities);
|
|
}
|
|
|
|
bool ValidationState_t::HasAnyOfExtensions(
|
|
const ExtensionSet& extensions) const {
|
|
return module_extensions_.HasAnyOf(extensions);
|
|
}
|
|
|
|
void ValidationState_t::set_addressing_model(SpvAddressingModel am) {
|
|
addressing_model_ = am;
|
|
switch (am) {
|
|
case SpvAddressingModelPhysical32:
|
|
pointer_size_and_alignment_ = 4;
|
|
break;
|
|
default:
|
|
// fall through
|
|
case SpvAddressingModelPhysical64:
|
|
case SpvAddressingModelPhysicalStorageBuffer64EXT:
|
|
pointer_size_and_alignment_ = 8;
|
|
break;
|
|
}
|
|
}
|
|
|
|
SpvAddressingModel ValidationState_t::addressing_model() const {
|
|
return addressing_model_;
|
|
}
|
|
|
|
void ValidationState_t::set_memory_model(SpvMemoryModel mm) {
|
|
memory_model_ = mm;
|
|
}
|
|
|
|
SpvMemoryModel ValidationState_t::memory_model() const { return memory_model_; }
|
|
|
|
spv_result_t ValidationState_t::RegisterFunction(
|
|
uint32_t id, uint32_t ret_type_id, SpvFunctionControlMask function_control,
|
|
uint32_t function_type_id) {
|
|
assert(in_function_body() == false &&
|
|
"RegisterFunction can only be called when parsing the binary outside "
|
|
"of another function");
|
|
in_function_ = true;
|
|
module_functions_.emplace_back(id, ret_type_id, function_control,
|
|
function_type_id);
|
|
id_to_function_.emplace(id, ¤t_function());
|
|
|
|
// TODO(umar): validate function type and type_id
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t ValidationState_t::RegisterFunctionEnd() {
|
|
assert(in_function_body() == true &&
|
|
"RegisterFunctionEnd can only be called when parsing the binary "
|
|
"inside of another function");
|
|
assert(in_block() == false &&
|
|
"RegisterFunctionParameter can only be called when parsing the binary "
|
|
"ouside of a block");
|
|
current_function().RegisterFunctionEnd();
|
|
in_function_ = false;
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
Instruction* ValidationState_t::AddOrderedInstruction(
|
|
const spv_parsed_instruction_t* inst) {
|
|
ordered_instructions_.emplace_back(inst);
|
|
ordered_instructions_.back().SetLineNum(ordered_instructions_.size());
|
|
return &ordered_instructions_.back();
|
|
}
|
|
|
|
// Improves diagnostic messages by collecting names of IDs
|
|
void ValidationState_t::RegisterDebugInstruction(const Instruction* inst) {
|
|
switch (inst->opcode()) {
|
|
case SpvOpName: {
|
|
const auto target = inst->GetOperandAs<uint32_t>(0);
|
|
const auto* str = reinterpret_cast<const char*>(inst->words().data() +
|
|
inst->operand(1).offset);
|
|
AssignNameToId(target, str);
|
|
break;
|
|
}
|
|
case SpvOpMemberName: {
|
|
const auto target = inst->GetOperandAs<uint32_t>(0);
|
|
const auto* str = reinterpret_cast<const char*>(inst->words().data() +
|
|
inst->operand(2).offset);
|
|
AssignNameToId(target, str);
|
|
break;
|
|
}
|
|
case SpvOpSourceContinued:
|
|
case SpvOpSource:
|
|
case SpvOpSourceExtension:
|
|
case SpvOpString:
|
|
case SpvOpLine:
|
|
case SpvOpNoLine:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ValidationState_t::RegisterInstruction(Instruction* inst) {
|
|
if (inst->id()) all_definitions_.insert(std::make_pair(inst->id(), inst));
|
|
|
|
// If the instruction is using an OpTypeSampledImage as an operand, it should
|
|
// be recorded. The validator will ensure that all usages of an
|
|
// OpTypeSampledImage and its definition are in the same basic block.
|
|
for (uint16_t i = 0; i < inst->operands().size(); ++i) {
|
|
const spv_parsed_operand_t& operand = inst->operand(i);
|
|
if (SPV_OPERAND_TYPE_ID == operand.type) {
|
|
const uint32_t operand_word = inst->word(operand.offset);
|
|
Instruction* operand_inst = FindDef(operand_word);
|
|
if (operand_inst && SpvOpSampledImage == operand_inst->opcode()) {
|
|
RegisterSampledImageConsumer(operand_word, inst);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<Instruction*> ValidationState_t::getSampledImageConsumers(
|
|
uint32_t sampled_image_id) const {
|
|
std::vector<Instruction*> result;
|
|
auto iter = sampled_image_consumers_.find(sampled_image_id);
|
|
if (iter != sampled_image_consumers_.end()) {
|
|
result = iter->second;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void ValidationState_t::RegisterSampledImageConsumer(uint32_t sampled_image_id,
|
|
Instruction* consumer) {
|
|
sampled_image_consumers_[sampled_image_id].push_back(consumer);
|
|
}
|
|
|
|
uint32_t ValidationState_t::getIdBound() const { return id_bound_; }
|
|
|
|
void ValidationState_t::setIdBound(const uint32_t bound) { id_bound_ = bound; }
|
|
|
|
bool ValidationState_t::RegisterUniqueTypeDeclaration(const Instruction* inst) {
|
|
std::vector<uint32_t> key;
|
|
key.push_back(static_cast<uint32_t>(inst->opcode()));
|
|
for (size_t index = 0; index < inst->operands().size(); ++index) {
|
|
const spv_parsed_operand_t& operand = inst->operand(index);
|
|
|
|
if (operand.type == SPV_OPERAND_TYPE_RESULT_ID) continue;
|
|
|
|
const int words_begin = operand.offset;
|
|
const int words_end = words_begin + operand.num_words;
|
|
assert(words_end <= static_cast<int>(inst->words().size()));
|
|
|
|
key.insert(key.end(), inst->words().begin() + words_begin,
|
|
inst->words().begin() + words_end);
|
|
}
|
|
|
|
return unique_type_declarations_.insert(std::move(key)).second;
|
|
}
|
|
|
|
uint32_t ValidationState_t::GetTypeId(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
return inst ? inst->type_id() : 0;
|
|
}
|
|
|
|
SpvOp ValidationState_t::GetIdOpcode(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
return inst ? inst->opcode() : SpvOpNop;
|
|
}
|
|
|
|
uint32_t ValidationState_t::GetComponentType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
switch (inst->opcode()) {
|
|
case SpvOpTypeFloat:
|
|
case SpvOpTypeInt:
|
|
case SpvOpTypeBool:
|
|
return id;
|
|
|
|
case SpvOpTypeVector:
|
|
return inst->word(2);
|
|
|
|
case SpvOpTypeMatrix:
|
|
return GetComponentType(inst->word(2));
|
|
|
|
case SpvOpTypeCooperativeMatrixNV:
|
|
return inst->word(2);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (inst->type_id()) return GetComponentType(inst->type_id());
|
|
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
uint32_t ValidationState_t::GetDimension(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
switch (inst->opcode()) {
|
|
case SpvOpTypeFloat:
|
|
case SpvOpTypeInt:
|
|
case SpvOpTypeBool:
|
|
return 1;
|
|
|
|
case SpvOpTypeVector:
|
|
case SpvOpTypeMatrix:
|
|
return inst->word(3);
|
|
|
|
case SpvOpTypeCooperativeMatrixNV:
|
|
// Actual dimension isn't known, return 0
|
|
return 0;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (inst->type_id()) return GetDimension(inst->type_id());
|
|
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
uint32_t ValidationState_t::GetBitWidth(uint32_t id) const {
|
|
const uint32_t component_type_id = GetComponentType(id);
|
|
const Instruction* inst = FindDef(component_type_id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeFloat || inst->opcode() == SpvOpTypeInt)
|
|
return inst->word(2);
|
|
|
|
if (inst->opcode() == SpvOpTypeBool) return 1;
|
|
|
|
assert(0);
|
|
return 0;
|
|
}
|
|
|
|
bool ValidationState_t::IsVoidType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
return inst->opcode() == SpvOpTypeVoid;
|
|
}
|
|
|
|
bool ValidationState_t::IsFloatScalarType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
return inst->opcode() == SpvOpTypeFloat;
|
|
}
|
|
|
|
bool ValidationState_t::IsFloatVectorType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeVector) {
|
|
return IsFloatScalarType(GetComponentType(id));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::IsFloatScalarOrVectorType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeFloat) {
|
|
return true;
|
|
}
|
|
|
|
if (inst->opcode() == SpvOpTypeVector) {
|
|
return IsFloatScalarType(GetComponentType(id));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::IsIntScalarType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
return inst->opcode() == SpvOpTypeInt;
|
|
}
|
|
|
|
bool ValidationState_t::IsIntVectorType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeVector) {
|
|
return IsIntScalarType(GetComponentType(id));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::IsIntScalarOrVectorType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeInt) {
|
|
return true;
|
|
}
|
|
|
|
if (inst->opcode() == SpvOpTypeVector) {
|
|
return IsIntScalarType(GetComponentType(id));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::IsUnsignedIntScalarType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
return inst->opcode() == SpvOpTypeInt && inst->word(3) == 0;
|
|
}
|
|
|
|
bool ValidationState_t::IsUnsignedIntVectorType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeVector) {
|
|
return IsUnsignedIntScalarType(GetComponentType(id));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::IsSignedIntScalarType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
return inst->opcode() == SpvOpTypeInt && inst->word(3) == 1;
|
|
}
|
|
|
|
bool ValidationState_t::IsSignedIntVectorType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeVector) {
|
|
return IsSignedIntScalarType(GetComponentType(id));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::IsBoolScalarType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
return inst->opcode() == SpvOpTypeBool;
|
|
}
|
|
|
|
bool ValidationState_t::IsBoolVectorType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeVector) {
|
|
return IsBoolScalarType(GetComponentType(id));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::IsBoolScalarOrVectorType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeBool) {
|
|
return true;
|
|
}
|
|
|
|
if (inst->opcode() == SpvOpTypeVector) {
|
|
return IsBoolScalarType(GetComponentType(id));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::IsFloatMatrixType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
|
|
if (inst->opcode() == SpvOpTypeMatrix) {
|
|
return IsFloatScalarType(GetComponentType(id));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::GetMatrixTypeInfo(uint32_t id, uint32_t* num_rows,
|
|
uint32_t* num_cols,
|
|
uint32_t* column_type,
|
|
uint32_t* component_type) const {
|
|
if (!id) return false;
|
|
|
|
const Instruction* mat_inst = FindDef(id);
|
|
assert(mat_inst);
|
|
if (mat_inst->opcode() != SpvOpTypeMatrix) return false;
|
|
|
|
const uint32_t vec_type = mat_inst->word(2);
|
|
const Instruction* vec_inst = FindDef(vec_type);
|
|
assert(vec_inst);
|
|
|
|
if (vec_inst->opcode() != SpvOpTypeVector) {
|
|
assert(0);
|
|
return false;
|
|
}
|
|
|
|
*num_cols = mat_inst->word(3);
|
|
*num_rows = vec_inst->word(3);
|
|
*column_type = mat_inst->word(2);
|
|
*component_type = vec_inst->word(2);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ValidationState_t::GetStructMemberTypes(
|
|
uint32_t struct_type_id, std::vector<uint32_t>* member_types) const {
|
|
member_types->clear();
|
|
if (!struct_type_id) return false;
|
|
|
|
const Instruction* inst = FindDef(struct_type_id);
|
|
assert(inst);
|
|
if (inst->opcode() != SpvOpTypeStruct) return false;
|
|
|
|
*member_types =
|
|
std::vector<uint32_t>(inst->words().cbegin() + 2, inst->words().cend());
|
|
|
|
if (member_types->empty()) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ValidationState_t::IsPointerType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
return inst->opcode() == SpvOpTypePointer;
|
|
}
|
|
|
|
bool ValidationState_t::GetPointerTypeInfo(uint32_t id, uint32_t* data_type,
|
|
uint32_t* storage_class) const {
|
|
if (!id) return false;
|
|
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
if (inst->opcode() != SpvOpTypePointer) return false;
|
|
|
|
*storage_class = inst->word(2);
|
|
*data_type = inst->word(3);
|
|
return true;
|
|
}
|
|
|
|
bool ValidationState_t::IsCooperativeMatrixType(uint32_t id) const {
|
|
const Instruction* inst = FindDef(id);
|
|
assert(inst);
|
|
return inst->opcode() == SpvOpTypeCooperativeMatrixNV;
|
|
}
|
|
|
|
bool ValidationState_t::IsFloatCooperativeMatrixType(uint32_t id) const {
|
|
if (!IsCooperativeMatrixType(id)) return false;
|
|
return IsFloatScalarType(FindDef(id)->word(2));
|
|
}
|
|
|
|
bool ValidationState_t::IsIntCooperativeMatrixType(uint32_t id) const {
|
|
if (!IsCooperativeMatrixType(id)) return false;
|
|
return IsIntScalarType(FindDef(id)->word(2));
|
|
}
|
|
|
|
bool ValidationState_t::IsUnsignedIntCooperativeMatrixType(uint32_t id) const {
|
|
if (!IsCooperativeMatrixType(id)) return false;
|
|
return IsUnsignedIntScalarType(FindDef(id)->word(2));
|
|
}
|
|
|
|
spv_result_t ValidationState_t::CooperativeMatrixShapesMatch(
|
|
const Instruction* inst, uint32_t m1, uint32_t m2) {
|
|
const auto m1_type = FindDef(m1);
|
|
const auto m2_type = FindDef(m2);
|
|
|
|
if (m1_type->opcode() != SpvOpTypeCooperativeMatrixNV ||
|
|
m2_type->opcode() != SpvOpTypeCooperativeMatrixNV) {
|
|
return diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Expected cooperative matrix types";
|
|
}
|
|
|
|
uint32_t m1_scope_id = m1_type->GetOperandAs<uint32_t>(2);
|
|
uint32_t m1_rows_id = m1_type->GetOperandAs<uint32_t>(3);
|
|
uint32_t m1_cols_id = m1_type->GetOperandAs<uint32_t>(4);
|
|
|
|
uint32_t m2_scope_id = m2_type->GetOperandAs<uint32_t>(2);
|
|
uint32_t m2_rows_id = m2_type->GetOperandAs<uint32_t>(3);
|
|
uint32_t m2_cols_id = m2_type->GetOperandAs<uint32_t>(4);
|
|
|
|
bool m1_is_int32 = false, m1_is_const_int32 = false, m2_is_int32 = false,
|
|
m2_is_const_int32 = false;
|
|
uint32_t m1_value = 0, m2_value = 0;
|
|
|
|
std::tie(m1_is_int32, m1_is_const_int32, m1_value) =
|
|
EvalInt32IfConst(m1_scope_id);
|
|
std::tie(m2_is_int32, m2_is_const_int32, m2_value) =
|
|
EvalInt32IfConst(m2_scope_id);
|
|
|
|
if (m1_is_const_int32 && m2_is_const_int32 && m1_value != m2_value) {
|
|
return diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Expected scopes of Matrix and Result Type to be "
|
|
<< "identical";
|
|
}
|
|
|
|
std::tie(m1_is_int32, m1_is_const_int32, m1_value) =
|
|
EvalInt32IfConst(m1_rows_id);
|
|
std::tie(m2_is_int32, m2_is_const_int32, m2_value) =
|
|
EvalInt32IfConst(m2_rows_id);
|
|
|
|
if (m1_is_const_int32 && m2_is_const_int32 && m1_value != m2_value) {
|
|
return diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Expected rows of Matrix type and Result Type to be "
|
|
<< "identical";
|
|
}
|
|
|
|
std::tie(m1_is_int32, m1_is_const_int32, m1_value) =
|
|
EvalInt32IfConst(m1_cols_id);
|
|
std::tie(m2_is_int32, m2_is_const_int32, m2_value) =
|
|
EvalInt32IfConst(m2_cols_id);
|
|
|
|
if (m1_is_const_int32 && m2_is_const_int32 && m1_value != m2_value) {
|
|
return diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Expected columns of Matrix type and Result Type to be "
|
|
<< "identical";
|
|
}
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
uint32_t ValidationState_t::GetOperandTypeId(const Instruction* inst,
|
|
size_t operand_index) const {
|
|
return GetTypeId(inst->GetOperandAs<uint32_t>(operand_index));
|
|
}
|
|
|
|
bool ValidationState_t::GetConstantValUint64(uint32_t id, uint64_t* val) const {
|
|
const Instruction* inst = FindDef(id);
|
|
if (!inst) {
|
|
assert(0 && "Instruction not found");
|
|
return false;
|
|
}
|
|
|
|
if (inst->opcode() != SpvOpConstant && inst->opcode() != SpvOpSpecConstant)
|
|
return false;
|
|
|
|
if (!IsIntScalarType(inst->type_id())) return false;
|
|
|
|
if (inst->words().size() == 4) {
|
|
*val = inst->word(3);
|
|
} else {
|
|
assert(inst->words().size() == 5);
|
|
*val = inst->word(3);
|
|
*val |= uint64_t(inst->word(4)) << 32;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::tuple<bool, bool, uint32_t> ValidationState_t::EvalInt32IfConst(
|
|
uint32_t id) const {
|
|
const Instruction* const inst = FindDef(id);
|
|
assert(inst);
|
|
const uint32_t type = inst->type_id();
|
|
|
|
if (type == 0 || !IsIntScalarType(type) || GetBitWidth(type) != 32) {
|
|
return std::make_tuple(false, false, 0);
|
|
}
|
|
|
|
// Spec constant values cannot be evaluated so don't consider constant for
|
|
// the purpose of this method.
|
|
if (!spvOpcodeIsConstant(inst->opcode()) ||
|
|
spvOpcodeIsSpecConstant(inst->opcode())) {
|
|
return std::make_tuple(true, false, 0);
|
|
}
|
|
|
|
if (inst->opcode() == SpvOpConstantNull) {
|
|
return std::make_tuple(true, true, 0);
|
|
}
|
|
|
|
assert(inst->words().size() == 4);
|
|
return std::make_tuple(true, true, inst->word(3));
|
|
}
|
|
|
|
void ValidationState_t::ComputeFunctionToEntryPointMapping() {
|
|
for (const uint32_t entry_point : entry_points()) {
|
|
std::stack<uint32_t> call_stack;
|
|
std::set<uint32_t> visited;
|
|
call_stack.push(entry_point);
|
|
while (!call_stack.empty()) {
|
|
const uint32_t called_func_id = call_stack.top();
|
|
call_stack.pop();
|
|
if (!visited.insert(called_func_id).second) continue;
|
|
|
|
function_to_entry_points_[called_func_id].push_back(entry_point);
|
|
|
|
const Function* called_func = function(called_func_id);
|
|
if (called_func) {
|
|
// Other checks should error out on this invalid SPIR-V.
|
|
for (const uint32_t new_call : called_func->function_call_targets()) {
|
|
call_stack.push(new_call);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ValidationState_t::ComputeRecursiveEntryPoints() {
|
|
for (const Function& func : functions()) {
|
|
std::stack<uint32_t> call_stack;
|
|
std::set<uint32_t> visited;
|
|
|
|
for (const uint32_t new_call : func.function_call_targets()) {
|
|
call_stack.push(new_call);
|
|
}
|
|
|
|
while (!call_stack.empty()) {
|
|
const uint32_t called_func_id = call_stack.top();
|
|
call_stack.pop();
|
|
|
|
if (!visited.insert(called_func_id).second) continue;
|
|
|
|
if (called_func_id == func.id()) {
|
|
for (const uint32_t entry_point :
|
|
function_to_entry_points_[called_func_id])
|
|
recursive_entry_points_.insert(entry_point);
|
|
break;
|
|
}
|
|
|
|
const Function* called_func = function(called_func_id);
|
|
if (called_func) {
|
|
// Other checks should error out on this invalid SPIR-V.
|
|
for (const uint32_t new_call : called_func->function_call_targets()) {
|
|
call_stack.push(new_call);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const std::vector<uint32_t>& ValidationState_t::FunctionEntryPoints(
|
|
uint32_t func) const {
|
|
auto iter = function_to_entry_points_.find(func);
|
|
if (iter == function_to_entry_points_.end()) {
|
|
return empty_ids_;
|
|
} else {
|
|
return iter->second;
|
|
}
|
|
}
|
|
|
|
std::set<uint32_t> ValidationState_t::EntryPointReferences(uint32_t id) const {
|
|
std::set<uint32_t> referenced_entry_points;
|
|
const auto inst = FindDef(id);
|
|
if (!inst) return referenced_entry_points;
|
|
|
|
std::vector<const Instruction*> stack;
|
|
stack.push_back(inst);
|
|
while (!stack.empty()) {
|
|
const auto current_inst = stack.back();
|
|
stack.pop_back();
|
|
|
|
if (const auto func = current_inst->function()) {
|
|
// Instruction lives in a function, we can stop searching.
|
|
const auto function_entry_points = FunctionEntryPoints(func->id());
|
|
referenced_entry_points.insert(function_entry_points.begin(),
|
|
function_entry_points.end());
|
|
} else {
|
|
// Instruction is in the global scope, keep searching its uses.
|
|
for (auto pair : current_inst->uses()) {
|
|
const auto next_inst = pair.first;
|
|
stack.push_back(next_inst);
|
|
}
|
|
}
|
|
}
|
|
|
|
return referenced_entry_points;
|
|
}
|
|
|
|
std::string ValidationState_t::Disassemble(const Instruction& inst) const {
|
|
const spv_parsed_instruction_t& c_inst(inst.c_inst());
|
|
return Disassemble(c_inst.words, c_inst.num_words);
|
|
}
|
|
|
|
std::string ValidationState_t::Disassemble(const uint32_t* words,
|
|
uint16_t num_words) const {
|
|
uint32_t disassembly_options = SPV_BINARY_TO_TEXT_OPTION_NO_HEADER |
|
|
SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES;
|
|
|
|
return spvInstructionBinaryToText(context()->target_env, words, num_words,
|
|
words_, num_words_, disassembly_options);
|
|
}
|
|
|
|
bool ValidationState_t::LogicallyMatch(const Instruction* lhs,
|
|
const Instruction* rhs,
|
|
bool check_decorations) {
|
|
if (lhs->opcode() != rhs->opcode()) {
|
|
return false;
|
|
}
|
|
|
|
if (check_decorations) {
|
|
const auto& dec_a = id_decorations(lhs->id());
|
|
const auto& dec_b = id_decorations(rhs->id());
|
|
|
|
for (const auto& dec : dec_b) {
|
|
if (std::find(dec_a.begin(), dec_a.end(), dec) == dec_a.end()) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (lhs->opcode() == SpvOpTypeArray) {
|
|
// Size operands must match.
|
|
if (lhs->GetOperandAs<uint32_t>(2u) != rhs->GetOperandAs<uint32_t>(2u)) {
|
|
return false;
|
|
}
|
|
|
|
// Elements must match or logically match.
|
|
const auto lhs_ele_id = lhs->GetOperandAs<uint32_t>(1u);
|
|
const auto rhs_ele_id = rhs->GetOperandAs<uint32_t>(1u);
|
|
if (lhs_ele_id == rhs_ele_id) {
|
|
return true;
|
|
}
|
|
|
|
const auto lhs_ele = FindDef(lhs_ele_id);
|
|
const auto rhs_ele = FindDef(rhs_ele_id);
|
|
if (!lhs_ele || !rhs_ele) {
|
|
return false;
|
|
}
|
|
return LogicallyMatch(lhs_ele, rhs_ele, check_decorations);
|
|
} else if (lhs->opcode() == SpvOpTypeStruct) {
|
|
// Number of elements must match.
|
|
if (lhs->operands().size() != rhs->operands().size()) {
|
|
return false;
|
|
}
|
|
|
|
for (size_t i = 1u; i < lhs->operands().size(); ++i) {
|
|
const auto lhs_ele_id = lhs->GetOperandAs<uint32_t>(i);
|
|
const auto rhs_ele_id = rhs->GetOperandAs<uint32_t>(i);
|
|
// Elements must match or logically match.
|
|
if (lhs_ele_id == rhs_ele_id) {
|
|
continue;
|
|
}
|
|
|
|
const auto lhs_ele = FindDef(lhs_ele_id);
|
|
const auto rhs_ele = FindDef(rhs_ele_id);
|
|
if (!lhs_ele || !rhs_ele) {
|
|
return false;
|
|
}
|
|
|
|
if (!LogicallyMatch(lhs_ele, rhs_ele, check_decorations)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// All checks passed.
|
|
return true;
|
|
}
|
|
|
|
// No other opcodes are acceptable at this point. Arrays and structs are
|
|
// caught above and if they're elements are not arrays or structs they are
|
|
// required to match exactly.
|
|
return false;
|
|
}
|
|
|
|
const Instruction* ValidationState_t::TracePointer(
|
|
const Instruction* inst) const {
|
|
auto base_ptr = inst;
|
|
while (base_ptr->opcode() == SpvOpAccessChain ||
|
|
base_ptr->opcode() == SpvOpInBoundsAccessChain ||
|
|
base_ptr->opcode() == SpvOpPtrAccessChain ||
|
|
base_ptr->opcode() == SpvOpInBoundsPtrAccessChain ||
|
|
base_ptr->opcode() == SpvOpCopyObject) {
|
|
base_ptr = FindDef(base_ptr->GetOperandAs<uint32_t>(2u));
|
|
}
|
|
return base_ptr;
|
|
}
|
|
|
|
bool ValidationState_t::ContainsSizedIntOrFloatType(uint32_t id, SpvOp type,
|
|
uint32_t width) const {
|
|
if (type != SpvOpTypeInt && type != SpvOpTypeFloat) return false;
|
|
|
|
const auto inst = FindDef(id);
|
|
if (!inst) return false;
|
|
|
|
if (inst->opcode() == type) {
|
|
return inst->GetOperandAs<uint32_t>(1u) == width;
|
|
}
|
|
|
|
switch (inst->opcode()) {
|
|
case SpvOpTypeArray:
|
|
case SpvOpTypeRuntimeArray:
|
|
case SpvOpTypeVector:
|
|
case SpvOpTypeMatrix:
|
|
case SpvOpTypeImage:
|
|
case SpvOpTypeSampledImage:
|
|
case SpvOpTypeCooperativeMatrixNV:
|
|
return ContainsSizedIntOrFloatType(inst->GetOperandAs<uint32_t>(1u), type,
|
|
width);
|
|
case SpvOpTypePointer:
|
|
if (IsForwardPointer(id)) return false;
|
|
return ContainsSizedIntOrFloatType(inst->GetOperandAs<uint32_t>(2u), type,
|
|
width);
|
|
case SpvOpTypeFunction:
|
|
case SpvOpTypeStruct: {
|
|
for (uint32_t i = 1; i < inst->operands().size(); ++i) {
|
|
if (ContainsSizedIntOrFloatType(inst->GetOperandAs<uint32_t>(i), type,
|
|
width))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ValidationState_t::ContainsLimitedUseIntOrFloatType(uint32_t id) const {
|
|
if ((!HasCapability(SpvCapabilityInt16) &&
|
|
ContainsSizedIntOrFloatType(id, SpvOpTypeInt, 16)) ||
|
|
(!HasCapability(SpvCapabilityInt8) &&
|
|
ContainsSizedIntOrFloatType(id, SpvOpTypeInt, 8)) ||
|
|
(!HasCapability(SpvCapabilityFloat16) &&
|
|
ContainsSizedIntOrFloatType(id, SpvOpTypeFloat, 16))) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ValidationState_t::IsValidStorageClass(
|
|
SpvStorageClass storage_class) const {
|
|
if (spvIsVulkanEnv(context()->target_env)) {
|
|
switch (storage_class) {
|
|
case SpvStorageClassUniformConstant:
|
|
case SpvStorageClassUniform:
|
|
case SpvStorageClassStorageBuffer:
|
|
case SpvStorageClassInput:
|
|
case SpvStorageClassOutput:
|
|
case SpvStorageClassImage:
|
|
case SpvStorageClassWorkgroup:
|
|
case SpvStorageClassPrivate:
|
|
case SpvStorageClassFunction:
|
|
case SpvStorageClassPushConstant:
|
|
case SpvStorageClassPhysicalStorageBuffer:
|
|
case SpvStorageClassRayPayloadNV:
|
|
case SpvStorageClassIncomingRayPayloadNV:
|
|
case SpvStorageClassHitAttributeNV:
|
|
case SpvStorageClassCallableDataNV:
|
|
case SpvStorageClassIncomingCallableDataNV:
|
|
case SpvStorageClassShaderRecordBufferNV:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#define VUID_WRAP(vuid) "[" #vuid "] "
|
|
|
|
// Currently no 2 VUID share the same id, so no need for |reference|
|
|
std::string ValidationState_t::VkErrorID(uint32_t id,
|
|
const char* /*reference*/) const {
|
|
if (!spvIsVulkanEnv(context_->target_env)) {
|
|
return "";
|
|
}
|
|
|
|
// This large switch case is only searched when an error has occured.
|
|
// If an id is changed, the old case must be modified or removed. Each string
|
|
// here is interpreted as being "implemented"
|
|
|
|
// Clang format adds spaces between hyphens
|
|
// clang-format off
|
|
switch (id) {
|
|
case 4181:
|
|
return VUID_WRAP(VUID-BaseInstance-BaseInstance-04181);
|
|
case 4182:
|
|
return VUID_WRAP(VUID-BaseInstance-BaseInstance-04182);
|
|
case 4183:
|
|
return VUID_WRAP(VUID-BaseInstance-BaseInstance-04183);
|
|
case 4184:
|
|
return VUID_WRAP(VUID-BaseVertex-BaseVertex-04184);
|
|
case 4185:
|
|
return VUID_WRAP(VUID-BaseVertex-BaseVertex-04185);
|
|
case 4186:
|
|
return VUID_WRAP(VUID-BaseVertex-BaseVertex-04186);
|
|
case 4187:
|
|
return VUID_WRAP(VUID-ClipDistance-ClipDistance-04187);
|
|
case 4188:
|
|
return VUID_WRAP(VUID-ClipDistance-ClipDistance-04188);
|
|
case 4189:
|
|
return VUID_WRAP(VUID-ClipDistance-ClipDistance-04189);
|
|
case 4190:
|
|
return VUID_WRAP(VUID-ClipDistance-ClipDistance-04190);
|
|
case 4191:
|
|
return VUID_WRAP(VUID-ClipDistance-ClipDistance-04191);
|
|
case 4196:
|
|
return VUID_WRAP(VUID-CullDistance-CullDistance-04196);
|
|
case 4197:
|
|
return VUID_WRAP(VUID-CullDistance-CullDistance-04197);
|
|
case 4198:
|
|
return VUID_WRAP(VUID-CullDistance-CullDistance-04198);
|
|
case 4199:
|
|
return VUID_WRAP(VUID-CullDistance-CullDistance-04199);
|
|
case 4200:
|
|
return VUID_WRAP(VUID-CullDistance-CullDistance-04200);
|
|
case 4205:
|
|
return VUID_WRAP(VUID-DeviceIndex-DeviceIndex-04205);
|
|
case 4206:
|
|
return VUID_WRAP(VUID-DeviceIndex-DeviceIndex-04206);
|
|
case 4207:
|
|
return VUID_WRAP(VUID-DrawIndex-DrawIndex-04207);
|
|
case 4208:
|
|
return VUID_WRAP(VUID-DrawIndex-DrawIndex-04208);
|
|
case 4209:
|
|
return VUID_WRAP(VUID-DrawIndex-DrawIndex-04209);
|
|
case 4210:
|
|
return VUID_WRAP(VUID-FragCoord-FragCoord-04210);
|
|
case 4211:
|
|
return VUID_WRAP(VUID-FragCoord-FragCoord-04211);
|
|
case 4212:
|
|
return VUID_WRAP(VUID-FragCoord-FragCoord-04212);
|
|
case 4213:
|
|
return VUID_WRAP(VUID-FragDepth-FragDepth-04213);
|
|
case 4214:
|
|
return VUID_WRAP(VUID-FragDepth-FragDepth-04214);
|
|
case 4215:
|
|
return VUID_WRAP(VUID-FragDepth-FragDepth-04215);
|
|
case 4216:
|
|
return VUID_WRAP(VUID-FragDepth-FragDepth-04216);
|
|
case 4217:
|
|
return VUID_WRAP(VUID-FragInvocationCountEXT-FragInvocationCountEXT-04217);
|
|
case 4218:
|
|
return VUID_WRAP(VUID-FragInvocationCountEXT-FragInvocationCountEXT-04218);
|
|
case 4219:
|
|
return VUID_WRAP(VUID-FragInvocationCountEXT-FragInvocationCountEXT-04219);
|
|
case 4220:
|
|
return VUID_WRAP(VUID-FragSizeEXT-FragSizeEXT-04220);
|
|
case 4221:
|
|
return VUID_WRAP(VUID-FragSizeEXT-FragSizeEXT-04221);
|
|
case 4222:
|
|
return VUID_WRAP(VUID-FragSizeEXT-FragSizeEXT-04222);
|
|
case 4223:
|
|
return VUID_WRAP(VUID-FragStencilRefEXT-FragStencilRefEXT-04223);
|
|
case 4224:
|
|
return VUID_WRAP(VUID-FragStencilRefEXT-FragStencilRefEXT-04224);
|
|
case 4225:
|
|
return VUID_WRAP(VUID-FragStencilRefEXT-FragStencilRefEXT-04225);
|
|
case 4229:
|
|
return VUID_WRAP(VUID-FrontFacing-FrontFacing-04229);
|
|
case 4230:
|
|
return VUID_WRAP(VUID-FrontFacing-FrontFacing-04230);
|
|
case 4231:
|
|
return VUID_WRAP(VUID-FrontFacing-FrontFacing-04231);
|
|
case 4232:
|
|
return VUID_WRAP(VUID-FullyCoveredEXT-FullyCoveredEXT-04232);
|
|
case 4233:
|
|
return VUID_WRAP(VUID-FullyCoveredEXT-FullyCoveredEXT-04233);
|
|
case 4234:
|
|
return VUID_WRAP(VUID-FullyCoveredEXT-FullyCoveredEXT-04234);
|
|
case 4236:
|
|
return VUID_WRAP(VUID-GlobalInvocationId-GlobalInvocationId-04236);
|
|
case 4237:
|
|
return VUID_WRAP(VUID-GlobalInvocationId-GlobalInvocationId-04237);
|
|
case 4238:
|
|
return VUID_WRAP(VUID-GlobalInvocationId-GlobalInvocationId-04238);
|
|
case 4239:
|
|
return VUID_WRAP(VUID-HelperInvocation-HelperInvocation-04239);
|
|
case 4240:
|
|
return VUID_WRAP(VUID-HelperInvocation-HelperInvocation-04240);
|
|
case 4241:
|
|
return VUID_WRAP(VUID-HelperInvocation-HelperInvocation-04241);
|
|
case 4242:
|
|
return VUID_WRAP(VUID-HitKindKHR-HitKindKHR-04242);
|
|
case 4243:
|
|
return VUID_WRAP(VUID-HitKindKHR-HitKindKHR-04243);
|
|
case 4244:
|
|
return VUID_WRAP(VUID-HitKindKHR-HitKindKHR-04244);
|
|
case 4245:
|
|
return VUID_WRAP(VUID-HitTNV-HitTNV-04245);
|
|
case 4246:
|
|
return VUID_WRAP(VUID-HitTNV-HitTNV-04246);
|
|
case 4247:
|
|
return VUID_WRAP(VUID-HitTNV-HitTNV-04247);
|
|
case 4248:
|
|
return VUID_WRAP(VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04248);
|
|
case 4249:
|
|
return VUID_WRAP(VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04249);
|
|
case 4250:
|
|
return VUID_WRAP(VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04250);
|
|
case 4251:
|
|
return VUID_WRAP(VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04251);
|
|
case 4252:
|
|
return VUID_WRAP(VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04252);
|
|
case 4253:
|
|
return VUID_WRAP(VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04253);
|
|
case 4254:
|
|
return VUID_WRAP(VUID-InstanceId-InstanceId-04254);
|
|
case 4255:
|
|
return VUID_WRAP(VUID-InstanceId-InstanceId-04255);
|
|
case 4256:
|
|
return VUID_WRAP(VUID-InstanceId-InstanceId-04256);
|
|
case 4257:
|
|
return VUID_WRAP(VUID-InvocationId-InvocationId-04257);
|
|
case 4258:
|
|
return VUID_WRAP(VUID-InvocationId-InvocationId-04258);
|
|
case 4259:
|
|
return VUID_WRAP(VUID-InvocationId-InvocationId-04259);
|
|
case 4263:
|
|
return VUID_WRAP(VUID-InstanceIndex-InstanceIndex-04263);
|
|
case 4264:
|
|
return VUID_WRAP(VUID-InstanceIndex-InstanceIndex-04264);
|
|
case 4265:
|
|
return VUID_WRAP(VUID-InstanceIndex-InstanceIndex-04265);
|
|
case 4266:
|
|
return VUID_WRAP(VUID-LaunchIdKHR-LaunchIdKHR-04266);
|
|
case 4267:
|
|
return VUID_WRAP(VUID-LaunchIdKHR-LaunchIdKHR-04267);
|
|
case 4268:
|
|
return VUID_WRAP(VUID-LaunchIdKHR-LaunchIdKHR-04268);
|
|
case 4269:
|
|
return VUID_WRAP(VUID-LaunchSizeKHR-LaunchSizeKHR-04269);
|
|
case 4270:
|
|
return VUID_WRAP(VUID-LaunchSizeKHR-LaunchSizeKHR-04270);
|
|
case 4271:
|
|
return VUID_WRAP(VUID-LaunchSizeKHR-LaunchSizeKHR-04271);
|
|
case 4272:
|
|
return VUID_WRAP(VUID-Layer-Layer-04272);
|
|
case 4273:
|
|
return VUID_WRAP(VUID-Layer-Layer-04273);
|
|
case 4274:
|
|
return VUID_WRAP(VUID-Layer-Layer-04274);
|
|
case 4275:
|
|
return VUID_WRAP(VUID-Layer-Layer-04275);
|
|
case 4276:
|
|
return VUID_WRAP(VUID-Layer-Layer-04276);
|
|
case 4281:
|
|
return VUID_WRAP(VUID-LocalInvocationId-LocalInvocationId-04281);
|
|
case 4282:
|
|
return VUID_WRAP(VUID-LocalInvocationId-LocalInvocationId-04282);
|
|
case 4283:
|
|
return VUID_WRAP(VUID-LocalInvocationId-LocalInvocationId-04283);
|
|
case 4293:
|
|
return VUID_WRAP(VUID-NumSubgroups-NumSubgroups-04293);
|
|
case 4294:
|
|
return VUID_WRAP(VUID-NumSubgroups-NumSubgroups-04294);
|
|
case 4295:
|
|
return VUID_WRAP(VUID-NumSubgroups-NumSubgroups-04295);
|
|
case 4296:
|
|
return VUID_WRAP(VUID-NumWorkgroups-NumWorkgroups-04296);
|
|
case 4297:
|
|
return VUID_WRAP(VUID-NumWorkgroups-NumWorkgroups-04297);
|
|
case 4298:
|
|
return VUID_WRAP(VUID-NumWorkgroups-NumWorkgroups-04298);
|
|
case 4299:
|
|
return VUID_WRAP(VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04299);
|
|
case 4300:
|
|
return VUID_WRAP(VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04300);
|
|
case 4301:
|
|
return VUID_WRAP(VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04301);
|
|
case 4302:
|
|
return VUID_WRAP(VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04302);
|
|
case 4303:
|
|
return VUID_WRAP(VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04303);
|
|
case 4304:
|
|
return VUID_WRAP(VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04304);
|
|
case 4305:
|
|
return VUID_WRAP(VUID-ObjectToWorldKHR-ObjectToWorldKHR-04305);
|
|
case 4306:
|
|
return VUID_WRAP(VUID-ObjectToWorldKHR-ObjectToWorldKHR-04306);
|
|
case 4307:
|
|
return VUID_WRAP(VUID-ObjectToWorldKHR-ObjectToWorldKHR-04307);
|
|
case 4308:
|
|
return VUID_WRAP(VUID-PatchVertices-PatchVertices-04308);
|
|
case 4309:
|
|
return VUID_WRAP(VUID-PatchVertices-PatchVertices-04309);
|
|
case 4310:
|
|
return VUID_WRAP(VUID-PatchVertices-PatchVertices-04310);
|
|
case 4311:
|
|
return VUID_WRAP(VUID-PointCoord-PointCoord-04311);
|
|
case 4312:
|
|
return VUID_WRAP(VUID-PointCoord-PointCoord-04312);
|
|
case 4313:
|
|
return VUID_WRAP(VUID-PointCoord-PointCoord-04313);
|
|
case 4314:
|
|
return VUID_WRAP(VUID-PointSize-PointSize-04314);
|
|
case 4315:
|
|
return VUID_WRAP(VUID-PointSize-PointSize-04315);
|
|
case 4316:
|
|
return VUID_WRAP(VUID-PointSize-PointSize-04316);
|
|
case 4317:
|
|
return VUID_WRAP(VUID-PointSize-PointSize-04317);
|
|
case 4318:
|
|
return VUID_WRAP(VUID-Position-Position-04318);
|
|
case 4319:
|
|
return VUID_WRAP(VUID-Position-Position-04319);
|
|
case 4320:
|
|
return VUID_WRAP(VUID-Position-Position-04320);
|
|
case 4321:
|
|
return VUID_WRAP(VUID-Position-Position-04321);
|
|
case 4330:
|
|
return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-04330);
|
|
case 4334:
|
|
return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-04334);
|
|
case 4337:
|
|
return VUID_WRAP(VUID-PrimitiveId-PrimitiveId-04337);
|
|
case 4345:
|
|
return VUID_WRAP(VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04345);
|
|
case 4346:
|
|
return VUID_WRAP(VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04346);
|
|
case 4347:
|
|
return VUID_WRAP(VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04347);
|
|
case 4348:
|
|
return VUID_WRAP(VUID-RayTmaxKHR-RayTmaxKHR-04348);
|
|
case 4349:
|
|
return VUID_WRAP(VUID-RayTmaxKHR-RayTmaxKHR-04349);
|
|
case 4350:
|
|
return VUID_WRAP(VUID-RayTmaxKHR-RayTmaxKHR-04350);
|
|
case 4351:
|
|
return VUID_WRAP(VUID-RayTminKHR-RayTminKHR-04351);
|
|
case 4352:
|
|
return VUID_WRAP(VUID-RayTminKHR-RayTminKHR-04352);
|
|
case 4353:
|
|
return VUID_WRAP(VUID-RayTminKHR-RayTminKHR-04353);
|
|
case 4354:
|
|
return VUID_WRAP(VUID-SampleId-SampleId-04354);
|
|
case 4355:
|
|
return VUID_WRAP(VUID-SampleId-SampleId-04355);
|
|
case 4356:
|
|
return VUID_WRAP(VUID-SampleId-SampleId-04356);
|
|
case 4357:
|
|
return VUID_WRAP(VUID-SampleMask-SampleMask-04357);
|
|
case 4358:
|
|
return VUID_WRAP(VUID-SampleMask-SampleMask-04358);
|
|
case 4359:
|
|
return VUID_WRAP(VUID-SampleMask-SampleMask-04359);
|
|
case 4360:
|
|
return VUID_WRAP(VUID-SamplePosition-SamplePosition-04360);
|
|
case 4361:
|
|
return VUID_WRAP(VUID-SamplePosition-SamplePosition-04361);
|
|
case 4362:
|
|
return VUID_WRAP(VUID-SamplePosition-SamplePosition-04362);
|
|
case 4367:
|
|
return VUID_WRAP(VUID-SubgroupId-SubgroupId-04367);
|
|
case 4368:
|
|
return VUID_WRAP(VUID-SubgroupId-SubgroupId-04368);
|
|
case 4369:
|
|
return VUID_WRAP(VUID-SubgroupId-SubgroupId-04369);
|
|
case 4370:
|
|
return VUID_WRAP(VUID-SubgroupEqMask-SubgroupEqMask-04370);
|
|
case 4371:
|
|
return VUID_WRAP(VUID-SubgroupEqMask-SubgroupEqMask-04371);
|
|
case 4372:
|
|
return VUID_WRAP(VUID-SubgroupGeMask-SubgroupGeMask-04372);
|
|
case 4373:
|
|
return VUID_WRAP(VUID-SubgroupGeMask-SubgroupGeMask-04373);
|
|
case 4374:
|
|
return VUID_WRAP(VUID-SubgroupGtMask-SubgroupGtMask-04374);
|
|
case 4375:
|
|
return VUID_WRAP(VUID-SubgroupGtMask-SubgroupGtMask-04375);
|
|
case 4376:
|
|
return VUID_WRAP(VUID-SubgroupLeMask-SubgroupLeMask-04376);
|
|
case 4377:
|
|
return VUID_WRAP(VUID-SubgroupLeMask-SubgroupLeMask-04377);
|
|
case 4378:
|
|
return VUID_WRAP(VUID-SubgroupLtMask-SubgroupLtMask-04378);
|
|
case 4379:
|
|
return VUID_WRAP(VUID-SubgroupLtMask-SubgroupLtMask-04379);
|
|
case 4380:
|
|
return VUID_WRAP(VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04380);
|
|
case 4381:
|
|
return VUID_WRAP(VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04381);
|
|
case 4382:
|
|
return VUID_WRAP(VUID-SubgroupSize-SubgroupSize-04382);
|
|
case 4383:
|
|
return VUID_WRAP(VUID-SubgroupSize-SubgroupSize-04383);
|
|
case 4387:
|
|
return VUID_WRAP(VUID-TessCoord-TessCoord-04387);
|
|
case 4388:
|
|
return VUID_WRAP(VUID-TessCoord-TessCoord-04388);
|
|
case 4389:
|
|
return VUID_WRAP(VUID-TessCoord-TessCoord-04389);
|
|
case 4390:
|
|
return VUID_WRAP(VUID-TessLevelOuter-TessLevelOuter-04390);
|
|
case 4391:
|
|
return VUID_WRAP(VUID-TessLevelOuter-TessLevelOuter-04391);
|
|
case 4392:
|
|
return VUID_WRAP(VUID-TessLevelOuter-TessLevelOuter-04392);
|
|
case 4393:
|
|
return VUID_WRAP(VUID-TessLevelOuter-TessLevelOuter-04393);
|
|
case 4394:
|
|
return VUID_WRAP(VUID-TessLevelInner-TessLevelInner-04394);
|
|
case 4395:
|
|
return VUID_WRAP(VUID-TessLevelInner-TessLevelInner-04395);
|
|
case 4396:
|
|
return VUID_WRAP(VUID-TessLevelInner-TessLevelInner-04396);
|
|
case 4397:
|
|
return VUID_WRAP(VUID-TessLevelInner-TessLevelInner-04397);
|
|
case 4398:
|
|
return VUID_WRAP(VUID-VertexIndex-VertexIndex-04398);
|
|
case 4399:
|
|
return VUID_WRAP(VUID-VertexIndex-VertexIndex-04399);
|
|
case 4400:
|
|
return VUID_WRAP(VUID-VertexIndex-VertexIndex-04400);
|
|
case 4401:
|
|
return VUID_WRAP(VUID-ViewIndex-ViewIndex-04401);
|
|
case 4402:
|
|
return VUID_WRAP(VUID-ViewIndex-ViewIndex-04402);
|
|
case 4403:
|
|
return VUID_WRAP(VUID-ViewIndex-ViewIndex-04403);
|
|
case 4404:
|
|
return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04404);
|
|
case 4405:
|
|
return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04405);
|
|
case 4406:
|
|
return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04406);
|
|
case 4407:
|
|
return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04407);
|
|
case 4408:
|
|
return VUID_WRAP(VUID-ViewportIndex-ViewportIndex-04408);
|
|
case 4422:
|
|
return VUID_WRAP(VUID-WorkgroupId-WorkgroupId-04422);
|
|
case 4423:
|
|
return VUID_WRAP(VUID-WorkgroupId-WorkgroupId-04423);
|
|
case 4424:
|
|
return VUID_WRAP(VUID-WorkgroupId-WorkgroupId-04424);
|
|
case 4425:
|
|
return VUID_WRAP(VUID-WorkgroupSize-WorkgroupSize-04425);
|
|
case 4426:
|
|
return VUID_WRAP(VUID-WorkgroupSize-WorkgroupSize-04426);
|
|
case 4427:
|
|
return VUID_WRAP(VUID-WorkgroupSize-WorkgroupSize-04427);
|
|
case 4428:
|
|
return VUID_WRAP(VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04428);
|
|
case 4429:
|
|
return VUID_WRAP(VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04429);
|
|
case 4430:
|
|
return VUID_WRAP(VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04430);
|
|
case 4431:
|
|
return VUID_WRAP(VUID-WorldRayOriginKHR-WorldRayOriginKHR-04431);
|
|
case 4432:
|
|
return VUID_WRAP(VUID-WorldRayOriginKHR-WorldRayOriginKHR-04432);
|
|
case 4433:
|
|
return VUID_WRAP(VUID-WorldRayOriginKHR-WorldRayOriginKHR-04433);
|
|
case 4434:
|
|
return VUID_WRAP(VUID-WorldToObjectKHR-WorldToObjectKHR-04434);
|
|
case 4435:
|
|
return VUID_WRAP(VUID-WorldToObjectKHR-WorldToObjectKHR-04435);
|
|
case 4436:
|
|
return VUID_WRAP(VUID-WorldToObjectKHR-WorldToObjectKHR-04436);
|
|
case 4484:
|
|
return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04484);
|
|
case 4485:
|
|
return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04485);
|
|
case 4486:
|
|
return VUID_WRAP(VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04486);
|
|
case 4490:
|
|
return VUID_WRAP(VUID-ShadingRateKHR-ShadingRateKHR-04490);
|
|
case 4491:
|
|
return VUID_WRAP(VUID-ShadingRateKHR-ShadingRateKHR-04491);
|
|
case 4492:
|
|
return VUID_WRAP(VUID-ShadingRateKHR-ShadingRateKHR-04492);
|
|
case 4633:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-None-04633);
|
|
case 4635:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-None-04635);
|
|
case 4638:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-None-04638);
|
|
case 4639:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-None-04639);
|
|
case 4640:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-None-04640);
|
|
case 4642:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-None-04642);
|
|
case 4651:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpVariable-04651);
|
|
case 4652:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpReadClockKHR-04652);
|
|
case 4653:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OriginLowerLeft-04653);
|
|
case 4654:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-PixelCenterInteger-04654);
|
|
case 4656:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpTypeImage-04656);
|
|
case 4657:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpTypeImage-04657);
|
|
case 4658:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpImageTexelPointer-04658);
|
|
case 4659:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpImageQuerySizeLod-04659);
|
|
case 4662:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-Offset-04662);
|
|
case 4663:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-Offset-04663);
|
|
case 4669:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-GLSLShared-04669);
|
|
case 4675:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-FPRoundingMode-04675);
|
|
case 4677:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-Invariant-04677);
|
|
case 4683:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-LocalSize-04683);
|
|
case 4685:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpGroupNonUniformBallotBitCount-04685);
|
|
case 4686:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-None-04686);
|
|
case 4710:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-PhysicalStorageBuffer64-04710);
|
|
case 4711:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpTypeForwardPointer-04711);
|
|
case 4730:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpAtomicStore-04730);
|
|
case 4731:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpAtomicLoad-04731);
|
|
case 4732:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpMemoryBarrier-04732);
|
|
case 4733:
|
|
return VUID_WRAP(VUID-StandaloneSpirv-OpMemoryBarrier-04733);
|
|
default:
|
|
return ""; // unknown id
|
|
};
|
|
// clang-format on
|
|
}
|
|
|
|
} // namespace val
|
|
} // namespace spvtools
|