// Copyright (c) 2018 Google LLC.

//

// 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/opcode.h"

#include "source/val/instruction.h"

#include "source/val/validate.h"

#include "source/val/validation_state.h"

namespace spvtools {

namespace val {

namespace {

spv_result_t ValidateConstantBool(ValidationState_t& _,

                                  const Instruction* inst) {

  auto type = _.FindDef(inst->type_id());

  if (!type || type->opcode() != spv::Op::OpTypeBool) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "Op" << spvOpcodeString(inst->opcode()) << " Result Type <id> "

           << _.getIdName(inst->type_id()) << " is not a boolean type.";

  }

  return SPV_SUCCESS;

}

bool isCompositeType(const Instruction* inst) {

  bool is_tensor = inst->opcode() == spv::Op::OpTypeTensorARM;

  bool tensor_is_shaped = inst->words().size() == 5;

  return spvOpcodeIsComposite(inst->opcode()) ||

         (is_tensor && tensor_is_shaped);

}

spv_result_t ValidateConstantOperand(ValidationState_t& _,

                                     const Instruction* inst, size_t operand) {

  std::string opcode_name = std::string("Op") + spvOpcodeString(inst->opcode());

  const auto operand_id = inst->GetOperandAs<uint32_t>(operand);

  const bool inst_is_spec_constant = spvOpcodeIsSpecConstant(inst->opcode());

  const auto operand_opcode = _.GetIdOpcode(operand_id);

  const bool is_constant = spvOpcodeIsConstantOrUndef(operand_opcode);

  const bool is_spec_constant = spvOpcodeIsSpecConstant(operand_opcode);

  if (!is_constant) {

    // All operands must be constant, undef, or poison.

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << opcode_name

           << " must only have constant, undef, or poison operands: <id> "

           << _.getIdName(operand_id);

  } else if (!inst_is_spec_constant && is_spec_constant) {

    // Spec constants are only allowed for spec constant opcodes.

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << opcode_name << " must not have spec constant operands: <id> "

           << _.getIdName(operand_id);

  }

  return SPV_SUCCESS;

}

spv_result_t ValidateConstantComposite(ValidationState_t& _,

                                       const Instruction* inst) {

  std::string opcode_name = std::string("Op") + spvOpcodeString(inst->opcode());

  const auto result_type = _.FindDef(inst->type_id());

  if (!result_type || !isCompositeType(result_type)) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << opcode_name << " Result Type <id> "

           << _.getIdName(inst->type_id()) << " is not a composite type.";

  }

  const auto constituent_count = inst->operands().size() - 2;

