// 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, spv::Op op) {

  // See Section 2.4

  if (spvOpcodeGeneratesType(op) || spvOpcodeIsConstant(op))

    return kLayoutTypes;

  switch (op) {

    case spv::Op::OpCapability:

      return kLayoutCapabilities;

    case spv::Op::OpExtension:

      return kLayoutExtensions;

    case spv::Op::OpExtInstImport:

      return kLayoutExtInstImport;

    case spv::Op::OpMemoryModel:

      return kLayoutMemoryModel;

    case spv::Op::OpEntryPoint:

      return kLayoutEntryPoint;

    case spv::Op::OpExecutionMode:

    case spv::Op::OpExecutionModeId:

      return kLayoutExecutionMode;

    case spv::Op::OpSourceContinued:

    case spv::Op::OpSource:

    case spv::Op::OpSourceExtension:

    case spv::Op::OpString:

      return kLayoutDebug1;

    case spv::Op::OpName:

    case spv::Op::OpMemberName:

      return kLayoutDebug2;

    case spv::Op::OpModuleProcessed:

      return kLayoutDebug3;

    case spv::Op::OpDecorate:

    case spv::Op::OpMemberDecorate:

    case spv::Op::OpGroupDecorate:

    case spv::Op::OpGroupMemberDecorate:

    case spv::Op::OpDecorationGroup:

    case spv::Op::OpDecorateId:

    case spv::Op::OpDecorateStringGOOGLE:

    case spv::Op::OpMemberDecorateStringGOOGLE:

      return kLayoutAnnotations;

    case spv::Op::OpTypeForwardPointer:

      return kLayoutTypes;

    case spv::Op::OpVariable:

      if (current_section == kLayoutTypes) return kLayoutTypes;

      return kLayoutFunctionDefinitions;

    case spv::Op::OpExtInst:

      // spv::Op::OpExtInst 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 spv::Op::OpLine:

    case spv::Op::OpNoLine:

    case spv::Op::OpUndef:

      if (current_section == kLayoutTypes) return kLayoutTypes;

      return kLayoutFunctionDefinitions;

    case spv::Op::OpFunction:

    case spv::Op::OpFunctionParameter:

    case spv::Op::OpFunctionEnd:

      if (current_section == kLayoutFunctionDeclarations)

        return kLayoutFunctionDeclarations;

      return kLayoutFunctionDefinitions;

    case spv::Op::OpSamplerImageAddressingModeNV:

      return kLayoutSamplerImageAddressMode;

    default:

      break;

  }

  return kLayoutFunctionDefinitions;

}

