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

#include "source/spirv_target_env.h"
#include "source/val/instruction.h"
#include "source/val/validation_state.h"

namespace spvtools {
namespace val {

bool IsValidScope(uint32_t scope) {
  // Deliberately avoid a default case so we have to update the list when the
  // scopes list changes.
  switch (static_cast<spv::Scope>(scope)) {
    case spv::Scope::CrossDevice:
    case spv::Scope::Device:
    case spv::Scope::Workgroup:
    case spv::Scope::Subgroup:
    case spv::Scope::Invocation:
    case spv::Scope::QueueFamilyKHR:
    case spv::Scope::ShaderCallKHR:
      return true;
    case spv::Scope::Max:
      break;
  }
  return false;
}

spv_result_t ValidateScope(ValidationState_t& _, const Instruction* inst,
                           uint32_t scope) {
  spv::Op opcode = inst->opcode();
  bool is_int32 = false, is_const_int32 = false;
  uint32_t value = 0;
  std::tie(is_int32, is_const_int32, value) = _.EvalInt32IfConst(scope);

  if (!is_int32) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << spvOpcodeString(opcode) << ": expected scope to be a 32-bit int";
  }

  if (!is_const_int32) {
    if (_.HasCapability(spv::Capability::Shader) &&
        !_.HasCapability(spv::Capability::CooperativeMatrixNV)) {
      return _.diag(SPV_ERROR_INVALID_DATA, inst)
             << "Scope ids must be OpConstant when Shader capability is "
             << "present";
    }
    if (_.HasCapability(spv::Capability::Shader) &&
        _.HasCapability(spv::Capability::CooperativeMatrixNV) &&
        !spvOpcodeIsConstant(_.GetIdOpcode(scope))) {
      return _.diag(SPV_ERROR_INVALID_DATA, inst)
             << "Scope ids must be constant or specialization constant when "
             << "CooperativeMatrixNV capability is present";
    }
  }

  if (is_const_int32 && !IsValidScope(value)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Invalid scope value:\n " << _.Disassemble(*_.FindDef(scope));
  }

