source/val/validate_pipe.cpp

// Copyright (c) 2026 LunarG 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.

// Validates correctness of Pipe SPIR-V instructions.

#include "source/val/instruction.h"
#include "source/val/validate.h"
#include "source/val/validate_scopes.h"
#include "source/val/validation_state.h"
#include "spirv/unified1/spirv.hpp11"

namespace spvtools {
namespace val {
namespace {

enum class ValidPipeType {
  READ_ONLY,
  WRITE_ONLY,
  READ_OR_WRITE,  // still excludes Read AND Write
};

spv_result_t ValidatePipeType(ValidationState_t& _, const Instruction* inst,
                              uint32_t operand, ValidPipeType valid_pt) {
  const Instruction* pipe_type = _.FindDef(_.GetOperandTypeId(inst, operand));
  if (pipe_type->opcode() != spv::Op::OpTypePipe) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Pipe must be a type of OpTypePipe.";
  }

  const auto access_qualifier =
      pipe_type->GetOperandAs<spv::AccessQualifier>(1);
  if (valid_pt == ValidPipeType::READ_ONLY) {
    if (access_qualifier != spv::AccessQualifier::ReadOnly) {
      return _.diag(SPV_ERROR_INVALID_DATA, inst)
             << "Pipe must have a OpTypePipe with ReadOnly access qualifier.";
    }
  } else if (valid_pt == ValidPipeType::WRITE_ONLY) {
    if (access_qualifier != spv::AccessQualifier::WriteOnly) {
      return _.diag(SPV_ERROR_INVALID_DATA, inst)
             << "Pipe must have a OpTypePipe with WriteOnly access qualifier.";
    }
  } else if (valid_pt == ValidPipeType::READ_OR_WRITE) {
    if (access_qualifier != spv::AccessQualifier::ReadOnly &&
        access_qualifier != spv::AccessQualifier::WriteOnly) {
      return _.diag(SPV_ERROR_INVALID_DATA, inst)
             << "Pipe must have a OpTypePipe with ReadOnly or WriteOnly access "
                "qualifier.";
    }
  }

  return SPV_SUCCESS;
}

spv_result_t ValidatePacketSizeAlign(ValidationState_t& _,
                                     const Instruction* inst,
                                     uint32_t size_operand,
                                     uint32_t alignment_operand) {
  const uint32_t packet_size_id = _.GetOperandTypeId(inst, size_operand);
  if (!_.IsIntScalarType(packet_size_id, 32)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Packet Size must be a 32-bit scalar integer.";
  }

  const uint32_t packet_alignment_id =
      _.GetOperandTypeId(inst, alignment_operand);
  if (!_.IsIntScalarType(packet_alignment_id, 32)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Packet Alignment must be a 32-bit scalar integer.";
  }

  return SPV_SUCCESS;
}

spv_result_t ValidateReadWritePipe(ValidationState_t& _,
                                   const Instruction* inst) {
  const uint32_t result_type = inst->type_id();
  if (!_.IsIntScalarType(result_type, 32)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Result Type must be a 32-bit int scalar.";
  }

  if (inst->opcode() == spv::Op::OpReadPipe) {
    if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::READ_ONLY))
      return error;
  } else if (inst->opcode() == spv::Op::OpWritePipe) {
    if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::WRITE_ONLY))
      return error;
  }

  const Instruction* pointer_type = _.FindDef(_.GetOperandTypeId(inst, 3));
  if (pointer_type->opcode() != spv::Op::OpTypePointer) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Pointer must be a type of OpTypePointer.";
  }
  if (pointer_type->GetOperandAs<spv::StorageClass>(1) !=
      spv::StorageClass::Generic) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Pointer must be a OpTypePointer with a Generic storage class.";
  }

  if (auto error = ValidatePacketSizeAlign(_, inst, 4, 5)) return error;

  return SPV_SUCCESS;
}