  switch (result_type->opcode()) {

    case spv::Op::OpTypeVector:

    case spv::Op::OpTypeVectorIdEXT: {

      uint32_t num_result_components = _.GetDimension(result_type->id());

      bool comp_is_int32 = true, comp_is_const_int32 = true;

      if (result_type->opcode() == spv::Op::OpTypeVectorIdEXT) {

        uint32_t comp_count_id = result_type->GetOperandAs<uint32_t>(2);

        std::tie(comp_is_int32, comp_is_const_int32, num_result_components) =

            _.EvalInt32IfConst(comp_count_id);

      }

      if (comp_is_const_int32 && num_result_components != constituent_count) {

        // TODO: Output ID's on diagnostic

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << opcode_name

               << " Constituent <id> count does not match "

                  "Result Type <id> "

               << _.getIdName(result_type->id()) << "s vector component count.";

      }

      const auto component_type =

          _.FindDef(result_type->GetOperandAs<uint32_t>(1));

      if (!component_type) {

        return _.diag(SPV_ERROR_INVALID_ID, result_type)

               << "Component type is not defined.";

      }

      for (size_t constituent_index = 2;

           constituent_index < inst->operands().size(); constituent_index++) {

        const auto constituent_id =

            inst->GetOperandAs<uint32_t>(constituent_index);

        const auto constituent = _.FindDef(constituent_id);

        const auto constituent_result_type = _.FindDef(constituent->type_id());

        if (!constituent_result_type ||

            component_type->id() != constituent_result_type->id()) {

          return _.diag(SPV_ERROR_INVALID_ID, inst)

                 << opcode_name << " Constituent <id> "

                 << _.getIdName(constituent_id)

                 << "s type does not match Result Type <id> "

                 << _.getIdName(result_type->id()) << "s vector element type.";

        }

      }

    } break;

    case spv::Op::OpTypeMatrix: {

      const auto column_count = result_type->GetOperandAs<uint32_t>(2);

      if (column_count != constituent_count) {

        // TODO: Output ID's on diagnostic

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << opcode_name

               << " Constituent <id> count does not match "

                  "Result Type <id> "

               << _.getIdName(result_type->id()) << "s matrix column count.";

      }

      const auto column_type =

          _.FindDef(result_type->GetOperandAs<uint32_t>(1));

      if (!column_type) {

        return _.diag(SPV_ERROR_INVALID_ID, result_type)

               << "Column type is not defined.";

      }

      const auto component_count = column_type->GetOperandAs<uint32_t>(2);

      const auto component_type =

          _.FindDef(column_type->GetOperandAs<uint32_t>(1));

      if (!component_type) {

        return _.diag(SPV_ERROR_INVALID_ID, column_type)

               << "Component type is not defined.";

      }

      for (size_t constituent_index = 2;

           constituent_index < inst->operands().size(); constituent_index++) {

        const auto constituent_id =

            inst->GetOperandAs<uint32_t>(constituent_index);

        const auto constituent = _.FindDef(constituent_id);

        const auto vector = _.FindDef(constituent->type_id());

        if (!vector) {

          return _.diag(SPV_ERROR_INVALID_ID, constituent)

                 << "Result type is not defined.";

        }

        if (column_type->opcode() != vector->opcode()) {

          return _.diag(SPV_ERROR_INVALID_ID, inst)

                 << opcode_name << " Constituent <id> "

                 << _.getIdName(constituent_id)

                 << " type does not match Result Type <id> "

                 << _.getIdName(result_type->id()) << "s matrix column type.";

        }

        const auto vector_component_type =

            _.FindDef(vector->GetOperandAs<uint32_t>(1));

        if (component_type->id() != vector_component_type->id()) {

          return _.diag(SPV_ERROR_INVALID_ID, inst)

                 << opcode_name << " Constituent <id> "

                 << _.getIdName(constituent_id)

                 << " component type does not match Result Type <id> "

                 << _.getIdName(result_type->id())

                 << "s matrix column component type.";

        }

        if (component_count != vector->GetOperandAs<uint32_t>(2)) {

          return _.diag(SPV_ERROR_INVALID_ID, inst)

                 << opcode_name << " Constituent <id> "

                 << _.getIdName(constituent_id)

                 << " vector component count does not match Result Type <id> "

                 << _.getIdName(result_type->id())

                 << "s vector component count.";

        }

      }

    } break;

    case spv::Op::OpTypeArray: {

      auto element_type = _.FindDef(result_type->GetOperandAs<uint32_t>(1));

      if (!element_type) {

        return _.diag(SPV_ERROR_INVALID_ID, result_type)

               << "Element type is not defined.";

      }

      const auto length = _.FindDef(result_type->GetOperandAs<uint32_t>(2));

      if (!length) {

        return _.diag(SPV_ERROR_INVALID_ID, result_type)

               << "Length is not defined.";

      }

      bool is_int32;

      bool is_const;

      uint32_t value;

      std::tie(is_int32, is_const, value) = _.EvalInt32IfConst(length->id());

      if (is_int32 && is_const && value != constituent_count) {

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << opcode_name

               << " Constituent count does not match "

                  "Result Type <id> "

               << _.getIdName(result_type->id()) << "s array length.";

      }

      for (size_t constituent_index = 2;

           constituent_index < inst->operands().size(); constituent_index++) {

        const auto constituent_id =

            inst->GetOperandAs<uint32_t>(constituent_index);

        const auto constituent = _.FindDef(constituent_id);

        const auto constituent_type = _.FindDef(constituent->type_id());

        if (!constituent_type) {

          return _.diag(SPV_ERROR_INVALID_ID, constituent)

                 << "Result type is not defined.";

        }

        if (element_type->id() != constituent_type->id()) {

          return _.diag(SPV_ERROR_INVALID_ID, inst)

                 << opcode_name << " Constituent <id> "

                 << _.getIdName(constituent_id)

                 << "s type does not match Result Type <id> "

                 << _.getIdName(result_type->id()) << "s array element type.";

        }

      }

    } break;

    case spv::Op::OpTypeStruct: {

      const auto member_count = result_type->operands().size() - 1;

      if (member_count != constituent_count) {

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << opcode_name << " Constituent <id> "

               << _.getIdName(inst->type_id())

               << " count does not match Result Type <id> "

               << _.getIdName(result_type->id()) << "s struct member count.";

      }

      for (uint32_t constituent_index = 2, member_index = 1;

           constituent_index < inst->operands().size();

           constituent_index++, member_index++) {

        const auto constituent_id =

            inst->GetOperandAs<uint32_t>(constituent_index);

        const auto constituent = _.FindDef(constituent_id);

        const auto constituent_type = _.FindDef(constituent->type_id());

        if (!constituent_type) {

          return _.diag(SPV_ERROR_INVALID_ID, constituent)

                 << "Result type is not defined.";

        }

        const auto member_type_id =

            result_type->GetOperandAs<uint32_t>(member_index);

        const auto member_type = _.FindDef(member_type_id);

        if (!member_type || member_type->id() != constituent_type->id()) {

          return _.diag(SPV_ERROR_INVALID_ID, inst)

                 << opcode_name << " Constituent <id> "

                 << _.getIdName(constituent_id)

                 << " type does not match the Result Type <id> "

                 << _.getIdName(result_type->id()) << "s member type.";

        }

      }

    } break;

    case spv::Op::OpTypeCooperativeMatrixKHR:

    case spv::Op::OpTypeCooperativeMatrixNV: {

      if (1 != constituent_count) {

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << opcode_name << " Constituent <id> "

               << _.getIdName(inst->type_id()) << " count must be one.";

      }

      const auto constituent_id = inst->GetOperandAs<uint32_t>(2);

      const auto constituent = _.FindDef(constituent_id);

      const auto constituent_type = _.FindDef(constituent->type_id());

      if (!constituent_type) {

        return _.diag(SPV_ERROR_INVALID_ID, constituent)

               << "Result type is not defined.";

      }

      const auto component_type_id = result_type->GetOperandAs<uint32_t>(1);

      const auto component_type = _.FindDef(component_type_id);

      if (!component_type || component_type->id() != constituent_type->id()) {

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << opcode_name << " Constituent <id> "

               << _.getIdName(constituent_id)

               << " type does not match the Result Type <id> "

               << _.getIdName(result_type->id()) << "s component type.";

      }

    } break;

    case spv::Op::OpTypeTensorARM: {

      auto inst_element_type =

          _.FindDef(result_type->GetOperandAs<uint32_t>(1));

      if (!inst_element_type) {

        return _.diag(SPV_ERROR_INVALID_ID, result_type)

               << "Element type is not defined.";

      }

      const auto inst_rank = _.FindDef(result_type->GetOperandAs<uint32_t>(2));

      if (!inst_rank) {

        return _.diag(SPV_ERROR_INVALID_ID, result_type)

               << "Rank is not defined.";

      }

      const auto inst_shape = _.FindDef(result_type->GetOperandAs<uint32_t>(3));

      if (!inst_shape) {

        return _.diag(SPV_ERROR_INVALID_ID, result_type)

               << "Shape is not defined.";

      }

      uint64_t rank = 0;

      _.EvalConstantValUint64(inst_rank->id(), &rank);

      uint64_t outermost_shape = 0;

      if (_.EvalConstantValUint64(inst_shape->GetOperandAs<uint32_t>(2),

                                  &outermost_shape) &&

          (outermost_shape != constituent_count)) {

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << opcode_name

               << " Constituent count does not match "

                  "the shape of Result Type <id> "

               << _.getIdName(result_type->id())

               << " along its outermost dimension, " << "expected "

               << outermost_shape << " but got " << constituent_count << ".";

      }

      for (size_t constituent_index = 2;

           constituent_index < inst->operands().size(); constituent_index++) {

        const auto constituent_id =

            inst->GetOperandAs<uint32_t>(constituent_index);

        const auto constituent = _.FindDef(constituent_id);

        const auto constituent_type = _.FindDef(constituent->type_id());

        if (!constituent_type) {

          return _.diag(SPV_ERROR_INVALID_ID, constituent)

                 << "Type of Constituent " << constituent_index - 2

                 << " is not defined.";

        }

        if (rank == 0) {

          // The rank of the returned tensor constant is not known.

          // Skip rank-dependent validation.

          continue;

        }

        if (rank == 1) {

          if (inst_element_type->id() != constituent_type->id()) {

            return _.diag(SPV_ERROR_INVALID_ID, inst)

                   << opcode_name << " Constituent <id> "

                   << _.getIdName(constituent_id)

                   << " type does not match the element type of the tensor ("

                   << _.getIdName(result_type->id()) << ").";

          }

        } else {

          if (constituent_type->opcode() != spv::Op::OpTypeTensorARM) {

            return _.diag(SPV_ERROR_INVALID_ID, inst)

                   << opcode_name << " Constituent <id> "

                   << _.getIdName(constituent_id)

                   << " must be an OpTypeTensorARM.";

          }

          auto inst_constituent_element_type =

              _.FindDef(constituent_type->GetOperandAs<uint32_t>(1));

          if (!inst_constituent_element_type ||

              inst_constituent_element_type->id() != inst_element_type->id()) {

            return _.diag(SPV_ERROR_INVALID_ID, inst)

                   << opcode_name << " Constituent <id> "

                   << _.getIdName(constituent_id)

                   << " must have the same Element Type as Result Type <id> "

                   << _.getIdName(result_type->id()) << ".";

          }

          auto inst_constituent_rank =

              _.FindDef(constituent_type->GetOperandAs<uint32_t>(2));

          uint64_t constituent_rank;

          if (inst_constituent_rank &&

              _.EvalConstantValUint64(inst_constituent_rank->id(),

                                      &constituent_rank) &&

              (constituent_rank != rank - 1)) {

            return _.diag(SPV_ERROR_INVALID_ID, inst)

                   << opcode_name << " Constituent <id> "

                   << _.getIdName(constituent_id)

                   << " must have a Rank that is 1 less than the Rank of "

                      "Result Type <id> "

                   << _.getIdName(result_type->id()) << ", expected "

                   << rank - 1 << " but got " << constituent_rank << ".";

          }

          auto inst_constituent_shape =

              _.FindDef(constituent_type->GetOperandAs<uint32_t>(3));

          if (!inst_constituent_shape) {

            return _.diag(SPV_ERROR_INVALID_ID, result_type)

                   << "Shape of Constituent " << constituent_index - 2

                   << " is not defined.";

          }

          for (size_t constituent_shape_index = 2;

               constituent_shape_index <

               inst_constituent_shape->operands().size();

               constituent_shape_index++) {

            size_t shape_index = constituent_shape_index + 1;

            uint64_t constituent_shape = 0, shape = 1;

            if (_.EvalConstantValUint64(

                    inst_constituent_shape->GetOperandAs<uint32_t>(

                        constituent_shape_index),

                    &constituent_shape) &&

                _.EvalConstantValUint64(

                    inst_shape->GetOperandAs<uint32_t>(shape_index), &shape) &&

                (constituent_shape != shape)) {

              return _.diag(SPV_ERROR_INVALID_ID, inst)

                     << opcode_name << " Constituent <id> "

                     << _.getIdName(constituent_id)

                     << " must have a Shape that matches that of Result Type "

                        "<id> "

                     << _.getIdName(result_type->id())

                     << " along all inner dimensions of Result Type, expected "

                     << shape << " for dimension "

                     << constituent_shape_index - 2

                     << " of Constituent but got " << constituent_shape << ".";

            }

          }

        }

      }

    } break;

    default:

      break;

  }

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

