Toastconcern--FrameStudio/third_party/spirv-tools/source/val/validate_barriers.cpp

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

// Validates correctness of barrier SPIR-V instructions.

#include <string>

#include "source/opcode.h"
#include "source/spirv_constant.h"
#include "source/val/instruction.h"
#include "source/val/validate.h"
#include "source/val/validate_memory_semantics.h"
#include "source/val/validate_scopes.h"
#include "source/val/validation_state.h"

namespace spvtools {
namespace val {

// Validates correctness of barrier instructions.
spv_result_t BarriersPass(ValidationState_t& _, const Instruction* inst) {
  const spv::Op opcode = inst->opcode();
  const uint32_t result_type = inst->type_id();

  switch (opcode) {
    case spv::Op::OpControlBarrier:
    case spv::Op::OpControlBarrierArriveEXT:
    case spv::Op::OpControlBarrierWaitEXT: {
      if (opcode == spv::Op::OpControlBarrier) {
        if (_.version() < SPV_SPIRV_VERSION_WORD(1, 3)) {
          _.function(inst->function()->id())
              ->RegisterExecutionModelLimitation([](spv::ExecutionModel model,
                                                    std::string* message) {
                if (model != spv::ExecutionModel::TessellationControl &&
                    model != spv::ExecutionModel::GLCompute &&
                    model != spv::ExecutionModel::Kernel &&
                    model != spv::ExecutionModel::TaskNV &&
                    model != spv::ExecutionModel::MeshNV) {
                  if (message) {
                    *message =
                        "In SPIR-V 1.2 or earlier, OpControlBarrier requires "
                        "one of the following "
                        "Execution Models: TessellationControl, GLCompute, "
                        "Kernel, MeshNV or TaskNV";
                  }
                  return false;
                }
                return true;
              });
        }
      }

      if (opcode == spv::Op::OpControlBarrierArriveEXT ||
          opcode == spv::Op::OpControlBarrierWaitEXT) {
        _.function(inst->function()->id())
            ->RegisterExecutionModelLimitation([&_](spv::ExecutionModel model,
                                                    std::string* message) {
              if (model != spv::ExecutionModel::GLCompute &&
                  model != spv::ExecutionModel::Kernel) {
                if (message) {
                  *message = _.VkErrorID(13552)
                                 .append(
                                     "The SplitBarrierEXT capability must not "
                                     "be enabled in any stage other than "
                                     "GLCompute or Kernel.")
                                 .c_str();
                }
                return false;
              }
              return true;
            });
      }

      const uint32_t execution_scope = inst->word(1);
      const uint32_t memory_scope = inst->word(2);

      if (auto error = ValidateExecutionScope(_, inst, execution_scope)) {
        return error;
      }

      if (auto error = ValidateMemoryScope(_, inst, memory_scope)) {
        return error;
      }

      if (auto error = ValidateMemorySemantics(_, inst, 2, memory_scope)) {
        return error;
      }
      break;
    }

    case spv::Op::OpMemoryBarrier: {
      const uint32_t memory_scope = inst->word(1);

      if (auto error = ValidateMemoryScope(_, inst, memory_scope)) {
        return error;
      }

      if (auto error = ValidateMemorySemantics(_, inst, 1, memory_scope)) {
        return error;
      }
      break;
    }

    case spv::Op::OpNamedBarrierInitialize: {
      if (_.GetIdOpcode(result_type) != spv::Op::OpTypeNamedBarrier) {
        return _.diag(SPV_ERROR_INVALID_DATA, inst)
               << spvOpcodeString(opcode)
               << ": expected Result Type to be OpTypeNamedBarrier";
      }

      const uint32_t subgroup_count_type = _.GetOperandTypeId(inst, 2);
      if (!_.IsIntScalarType(subgroup_count_type, 32)) {
        return _.diag(SPV_ERROR_INVALID_DATA, inst)
               << spvOpcodeString(opcode)
               << ": expected Subgroup Count to be a 32-bit int";
      }
      break;
    }

    case spv::Op::OpMemoryNamedBarrier: {
      const uint32_t named_barrier_type = _.GetOperandTypeId(inst, 0);
      if (_.GetIdOpcode(named_barrier_type) != spv::Op::OpTypeNamedBarrier) {
        return _.diag(SPV_ERROR_INVALID_DATA, inst)
               << spvOpcodeString(opcode)
               << ": expected Named Barrier to be of type OpTypeNamedBarrier";
      }

      const uint32_t memory_scope = inst->word(2);

      if (auto error = ValidateMemoryScope(_, inst, memory_scope)) {
        return error;
      }

      if (auto error = ValidateMemorySemantics(_, inst, 2, memory_scope)) {
        return error;
      }
      break;
    }

    default:
      break;
  }

  return SPV_SUCCESS;
}

}  // namespace val
}  // namespace spvtools