bool IsInstructionInLayoutSection(ModuleLayoutSection layout, spv::Op 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 (spv::Op(inst->opcode) == spv::Op::OpFunction) {

    _.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_(spv::AddressingModel::Max),

      memory_model_(spv::MemoryModel::Max),

      pointer_size_and_alignment_(0),

      sampler_image_addressing_mode_(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;

    }

  }

  // LocalSizeId is only disallowed prior to Vulkan 1.3 without maintenance4.

  switch (env) {

    case SPV_ENV_VULKAN_1_0:

    case SPV_ENV_VULKAN_1_1:

    case SPV_ENV_VULKAN_1_1_SPIRV_1_4:

    case SPV_ENV_VULKAN_1_2:

      features_.env_allow_localsizeid = false;

      break;

    default:

      features_.env_allow_localsizeid = true;

      break;

  }

  // 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_);

  name_mapper_ = spvtools::GetTrivialNameMapper();

  if (options_->use_friendly_names) {

    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(spv::Op op) {

  ModuleLayoutSection section =

      InstructionLayoutSection(current_layout_section_, op);

  return section < current_layout_section_;

}

bool ValidationState_t::IsOpcodeInCurrentLayoutSection(spv::Op 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(spv::Capability 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,

                                            uint32_t(cap), &desc)) {

    CapabilitySet(desc->numCapabilities, desc->capabilities)

        .ForEach([this](spv::Capability c) { RegisterCapability(c); });

  }

  switch (cap) {

    case spv::Capability::Kernel:

      features_.group_ops_reduce_and_scans = true;

      break;

    case spv::Capability::Int8:

      features_.use_int8_type = true;

      features_.declare_int8_type = true;

      break;

    case spv::Capability::StorageBuffer8BitAccess:

    case spv::Capability::UniformAndStorageBuffer8BitAccess:

    case spv::Capability::StoragePushConstant8:

    case spv::Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR:

      features_.declare_int8_type = true;

      break;

    case spv::Capability::Int16:

      features_.declare_int16_type = true;

      break;

    case spv::Capability::Float16:

    case spv::Capability::Float16Buffer:

      features_.declare_float16_type = true;

      break;

    case spv::Capability::StorageUniformBufferBlock16:

    case spv::Capability::StorageUniform16:

    case spv::Capability::StoragePushConstant16:

    case spv::Capability::StorageInputOutput16:

    case spv::Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR:

      features_.declare_int16_type = true;

      features_.declare_float16_type = true;

      features_.free_fp_rounding_mode = true;

      break;

    case spv::Capability::VariablePointers:

    case spv::Capability::VariablePointersStorageBuffer:

      features_.variable_pointers = true;

      break;

    default:

      // TODO(dneto): For now don't validate SPV_NV_ray_tracing, which uses

      // capability spv::Capability::RayTracingNV.

      // spv::Capability::RayTracingProvisionalKHR would need the same

      // treatment. One of the differences going from SPV_KHR_ray_tracing from

      // provisional to final spec was the provisional spec uses Locations

      // for variables in certain storage classes, just like the

      // SPV_NV_ray_tracing extension.  So it mimics the NVIDIA extension.

      // The final SPV_KHR_ray_tracing uses a different capability token

      // number, so it doesn't fall into this case.

      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(spv::AddressingModel am) {

  addressing_model_ = am;

  switch (am) {

    case spv::AddressingModel::Physical32:

      pointer_size_and_alignment_ = 4;

      break;

    default:

    // fall through

    case spv::AddressingModel::Physical64:

    case spv::AddressingModel::PhysicalStorageBuffer64:

      pointer_size_and_alignment_ = 8;

      break;

  }

}

spv::AddressingModel ValidationState_t::addressing_model() const {

  return addressing_model_;

}

void ValidationState_t::set_memory_model(spv::MemoryModel mm) {

  memory_model_ = mm;

}

spv::MemoryModel ValidationState_t::memory_model() const {

  return memory_model_;

}

void ValidationState_t::set_samplerimage_variable_address_mode(

    uint32_t bit_width) {

  sampler_image_addressing_mode_ = bit_width;

}

uint32_t ValidationState_t::samplerimage_variable_address_mode() const {

  return sampler_image_addressing_mode_;

}

spv_result_t ValidationState_t::RegisterFunction(

    uint32_t id, uint32_t ret_type_id,

    spv::FunctionControlMask 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, &current_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 "

         "outside 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 spv::Op::OpName: {

      const auto target = inst->GetOperandAs<uint32_t>(0);

      const std::string str = inst->GetOperandAs<std::string>(1);

      AssignNameToId(target, str);

      break;

    }

    case spv::Op::OpMemberName: {

      const auto target = inst->GetOperandAs<uint32_t>(0);

      const std::string str = inst->GetOperandAs<std::string>(2);

      AssignNameToId(target, str);

      break;

    }

    case spv::Op::OpSourceContinued:

    case spv::Op::OpSource:

    case spv::Op::OpSourceExtension:

    case spv::Op::OpString:

    case spv::Op::OpLine:

    case spv::Op::OpNoLine:

    default:

      break;

  }

}

void ValidationState_t::RegisterInstruction(Instruction* inst) {

  if (inst->id()) all_definitions_.insert(std::make_pair(inst->id(), inst));

  // Some validation checks are easier by getting all the consumers

  for (size_t i = 0; i < inst->operands().size(); ++i) {

    const spv_parsed_operand_t& operand = inst->operand(i);

    if ((SPV_OPERAND_TYPE_ID == operand.type) ||

        (SPV_OPERAND_TYPE_TYPE_ID == operand.type)) {

      const uint32_t operand_word = inst->word(operand.offset);

      Instruction* operand_inst = FindDef(operand_word);

      if (!operand_inst) {

        continue;

      }

      // 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.

      if ((SPV_OPERAND_TYPE_ID == operand.type) &&

          (spv::Op::OpSampledImage == operand_inst->opcode())) {

        RegisterSampledImageConsumer(operand_word, inst);

      }

      // In order to track storage classes (not Function) used per execution

      // model we can't use RegisterExecutionModelLimitation on instructions

      // like OpTypePointer which are going to be in the pre-function section.

      // Instead just need to register storage class usage for consumers in a

      // function block.

      if (inst->function()) {

        if (operand_inst->opcode() == spv::Op::OpTypePointer) {

          RegisterStorageClassConsumer(

              operand_inst->GetOperandAs<spv::StorageClass>(1), inst);

        } else if (operand_inst->opcode() == spv::Op::OpVariable) {

          RegisterStorageClassConsumer(

              operand_inst->GetOperandAs<spv::StorageClass>(2), 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);

}

void ValidationState_t::RegisterStorageClassConsumer(

    spv::StorageClass storage_class, Instruction* consumer) {

  if (spvIsVulkanEnv(context()->target_env)) {

    if (storage_class == spv::StorageClass::Output) {

      std::string errorVUID = VkErrorID(4644);

      function(consumer->function()->id())

          ->RegisterExecutionModelLimitation([errorVUID](

                                                 spv::ExecutionModel model,

                                                 std::string* message) {

            if (model == spv::ExecutionModel::GLCompute ||

                model == spv::ExecutionModel::RayGenerationKHR ||

                model == spv::ExecutionModel::IntersectionKHR ||

                model == spv::ExecutionModel::AnyHitKHR ||

                model == spv::ExecutionModel::ClosestHitKHR ||

                model == spv::ExecutionModel::MissKHR ||

                model == spv::ExecutionModel::CallableKHR) {

              if (message) {

                *message =

                    errorVUID +

                    "in Vulkan environment, Output Storage Class must not be "

                    "used in GLCompute, RayGenerationKHR, IntersectionKHR, "

                    "AnyHitKHR, ClosestHitKHR, MissKHR, or CallableKHR "

                    "execution models";

              }

              return false;

            }

            return true;

          });

    }

    if (storage_class == spv::StorageClass::Workgroup) {

      std::string errorVUID = VkErrorID(4645);

      function(consumer->function()->id())

          ->RegisterExecutionModelLimitation([errorVUID](

                                                 spv::ExecutionModel model,

                                                 std::string* message) {

            if (model != spv::ExecutionModel::GLCompute &&

                model != spv::ExecutionModel::TaskNV &&

                model != spv::ExecutionModel::MeshNV &&

                model != spv::ExecutionModel::TaskEXT &&

                model != spv::ExecutionModel::MeshEXT) {

              if (message) {

                *message =

                    errorVUID +

                    "in Vulkan environment, Workgroup Storage Class is limited "

                    "to MeshNV, TaskNV, and GLCompute execution model";

              }

              return false;

            }

            return true;

          });

    }

  }

  if (storage_class == spv::StorageClass::CallableDataKHR) {

    std::string errorVUID = VkErrorID(4704);

    function(consumer->function()->id())

        ->RegisterExecutionModelLimitation([errorVUID](

                                               spv::ExecutionModel model,

                                               std::string* message) {

          if (model != spv::ExecutionModel::RayGenerationKHR &&

              model != spv::ExecutionModel::ClosestHitKHR &&

              model != spv::ExecutionModel::CallableKHR &&

              model != spv::ExecutionModel::MissKHR) {

            if (message) {

              *message = errorVUID +

                         "CallableDataKHR Storage Class is limited to "

                         "RayGenerationKHR, ClosestHitKHR, CallableKHR, and "

                         "MissKHR execution model";

            }

            return false;

          }

          return true;

        });

  } else if (storage_class == spv::StorageClass::IncomingCallableDataKHR) {

    std::string errorVUID = VkErrorID(4705);

    function(consumer->function()->id())

        ->RegisterExecutionModelLimitation([errorVUID](

                                               spv::ExecutionModel model,

                                               std::string* message) {

          if (model != spv::ExecutionModel::CallableKHR) {

            if (message) {

              *message = errorVUID +

                         "IncomingCallableDataKHR Storage Class is limited to "

                         "CallableKHR execution model";

            }

            return false;

          }

          return true;

        });

  } else if (storage_class == spv::StorageClass::RayPayloadKHR) {

    std::string errorVUID = VkErrorID(4698);

    function(consumer->function()->id())

        ->RegisterExecutionModelLimitation([errorVUID](

                                               spv::ExecutionModel model,

                                               std::string* message) {

          if (model != spv::ExecutionModel::RayGenerationKHR &&

              model != spv::ExecutionModel::ClosestHitKHR &&

              model != spv::ExecutionModel::MissKHR) {

            if (message) {

              *message =

                  errorVUID +

                  "RayPayloadKHR Storage Class is limited to RayGenerationKHR, "

                  "ClosestHitKHR, and MissKHR execution model";

            }

            return false;

          }

          return true;

        });

  } else if (storage_class == spv::StorageClass::HitAttributeKHR) {

    std::string errorVUID = VkErrorID(4701);

    function(consumer->function()->id())

        ->RegisterExecutionModelLimitation(

            [errorVUID](spv::ExecutionModel model, std::string* message) {

              if (model != spv::ExecutionModel::IntersectionKHR &&

                  model != spv::ExecutionModel::AnyHitKHR &&

                  model != spv::ExecutionModel::ClosestHitKHR) {

                if (message) {

                  *message = errorVUID +

                             "HitAttributeKHR Storage Class is limited to "

                             "IntersectionKHR, AnyHitKHR, sand ClosestHitKHR "

                             "execution model";

                }

                return false;

              }

              return true;

            });

  } else if (storage_class == spv::StorageClass::IncomingRayPayloadKHR) {

    std::string errorVUID = VkErrorID(4699);

    function(consumer->function()->id())

        ->RegisterExecutionModelLimitation(

            [errorVUID](spv::ExecutionModel model, std::string* message) {

              if (model != spv::ExecutionModel::AnyHitKHR &&

                  model != spv::ExecutionModel::ClosestHitKHR &&

                  model != spv::ExecutionModel::MissKHR) {

                if (message) {

                  *message =

                      errorVUID +

                      "IncomingRayPayloadKHR Storage Class is limited to "

                      "AnyHitKHR, ClosestHitKHR, and MissKHR execution model";

                }

                return false;

              }

              return true;

            });

  } else if (storage_class == spv::StorageClass::ShaderRecordBufferKHR) {

    std::string errorVUID = VkErrorID(7119);

    function(consumer->function()->id())

        ->RegisterExecutionModelLimitation(

            [errorVUID](spv::ExecutionModel model, std::string* message) {

              if (model != spv::ExecutionModel::RayGenerationKHR &&

                  model != spv::ExecutionModel::IntersectionKHR &&

                  model != spv::ExecutionModel::AnyHitKHR &&

                  model != spv::ExecutionModel::ClosestHitKHR &&

                  model != spv::ExecutionModel::CallableKHR &&

                  model != spv::ExecutionModel::MissKHR) {

                if (message) {

                  *message =

                      errorVUID +

                      "ShaderRecordBufferKHR Storage Class is limited to "

                      "RayGenerationKHR, IntersectionKHR, AnyHitKHR, "

                      "ClosestHitKHR, CallableKHR, and MissKHR execution model";

                }

                return false;

              }

              return true;

            });

  } else if (storage_class == spv::StorageClass::TaskPayloadWorkgroupEXT) {

    function(consumer->function()->id())

        ->RegisterExecutionModelLimitation(

            [](spv::ExecutionModel model, std::string* message) {

              if (model != spv::ExecutionModel::TaskEXT &&

                  model != spv::ExecutionModel::MeshEXT) {

                if (message) {

                  *message =

                      "TaskPayloadWorkgroupEXT Storage Class is limited to "

                      "TaskEXT and MeshKHR execution model";

                }

                return false;

              }

              return true;

            });

  } else if (storage_class == spv::StorageClass::HitObjectAttributeNV) {

    function(consumer->function()->id())

        ->RegisterExecutionModelLimitation([](spv::ExecutionModel model,

                                              std::string* message) {

          if (model != spv::ExecutionModel::RayGenerationKHR &&

              model != spv::ExecutionModel::ClosestHitKHR &&

              model != spv::ExecutionModel::MissKHR) {

            if (message) {

              *message =

                  "HitObjectAttributeNV Storage Class is limited to "

                  "RayGenerationKHR, ClosestHitKHR or MissKHR execution model";

            }

            return false;

          }

          return true;

        });

  }

}

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;

}

spv::Op ValidationState_t::GetIdOpcode(uint32_t id) const {

  const Instruction* inst = FindDef(id);

  return inst ? inst->opcode() : spv::Op::OpNop;

}

uint32_t ValidationState_t::GetComponentType(uint32_t id) const {

  const Instruction* inst = FindDef(id);

  assert(inst);

  switch (inst->opcode()) {

    case spv::Op::OpTypeFloat:

    case spv::Op::OpTypeInt:

    case spv::Op::OpTypeBool:

      return id;

    case spv::Op::OpTypeVector:

      return inst->word(2);

    case spv::Op::OpTypeMatrix:

      return GetComponentType(inst->word(2));

    case spv::Op::OpTypeCooperativeMatrixNV:

      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 spv::Op::OpTypeFloat:

    case spv::Op::OpTypeInt:

    case spv::Op::OpTypeBool:

      return 1;

    case spv::Op::OpTypeVector:

    case spv::Op::OpTypeMatrix:

      return inst->word(3);

    case spv::Op::OpTypeCooperativeMatrixNV:

      // 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() == spv::Op::OpTypeFloat ||

      inst->opcode() == spv::Op::OpTypeInt)

    return inst->word(2);

  if (inst->opcode() == spv::Op::OpTypeBool) return 1;

  assert(0);

  return 0;

}

bool ValidationState_t::IsVoidType(uint32_t id) const {

  const Instruction* inst = FindDef(id);

  return inst && inst->opcode() == spv::Op::OpTypeVoid;

}

bool ValidationState_t::IsFloatScalarType(uint32_t id) const {

  const Instruction* inst = FindDef(id);

  return inst && inst->opcode() == spv::Op::OpTypeFloat;

}

bool ValidationState_t::IsFloatVectorType(uint32_t id) const {

  const Instruction* inst = FindDef(id);

  if (!inst) {

    return false;

  }

  if (inst->opcode() == spv::Op::OpTypeVector) {

    return IsFloatScalarType(GetComponentType(id));

  }

  return false;

}

bool ValidationState_t::IsFloatScalarOrVectorType(uint32_t id) const {

  const Instruction* inst = FindDef(id);

  if (!inst) {

    return false;

  }

  if (inst->opcode() == spv::Op::OpTypeFloat) {

    return true;

  }

  if (inst->opcode() == spv::Op::OpTypeVector) {

    return IsFloatScalarType(GetComponentType(id));

  }

  return false;

}

bool ValidationState_t::IsIntScalarType(uint32_t id) const {

  const Instruction* inst = FindDef(id);

  return inst && inst->opcode() == spv::Op::OpTypeInt;

}

bool ValidationState_t::IsIntVectorType(uint32_t id) const {

  const Instruction* inst = FindDef(id);

  if (!inst) {

    return false;

  }

  if (inst->opcode() == spv::Op::OpTypeVector) {

    return IsIntScalarType(GetComponentType(id));

  }

  return false;