    if (auto error = ValidateConstantOperand(_, inst, i)) {

      return error;

    }

  }

  return SPV_SUCCESS;

}

spv_result_t ValidateConstantCompositeReplicate(ValidationState_t& _,

                                                const Instruction* inst) {

  std::string opcode_name = std::string("Op") + spvOpcodeString(inst->opcode());

  const auto result_type = _.FindDef(inst->type_id());

  if (!result_type || !isCompositeType(result_type)) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << opcode_name << " Result Type <id> "

           << _.getIdName(inst->type_id()) << " is not a composite type.";

  }

  const auto constituent_id = inst->GetOperandAs<uint32_t>(2);

  const auto constituent = _.FindDef(constituent_id);

  switch (result_type->opcode()) {

    case spv::Op::OpTypeVector:

    case spv::Op::OpTypeVectorIdEXT:

    case spv::Op::OpTypeMatrix:

    case spv::Op::OpTypeArray:

    case spv::Op::OpTypeCooperativeMatrixKHR:

    case spv::Op::OpTypeCooperativeMatrixNV:

    case spv::Op::OpTypeTensorARM: {

      const auto component_type = result_type->GetOperandAs<uint32_t>(1);

      if (component_type != constituent->type_id()) {

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << opcode_name << " Constituent <id> "

               << _.getIdName(constituent_id)

               << "s type does not match Result Type <id> "

               << _.getIdName(result_type->id()) << "s element type.";

      }

      break;

    }

    case spv::Op::OpTypeStruct: {

      const auto member_count = result_type->operands().size() - 1;

      for (uint32_t member_index = 1; member_index <= member_count;

           member_index++) {

        const auto member_type_id =

            result_type->GetOperandAs<uint32_t>(member_index);

        if (member_type_id != constituent->type_id()) {

          return _.diag(SPV_ERROR_INVALID_ID, inst)

                 << opcode_name << " Constituent <id> "

                 << _.getIdName(constituent_id)

                 << " type does not match the Result Type <id> "

                 << _.getIdName(result_type->id()) << "s member type.";

        }

      }

      break;

    }

    default:

      break;

  }

  return ValidateConstantOperand(_, inst, 2);

}