spv_result_t ValidateReservedReadWritePipe(ValidationState_t& _,
                                           const Instruction* inst) {
  const uint32_t result_type = inst->type_id();
  if (!_.IsIntScalarType(result_type, 32)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Result Type must be a 32-bit int scalar.";
  }

  if (inst->opcode() == spv::Op::OpReservedReadPipe) {
    if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::READ_ONLY))
      return error;
  } else if (inst->opcode() == spv::Op::OpReservedWritePipe) {
    if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::WRITE_ONLY))
      return error;
  }

  const Instruction* reserve_id = _.FindDef(_.GetOperandTypeId(inst, 3));
  if (reserve_id->opcode() != spv::Op::OpTypeReserveId) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Reserve Id type must be OpTypeReserveId.";
  }

  const uint32_t index_id = _.GetOperandTypeId(inst, 4);
  if (!_.IsIntScalarType(index_id, 32)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Index must be a 32-bit scalar integer.";
  }

  const Instruction* pointer_type = _.FindDef(_.GetOperandTypeId(inst, 5));
  if (pointer_type->opcode() != spv::Op::OpTypePointer) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Pointer must be a type of OpTypePointer.";
  }
  if (pointer_type->GetOperandAs<spv::StorageClass>(1) !=
      spv::StorageClass::Generic) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Pointer must be a OpTypePointer with a Generic storage class.";
  }

  if (auto error = ValidatePacketSizeAlign(_, inst, 6, 7)) return error;

  return SPV_SUCCESS;
}

spv_result_t ValidateReservePackets(ValidationState_t& _,
                                    const Instruction* inst) {
  const Instruction* result_type = _.FindDef(inst->type_id());
  if (result_type->opcode() != spv::Op::OpTypeReserveId) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Result Type must be OpTypeReserveId.";
  }

  if (inst->opcode() == spv::Op::OpReserveReadPipePackets) {
    if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::READ_ONLY))
      return error;
  } else if (inst->opcode() == spv::Op::OpReserveWritePipePackets) {
    if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::WRITE_ONLY))
      return error;
  }

  const uint32_t num_packets_id = _.GetOperandTypeId(inst, 3);
  if (!_.IsIntScalarType(num_packets_id, 32)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Num Packets must be a 32-bit scalar integer.";
  }

  if (auto error = ValidatePacketSizeAlign(_, inst, 4, 5)) return error;

  return SPV_SUCCESS;
}

spv_result_t ValidateGroupReservePackets(ValidationState_t& _,
                                         const Instruction* inst) {
  const Instruction* result_type = _.FindDef(inst->type_id());
  if (result_type->opcode() != spv::Op::OpTypeReserveId) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Result Type must be OpTypeReserveId.";
  }

  if (inst->opcode() == spv::Op::OpGroupReserveReadPipePackets) {
    if (auto error = ValidatePipeType(_, inst, 3, ValidPipeType::READ_ONLY))
      return error;
  } else if (inst->opcode() == spv::Op::OpGroupReserveWritePipePackets) {
    if (auto error = ValidatePipeType(_, inst, 3, ValidPipeType::WRITE_ONLY))
      return error;
  }

  const uint32_t num_packets_id = _.GetOperandTypeId(inst, 4);
  if (!_.IsIntScalarType(num_packets_id, 32)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Num Packets must be a 32-bit scalar integer.";
  }

  if (auto error = ValidatePacketSizeAlign(_, inst, 5, 6)) return error;

  return SPV_SUCCESS;
}

spv_result_t ValidateCommitPipe(ValidationState_t& _, const Instruction* inst) {
  if (inst->opcode() == spv::Op::OpCommitReadPipe) {
    if (auto error = ValidatePipeType(_, inst, 0, ValidPipeType::READ_ONLY))
      return error;
  } else if (inst->opcode() == spv::Op::OpCommitWritePipe) {
    if (auto error = ValidatePipeType(_, inst, 0, ValidPipeType::WRITE_ONLY))
      return error;
  }

  const Instruction* reserve_id = _.FindDef(_.GetOperandTypeId(inst, 1));
  if (reserve_id->opcode() != spv::Op::OpTypeReserveId) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Reserve Id type must be OpTypeReserveId.";
  }

  if (auto error = ValidatePacketSizeAlign(_, inst, 2, 3)) return error;

  return SPV_SUCCESS;
}