  return SPV_SUCCESS;
}

spv_result_t ValidateExecutionScope(ValidationState_t& _,
                                    const Instruction* inst, uint32_t scope) {
  spv::Op opcode = inst->opcode();
  bool is_int32 = false, is_const_int32 = false;
  uint32_t tmp_value = 0;
  std::tie(is_int32, is_const_int32, tmp_value) = _.EvalInt32IfConst(scope);

  if (auto error = ValidateScope(_, inst, scope)) {
    return error;
  }

  if (!is_const_int32) {
    return SPV_SUCCESS;
  }

  spv::Scope value = spv::Scope(tmp_value);

  // Vulkan specific rules
  if (spvIsVulkanEnv(_.context()->target_env)) {
    // Subgroups were not added until 1.1
    if (_.context()->target_env != SPV_ENV_VULKAN_1_0) {
      // Scope for Non Uniform Group Operations must be limited to Subgroup
      if ((spvOpcodeIsNonUniformGroupOperation(opcode) &&
           (opcode != spv::Op::OpGroupNonUniformQuadAllKHR) &&
           (opcode != spv::Op::OpGroupNonUniformQuadAnyKHR)) &&
          (value != spv::Scope::Subgroup)) {
        return _.diag(SPV_ERROR_INVALID_DATA, inst)
               << _.VkErrorID(4642) << spvOpcodeString(opcode)
               << ": in Vulkan environment Execution scope is limited to "
               << "Subgroup";
      }
    }

    // OpControlBarrier must only use Subgroup execution scope for a subset of
    // execution models.
    if (opcode == spv::Op::OpControlBarrier && value != spv::Scope::Subgroup) {
      std::string errorVUID = _.VkErrorID(4682);
      _.function(inst->function()->id())
          ->RegisterExecutionModelLimitation([errorVUID](
                                                 spv::ExecutionModel model,
                                                 std::string* message) {
            if (model == spv::ExecutionModel::Fragment ||
                model == spv::ExecutionModel::Vertex ||
                model == spv::ExecutionModel::Geometry ||
                model == spv::ExecutionModel::TessellationEvaluation ||
                model == spv::ExecutionModel::RayGenerationKHR ||
                model == spv::ExecutionModel::IntersectionKHR ||
                model == spv::ExecutionModel::AnyHitKHR ||
                model == spv::ExecutionModel::ClosestHitKHR ||
                model == spv::ExecutionModel::MissKHR) {
              if (message) {
                *message =
                    errorVUID +
                    "in Vulkan environment, OpControlBarrier execution scope "
                    "must be Subgroup for Fragment, Vertex, Geometry, "
                    "TessellationEvaluation, RayGeneration, Intersection, "
                    "AnyHit, ClosestHit, and Miss execution models";
              }
              return false;
            }
            return true;
          });
    }

    if (opcode == spv::Op::OpControlBarrierArriveEXT ||
        opcode == spv::Op::OpControlBarrierWaitEXT) {
      if (value != spv::Scope::Workgroup && value != spv::Scope::Subgroup) {
        return _.diag(SPV_ERROR_INVALID_DATA, inst)
               << _.VkErrorID(13553)
               << "The execution Scope for OpControlBarrierArriveEXT and "
                  "OpControlBarrierWaitEXT must be Workgroup or Subgroup";
      }
    }
    // Only subset of execution models support Workgroup.
    if (value == spv::Scope::Workgroup) {
      std::string errorVUID = _.VkErrorID(4637);
      _.function(inst->function()->id())
          ->RegisterExecutionModelLimitation(
              [errorVUID](spv::ExecutionModel model, std::string* message) {
                if (model != spv::ExecutionModel::TaskNV &&
                    model != spv::ExecutionModel::MeshNV &&
                    model != spv::ExecutionModel::TaskEXT &&
                    model != spv::ExecutionModel::MeshEXT &&
                    model != spv::ExecutionModel::TessellationControl &&
                    model != spv::ExecutionModel::GLCompute) {
                  if (message) {
                    *message =
                        errorVUID +
                        "in Vulkan environment, Workgroup execution scope is "
                        "only for TaskNV, MeshNV, TaskEXT, MeshEXT, "
                        "TessellationControl, and GLCompute execution models";
                  }
                  return false;
                }
                return true;
              });
    }

    // Vulkan generic rules
    // Scope for execution must be limited to Workgroup or Subgroup
    if (value != spv::Scope::Workgroup && value != spv::Scope::Subgroup) {
      return _.diag(SPV_ERROR_INVALID_DATA, inst)
             << _.VkErrorID(4636) << spvOpcodeString(opcode)
             << ": in Vulkan environment Execution Scope is limited to "
             << "Workgroup and Subgroup";
    }
  }

  // TODO(atgoo@github.com) Add checks for OpenCL and OpenGL environments.

  // General SPIRV rules
  // OpGroupNonUniformRotateKHR is the only non-uniform group operation that
  // allows Workgroup scope; all others are limited to Subgroup.
  if (spvOpcodeIsNonUniformGroupOperation(opcode) &&
      opcode != spv::Op::OpGroupNonUniformQuadAllKHR &&
      opcode != spv::Op::OpGroupNonUniformQuadAnyKHR &&
      opcode != spv::Op::OpGroupNonUniformRotateKHR &&
      value != spv::Scope::Subgroup) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << spvOpcodeString(opcode) << ": Execution scope is limited to "
           << "Subgroup";
  }

  if (opcode == spv::Op::OpGroupNonUniformRotateKHR &&
      value != spv::Scope::Subgroup && value != spv::Scope::Workgroup) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << spvOpcodeString(opcode)
           << ": Execution scope is limited to Subgroup or Workgroup";
  }

  return SPV_SUCCESS;
}