spv_result_t ValidateConstantSampler(ValidationState_t& _,

                                     const Instruction* inst) {

  const auto result_type = _.FindDef(inst->type_id());

  if (!result_type || result_type->opcode() != spv::Op::OpTypeSampler) {

    return _.diag(SPV_ERROR_INVALID_ID, result_type)

           << "OpConstantSampler Result Type <id> "

           << _.getIdName(inst->type_id()) << " is not a sampler type.";

  }

  return SPV_SUCCESS;

}

// True if instruction defines a type that can have a null value, as defined by

// the SPIR-V spec.  Tracks composite-type components through module to check

// nullability transitively.

bool IsTypeNullable(const std::vector<uint32_t>& instruction,

                    const ValidationState_t& _) {

  uint16_t opcode;

  uint16_t word_count;

  spvOpcodeSplit(instruction[0], &word_count, &opcode);

  switch (static_cast<spv::Op>(opcode)) {

    case spv::Op::OpTypeBool:

    case spv::Op::OpTypeInt:

    case spv::Op::OpTypeFloat:

    case spv::Op::OpTypeEvent:

    case spv::Op::OpTypeDeviceEvent:

    case spv::Op::OpTypeReserveId:

    case spv::Op::OpTypeQueue:

      return true;

    case spv::Op::OpTypeArray:

    case spv::Op::OpTypeMatrix:

    case spv::Op::OpTypeCooperativeMatrixNV:

    case spv::Op::OpTypeCooperativeMatrixKHR:

    case spv::Op::OpTypeVectorIdEXT:

    case spv::Op::OpTypeVector: {

      auto base_type = _.FindDef(instruction[2]);

      return base_type && IsTypeNullable(base_type->words(), _);

    }

    case spv::Op::OpTypeStruct: {

      for (size_t elementIndex = 2; elementIndex < instruction.size();

           ++elementIndex) {

        auto element = _.FindDef(instruction[elementIndex]);

        if (!element || !IsTypeNullable(element->words(), _)) return false;

      }

      return true;

    }

    case spv::Op::OpTypeUntypedPointerKHR:

    case spv::Op::OpTypePointer:

      if (spv::StorageClass(instruction[2]) ==

          spv::StorageClass::PhysicalStorageBuffer) {

        return false;

      }

      return true;

    case spv::Op::OpTypeTensorARM: {

      auto elem_type = _.FindDef(instruction[2]);

      return (instruction.size() > 4) && elem_type &&

             IsTypeNullable(elem_type->words(), _);

    }

    default:

      return false;

  }

}