spv_result_t ValidateGroupCommitPipe(ValidationState_t& _,
                                     const Instruction* inst) {
  if (inst->opcode() == spv::Op::OpGroupCommitReadPipe) {
    if (auto error = ValidatePipeType(_, inst, 1, ValidPipeType::READ_ONLY))
      return error;
  } else if (inst->opcode() == spv::Op::OpGroupCommitWritePipe) {
    if (auto error = ValidatePipeType(_, inst, 1, ValidPipeType::WRITE_ONLY))
      return error;
  }

  const Instruction* reserve_id = _.FindDef(_.GetOperandTypeId(inst, 2));
  if (reserve_id->opcode() != spv::Op::OpTypeReserveId) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Reserve Id type must be OpTypeReserveId.";
  }

  if (auto error = ValidatePacketSizeAlign(_, inst, 3, 4)) return error;

  return SPV_SUCCESS;
}

spv_result_t ValidatePipePacketsQuery(ValidationState_t& _,
                                      const Instruction* inst) {
  const uint32_t result_type = inst->type_id();
  if (!_.IsIntScalarType(result_type, 32)) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Result Type must be a 32-bit int scalar.";
  }

  if (auto error = ValidatePipeType(_, inst, 2, ValidPipeType::READ_OR_WRITE))
    return error;

  if (auto error = ValidatePacketSizeAlign(_, inst, 3, 4)) return error;

  return SPV_SUCCESS;
}

spv_result_t ValidateIsValidReserveId(ValidationState_t& _,
                                      const Instruction* inst) {
  if (!_.IsBoolScalarType(inst->type_id())) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Result Type must be a bool scalar";
  }

  const Instruction* reserve_id = _.FindDef(_.GetOperandTypeId(inst, 2));
  if (reserve_id->opcode() != spv::Op::OpTypeReserveId) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Reserve Id type must be OpTypeReserveId.";
  }

  return SPV_SUCCESS;
}

spv_result_t ValidateCreatePipeFromPipeStorage(ValidationState_t& _,
                                               const Instruction* inst) {
  const Instruction* result_type = _.FindDef(inst->type_id());
  if (result_type->opcode() != spv::Op::OpTypePipe) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Result Type must be OpTypePipe.";
  }

  // TODO - Need to check OpTypeStorage is from OpConstantPipeStorage
  return SPV_SUCCESS;
}

spv_result_t ValidateConstantPipeStorage(ValidationState_t& _,
                                         const Instruction* inst) {
  const Instruction* result_type = _.FindDef(inst->type_id());
  if (result_type->opcode() != spv::Op::OpTypePipeStorage) {
    return _.diag(SPV_ERROR_INVALID_DATA, inst)
           << "Result Type must be OpTypePipeStorage.";
  }

  // TODO - Should we validate the literal values?
  // https://gitlab.khronos.org/spirv/SPIR-V/-/issues/914
  return SPV_SUCCESS;
}

}  // namespace

// Validates correctness of pipe instructions.
spv_result_t PipePass(ValidationState_t& _, const Instruction* inst) {
  switch (inst->opcode()) {
    case spv::Op::OpReadPipe:
    case spv::Op::OpWritePipe:
      return ValidateReadWritePipe(_, inst);
    case spv::Op::OpReservedReadPipe:
    case spv::Op::OpReservedWritePipe:
      return ValidateReservedReadWritePipe(_, inst);
    case spv::Op::OpReserveReadPipePackets:
    case spv::Op::OpReserveWritePipePackets:
      return ValidateReservePackets(_, inst);
    case spv::Op::OpGroupReserveReadPipePackets:
    case spv::Op::OpGroupReserveWritePipePackets:
      return ValidateGroupReservePackets(_, inst);
    case spv::Op::OpCommitReadPipe:
    case spv::Op::OpCommitWritePipe:
      return ValidateCommitPipe(_, inst);
    case spv::Op::OpGroupCommitReadPipe:
    case spv::Op::OpGroupCommitWritePipe:
      return ValidateGroupCommitPipe(_, inst);
    case spv::Op::OpGetNumPipePackets:
    case spv::Op::OpGetMaxPipePackets:
      return ValidatePipePacketsQuery(_, inst);
    case spv::Op::OpIsValidReserveId:
      return ValidateIsValidReserveId(_, inst);
    case spv::Op::OpCreatePipeFromPipeStorage:
      return ValidateCreatePipeFromPipeStorage(_, inst);
    case spv::Op::OpConstantPipeStorage:
      return ValidateConstantPipeStorage(_, inst);
    default:
      break;
  }

  return SPV_SUCCESS;
}

}  // namespace val
}  // namespace spvtools