spv_result_t ValidateMemoryScope(ValidationState_t& _, const Instruction* inst,
                                 uint32_t scope) {
  const spv::Op opcode = inst->opcode();
  bool is_int32 = false, is_const_int32 = false;
  uint32_t tmp_value = 0;
  std::tie(is_int32, is_const_int32, tmp_value) = _.EvalInt32IfConst(scope);

  if (auto error = ValidateScope(_, inst, scope)) {
    return error;
  }

  if (!is_const_int32) {
    return SPV_SUCCESS;
  }

  spv::Scope value = spv::Scope(tmp_value);

  if (value == spv::Scope::QueueFamilyKHR) {
    if (_.HasCapability(spv::Capability::VulkanMemoryModelKHR)) {
      return SPV_SUCCESS;
    } else {
      return _.diag(SPV_ERROR_INVALID_DATA, inst)
             << spvOpcodeString(opcode)
             << ": Memory Scope QueueFamilyKHR requires capability "
             << "VulkanMemoryModelKHR";
    }
  }

  if (value == spv::Scope::Device &&
      _.HasCapability(spv::Capability::VulkanMemoryModelKHR) &&
      !_.HasCapability(spv::Capability::VulkanMemoryModelDeviceScopeKHR)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Use of device scope with VulkanKHR memory model requires the "
           << "VulkanMemoryModelDeviceScopeKHR capability";
  }

  // Vulkan Specific rules
  if (spvIsVulkanEnv(_.context()->target_env)) {
    if (value != spv::Scope::Device && value != spv::Scope::Workgroup &&
        value != spv::Scope::Subgroup && value != spv::Scope::Invocation &&
        value != spv::Scope::ShaderCallKHR &&
        value != spv::Scope::QueueFamily) {
      return _.diag(SPV_ERROR_INVALID_DATA, inst)
             << _.VkErrorID(4638) << spvOpcodeString(opcode)
             << ": in Vulkan environment Memory Scope is limited to Device, "
                "QueueFamily, Workgroup, ShaderCallKHR, Subgroup, or "
                "Invocation";
    } else if (_.context()->target_env == SPV_ENV_VULKAN_1_0 &&
               value == spv::Scope::Subgroup &&
               !_.HasCapability(spv::Capability::SubgroupBallotKHR) &&
               !_.HasCapability(spv::Capability::SubgroupVoteKHR)) {
      return _.diag(SPV_ERROR_INVALID_DATA, inst)
             << _.VkErrorID(7951) << spvOpcodeString(opcode)
             << ": in Vulkan 1.0 environment Memory Scope is can not be "
                "Subgroup without SubgroupBallotKHR or SubgroupVoteKHR "
                "declared";
    }

    if (value == spv::Scope::ShaderCallKHR) {
      std::string errorVUID = _.VkErrorID(4640);
      _.function(inst->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::MissKHR &&
                    model != spv::ExecutionModel::CallableKHR) {
                  if (message) {
                    *message =
                        errorVUID +
                        "ShaderCallKHR Memory Scope requires a ray tracing "
                        "execution model";
                  }
                  return false;
                }
                return true;
              });
    }

    if (value == spv::Scope::Workgroup) {
      std::string errorVUID = _.VkErrorID(7321);
      _.function(inst->function()->id())
          ->RegisterExecutionModelLimitation(
              [errorVUID](spv::ExecutionModel model, std::string* message) {
                if (model != spv::ExecutionModel::GLCompute &&
                    model != spv::ExecutionModel::TessellationControl &&
                    model != spv::ExecutionModel::TaskNV &&
                    model != spv::ExecutionModel::MeshNV &&
                    model != spv::ExecutionModel::TaskEXT &&
                    model != spv::ExecutionModel::MeshEXT) {
                  if (message) {
                    *message = errorVUID +
                               "Workgroup Memory Scope is limited to MeshNV, "
                               "TaskNV, MeshEXT, TaskEXT, TessellationControl, "
                               "and GLCompute execution model";
                  }
                  return false;
                }
                return true;
              });

      if (_.memory_model() == spv::MemoryModel::GLSL450) {
        errorVUID = _.VkErrorID(7320);
        _.function(inst->function()->id())
            ->RegisterExecutionModelLimitation(
                [errorVUID](spv::ExecutionModel model, std::string* message) {
                  if (model == spv::ExecutionModel::TessellationControl) {
                    if (message) {
                      *message =
                          errorVUID +
                          "Workgroup Memory Scope can't be used with "
                          "TessellationControl using GLSL450 Memory Model";
                    }
                    return false;
                  }
                  return true;
                });
      }
    }
  }

  // TODO(atgoo@github.com) Add checks for OpenCL and OpenGL environments.

  return SPV_SUCCESS;
}

}  // namespace val
}  // namespace spvtools