spv_result_t ValidateConstantNull(ValidationState_t& _,

                                  const Instruction* inst) {

  const auto result_type = _.FindDef(inst->type_id());

  if (!result_type || !IsTypeNullable(result_type->words(), _)) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "OpConstantNull Result Type <id> " << _.getIdName(inst->type_id())

           << " cannot have a null value.";

  }

  return SPV_SUCCESS;

}

spv_result_t ValidateConstantSizeOfEXT(ValidationState_t& _,

                                       const Instruction* inst) {

  const Instruction* result_type = _.FindDef(inst->type_id());

  const uint32_t bit_width = result_type->opcode() == spv::Op::OpTypeInt

                                 ? result_type->GetOperandAs<uint32_t>(1)

                                 : 0;

  // VVL will validate the SPV_EXT_shader_64bit_indexing interaction

  if (bit_width != 64 && bit_width != 32) {

    return _.diag(SPV_ERROR_INVALID_DATA, inst)

           << "For OpConstantSizeOfEXT instruction, its result type "

           << "must be a 32-bit or 64-bit integer type scalar."

           << " (OpCapability Int64 is required for 64-bit)";

  }

  const uint32_t type_operand = inst->GetOperandAs<uint32_t>(2);

  if (!_.IsDescriptorType(type_operand)) {

    return _.diag(SPV_ERROR_INVALID_DATA, inst)

           << "For OpConstantSizeOfEXT instruction, its Type operand <Id> "

           << _.getIdName(type_operand) << " must be a Descriptor type.";

  }

  return SPV_SUCCESS;

}

// Validates that OpSpecConstant specializes to either int or float type.

spv_result_t ValidateSpecConstant(ValidationState_t& _,

                                  const Instruction* inst) {

  // Operand 0 is the <id> of the type that we're specializing to.

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

  auto type_instruction = _.FindDef(type_id);

  auto type_opcode = type_instruction->opcode();

  if (type_opcode != spv::Op::OpTypeInt &&

      type_opcode != spv::Op::OpTypeFloat) {

    return _.diag(SPV_ERROR_INVALID_DATA, inst) << "Specialization constant "

                                                   "must be an integer or "

                                                   "floating-point number.";

  }

  return SPV_SUCCESS;

}

spv_result_t ValidateSpecConstantOp(ValidationState_t& _,

                                    const Instruction* inst) {

  const auto op = inst->GetOperandAs<spv::Op>(2);

  // The binary parser already ensures that the op is valid for *some*

  // environment.  Here we check restrictions.

  switch (op) {

    case spv::Op::OpQuantizeToF16:

      if (!_.HasCapability(spv::Capability::Shader)) {

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << "Specialization constant operation " << spvOpcodeString(op)

               << " requires Shader capability";

      }

      break;

    case spv::Op::OpUConvert:

      if (!_.features().uconvert_spec_constant_op &&

          !_.HasCapability(spv::Capability::Kernel)) {

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << "Prior to SPIR-V 1.4, specialization constant operation "

                  "UConvert requires Kernel capability or extension "

                  "SPV_AMD_gpu_shader_int16";

      }

      break;

    case spv::Op::OpConvertFToS:

    case spv::Op::OpConvertSToF:

    case spv::Op::OpConvertFToU:

    case spv::Op::OpConvertUToF:

    case spv::Op::OpConvertPtrToU:

    case spv::Op::OpConvertUToPtr:

    case spv::Op::OpGenericCastToPtr:

    case spv::Op::OpPtrCastToGeneric:

    case spv::Op::OpBitcast:

    case spv::Op::OpFNegate:

    case spv::Op::OpFAdd:

    case spv::Op::OpFSub:

    case spv::Op::OpFMul:

    case spv::Op::OpFDiv:

    case spv::Op::OpFRem:

    case spv::Op::OpFMod:

    case spv::Op::OpAccessChain:

    case spv::Op::OpInBoundsAccessChain:

    case spv::Op::OpPtrAccessChain:

    case spv::Op::OpInBoundsPtrAccessChain:

    case spv::Op::OpUntypedAccessChainKHR:

    case spv::Op::OpUntypedInBoundsAccessChainKHR:

    case spv::Op::OpUntypedPtrAccessChainKHR:

    case spv::Op::OpUntypedInBoundsPtrAccessChainKHR:

      if (!_.HasCapability(spv::Capability::Kernel)) {

        return _.diag(SPV_ERROR_INVALID_ID, inst)

               << "Specialization constant operation " << spvOpcodeString(op)

               << " requires Kernel capability";

      }

      break;

    default:

      break;

  }

  // TODO(dneto): Validate result type and arguments to the various operations.

  return SPV_SUCCESS;

}

spv_result_t ValidateConstantFunctionPointerINTEL(ValidationState_t& _,

                                                  const Instruction* inst) {

  const auto result_type = _.FindDef(inst->type_id());

  // Result Type must be a pointer type

  if (result_type->opcode() != spv::Op::OpTypePointer &&

      result_type->opcode() != spv::Op::OpTypeUntypedPointerKHR) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "OpConstantFunctionPointerINTEL Result Type <id> "

           << _.getIdName(inst->type_id()) << " is not a pointer type";

  }

  // For typed pointers, check that pointee is a function type

  const Instruction* pointee_type = nullptr;

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

    pointee_type = _.FindDef(result_type->GetOperandAs<uint32_t>(2));

    if (pointee_type->opcode() != spv::Op::OpTypeFunction) {

      return _.diag(SPV_ERROR_INVALID_ID, inst)

             << "OpConstantFunctionPointerINTEL Result Type <id> "

             << _.getIdName(inst->type_id())

             << " must be a pointer to function type";

    }

  }

  // Validate that the function operand refers to an OpFunction

  const uint32_t function_id = inst->GetOperandAs<uint32_t>(2);

  const auto function_inst = _.FindDef(function_id);

  if (function_inst->opcode() != spv::Op::OpFunction) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "OpConstantFunctionPointerINTEL Function operand <id> "

           << _.getIdName(function_id) << " is not an OpFunction";

  }

  // For typed pointers, validate that function type matches pointee type

  if (pointee_type) {

    const uint32_t function_type_id = function_inst->GetOperandAs<uint32_t>(3);

    if (function_type_id != pointee_type->id()) {

      return _.diag(SPV_ERROR_INVALID_ID, inst)

             << "OpConstantFunctionPointerINTEL Function operand <id> "

             << _.getIdName(function_id)

             << " type does not match the pointer's function type";

    }

  }

  return SPV_SUCCESS;

}

spv_result_t ValidateConstantData(ValidationState_t& _,

                                  const Instruction* inst) {

  const auto array_inst = _.FindDef(inst->type_id());

  if (array_inst->opcode() != spv::Op::OpTypeArray) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "Result type must be an array.";

  }

  const auto element_type_inst =

      _.FindDef(array_inst->GetOperandAs<uint32_t>(1));

  if (!_.IsIntScalarType(element_type_inst->id())) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "Result type must be an array of integer scalar type.";

  }

  // The Data literals are tightly packed, so an explicit layout stride on the

  // result type would contradict how the constant is encoded.

  if (_.HasDecoration(array_inst->id(), spv::Decoration::ArrayStride)) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "Result type must not be decorated with ArrayStride.";

  }

  const uint32_t int_width = element_type_inst->word(2);

  const uint32_t data_words = static_cast<uint32_t>(inst->words().size() - 3);

  if (data_words == 0) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "There must be at least 1 literal integer (because an array of "

              "zero is not allowed).";

  }

  uint64_t array_length = 0;

  if (!_.EvalConstantValUint64(array_inst->GetOperandAs<uint32_t>(2),

                               &array_length)) {

    // The length could be a SpecConstant, will need to be frozen to validate

    return SPV_SUCCESS;

  }

  const uint32_t words_needed =

      (((int_width / 8) * static_cast<uint32_t>(array_length) + 3) & ~3) / 4;

  if (data_words != words_needed) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "contains " << data_words << " words of data, but needs to have "

           << words_needed << " words to match the array of " << array_length

           << " of " << int_width << "-bit ints.";

  }

  return SPV_SUCCESS;

}

}  // namespace

spv_result_t ConstantPass(ValidationState_t& _, const Instruction* inst) {

  switch (inst->opcode()) {

    case spv::Op::OpConstantTrue:

    case spv::Op::OpConstantFalse:

    case spv::Op::OpSpecConstantTrue:

    case spv::Op::OpSpecConstantFalse:

      if (auto error = ValidateConstantBool(_, inst)) return error;

      break;

    case spv::Op::OpConstantComposite:

    case spv::Op::OpSpecConstantComposite:

      if (auto error = ValidateConstantComposite(_, inst)) return error;

      break;

    case spv::Op::OpConstantCompositeReplicateEXT:

    case spv::Op::OpSpecConstantCompositeReplicateEXT:

      if (auto error = ValidateConstantCompositeReplicate(_, inst))

        return error;

      break;

    case spv::Op::OpConstantSampler:

      if (auto error = ValidateConstantSampler(_, inst)) return error;

      break;

    case spv::Op::OpConstantNull:

      if (auto error = ValidateConstantNull(_, inst)) return error;

      break;

    case spv::Op::OpSpecConstant:

      if (auto error = ValidateSpecConstant(_, inst)) return error;

      break;

    case spv::Op::OpSpecConstantOp:

      if (auto error = ValidateSpecConstantOp(_, inst)) return error;

      break;

    case spv::Op::OpConstantSizeOfEXT:

      if (auto error = ValidateConstantSizeOfEXT(_, inst)) return error;

      break;

    case spv::Op::OpConstantFunctionPointerINTEL:

      if (auto error = ValidateConstantFunctionPointerINTEL(_, inst))

        return error;

      break;

    case spv::Op::OpConstantDataKHR:

    case spv::Op::OpSpecConstantDataKHR:

      if (auto error = ValidateConstantData(_, inst)) return error;

      break;

    default:

      break;

  }

  // Generally disallow creating 8- or 16-bit constants unless the full

  // capabilities are present.

  if (spvOpcodeIsConstant(inst->opcode()) &&

      _.HasCapability(spv::Capability::Shader) &&

      !_.IsPointerType(inst->type_id()) &&

      _.ContainsLimitedUseIntOrFloatType(inst->type_id())) {

    return _.diag(SPV_ERROR_INVALID_ID, inst)

           << "Cannot form constants of 8- or 16-bit types";

  }

  return SPV_SUCCESS;

}

}  // namespace val

}  // namespace spvtools