2037 lines
77 KiB
C++
2037 lines
77 KiB
C++
// Copyright (c) 2018 Google 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 extension SPIR-V instructions.
|
|
|
|
#include "source/val/validate.h"
|
|
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "source/diagnostic.h"
|
|
#include "source/enum_string_mapping.h"
|
|
#include "source/extensions.h"
|
|
#include "source/latest_version_glsl_std_450_header.h"
|
|
#include "source/latest_version_opencl_std_header.h"
|
|
#include "source/opcode.h"
|
|
#include "source/spirv_target_env.h"
|
|
#include "source/val/instruction.h"
|
|
#include "source/val/validation_state.h"
|
|
|
|
namespace spvtools {
|
|
namespace val {
|
|
namespace {
|
|
|
|
uint32_t GetSizeTBitWidth(const ValidationState_t& _) {
|
|
if (_.addressing_model() == SpvAddressingModelPhysical32) return 32;
|
|
|
|
if (_.addressing_model() == SpvAddressingModelPhysical64) return 64;
|
|
|
|
return 0;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
spv_result_t ValidateExtension(ValidationState_t& _, const Instruction* inst) {
|
|
if (spvIsWebGPUEnv(_.context()->target_env)) {
|
|
std::string extension = GetExtensionString(&(inst->c_inst()));
|
|
|
|
if (extension != ExtensionToString(kSPV_KHR_vulkan_memory_model)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "For WebGPU, the only valid parameter to OpExtension is "
|
|
<< "\"" << ExtensionToString(kSPV_KHR_vulkan_memory_model)
|
|
<< "\".";
|
|
}
|
|
}
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t ValidateExtInstImport(ValidationState_t& _,
|
|
const Instruction* inst) {
|
|
if (spvIsWebGPUEnv(_.context()->target_env)) {
|
|
const auto name_id = 1;
|
|
const std::string name(reinterpret_cast<const char*>(
|
|
inst->words().data() + inst->operands()[name_id].offset));
|
|
if (name != "GLSL.std.450") {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "For WebGPU, the only valid parameter to OpExtInstImport is "
|
|
"\"GLSL.std.450\".";
|
|
}
|
|
}
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t ValidateExtInst(ValidationState_t& _, const Instruction* inst) {
|
|
const uint32_t result_type = inst->type_id();
|
|
const uint32_t num_operands = static_cast<uint32_t>(inst->operands().size());
|
|
|
|
const uint32_t ext_inst_set = inst->word(3);
|
|
const uint32_t ext_inst_index = inst->word(4);
|
|
const spv_ext_inst_type_t ext_inst_type =
|
|
spv_ext_inst_type_t(inst->ext_inst_type());
|
|
|
|
auto ext_inst_name = [&_, ext_inst_set, ext_inst_type, ext_inst_index]() {
|
|
spv_ext_inst_desc desc = nullptr;
|
|
if (_.grammar().lookupExtInst(ext_inst_type, ext_inst_index, &desc) !=
|
|
SPV_SUCCESS ||
|
|
!desc) {
|
|
return std::string("Unknown ExtInst");
|
|
}
|
|
|
|
auto* import_inst = _.FindDef(ext_inst_set);
|
|
assert(import_inst);
|
|
|
|
std::ostringstream ss;
|
|
ss << reinterpret_cast<const char*>(import_inst->words().data() + 2);
|
|
ss << " ";
|
|
ss << desc->name;
|
|
|
|
return ss.str();
|
|
};
|
|
|
|
if (ext_inst_type == SPV_EXT_INST_TYPE_GLSL_STD_450) {
|
|
const GLSLstd450 ext_inst_key = GLSLstd450(ext_inst_index);
|
|
switch (ext_inst_key) {
|
|
case GLSLstd450Round:
|
|
case GLSLstd450RoundEven:
|
|
case GLSLstd450FAbs:
|
|
case GLSLstd450Trunc:
|
|
case GLSLstd450FSign:
|
|
case GLSLstd450Floor:
|
|
case GLSLstd450Ceil:
|
|
case GLSLstd450Fract:
|
|
case GLSLstd450Sqrt:
|
|
case GLSLstd450InverseSqrt:
|
|
case GLSLstd450FMin:
|
|
case GLSLstd450FMax:
|
|
case GLSLstd450FClamp:
|
|
case GLSLstd450FMix:
|
|
case GLSLstd450Step:
|
|
case GLSLstd450SmoothStep:
|
|
case GLSLstd450Fma:
|
|
case GLSLstd450Normalize:
|
|
case GLSLstd450FaceForward:
|
|
case GLSLstd450Reflect:
|
|
case GLSLstd450NMin:
|
|
case GLSLstd450NMax:
|
|
case GLSLstd450NClamp: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar or vector type";
|
|
}
|
|
|
|
for (uint32_t operand_index = 4; operand_index < num_operands;
|
|
++operand_index) {
|
|
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
|
|
if (result_type != operand_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected types of all operands to be equal to Result "
|
|
"Type";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450SAbs:
|
|
case GLSLstd450SSign:
|
|
case GLSLstd450UMin:
|
|
case GLSLstd450SMin:
|
|
case GLSLstd450UMax:
|
|
case GLSLstd450SMax:
|
|
case GLSLstd450UClamp:
|
|
case GLSLstd450SClamp:
|
|
case GLSLstd450FindILsb:
|
|
case GLSLstd450FindUMsb:
|
|
case GLSLstd450FindSMsb: {
|
|
if (!_.IsIntScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be an int scalar or vector type";
|
|
}
|
|
|
|
const uint32_t result_type_bit_width = _.GetBitWidth(result_type);
|
|
const uint32_t result_type_dimension = _.GetDimension(result_type);
|
|
|
|
for (uint32_t operand_index = 4; operand_index < num_operands;
|
|
++operand_index) {
|
|
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
|
|
if (!_.IsIntScalarOrVectorType(operand_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected all operands to be int scalars or vectors";
|
|
}
|
|
|
|
if (result_type_dimension != _.GetDimension(operand_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected all operands to have the same dimension as "
|
|
<< "Result Type";
|
|
}
|
|
|
|
if (result_type_bit_width != _.GetBitWidth(operand_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected all operands to have the same bit width as "
|
|
<< "Result Type";
|
|
}
|
|
|
|
if (ext_inst_key == GLSLstd450FindUMsb ||
|
|
ext_inst_key == GLSLstd450FindSMsb) {
|
|
if (result_type_bit_width != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "this instruction is currently limited to 32-bit width "
|
|
<< "components";
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450Radians:
|
|
case GLSLstd450Degrees:
|
|
case GLSLstd450Sin:
|
|
case GLSLstd450Cos:
|
|
case GLSLstd450Tan:
|
|
case GLSLstd450Asin:
|
|
case GLSLstd450Acos:
|
|
case GLSLstd450Atan:
|
|
case GLSLstd450Sinh:
|
|
case GLSLstd450Cosh:
|
|
case GLSLstd450Tanh:
|
|
case GLSLstd450Asinh:
|
|
case GLSLstd450Acosh:
|
|
case GLSLstd450Atanh:
|
|
case GLSLstd450Exp:
|
|
case GLSLstd450Exp2:
|
|
case GLSLstd450Log:
|
|
case GLSLstd450Log2:
|
|
case GLSLstd450Atan2:
|
|
case GLSLstd450Pow: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a 16 or 32-bit scalar or "
|
|
"vector float type";
|
|
}
|
|
|
|
const uint32_t result_type_bit_width = _.GetBitWidth(result_type);
|
|
if (result_type_bit_width != 16 && result_type_bit_width != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a 16 or 32-bit scalar or "
|
|
"vector float type";
|
|
}
|
|
|
|
for (uint32_t operand_index = 4; operand_index < num_operands;
|
|
++operand_index) {
|
|
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
|
|
if (result_type != operand_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected types of all operands to be equal to Result "
|
|
"Type";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450Determinant: {
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
uint32_t num_rows = 0;
|
|
uint32_t num_cols = 0;
|
|
uint32_t col_type = 0;
|
|
uint32_t component_type = 0;
|
|
if (!_.GetMatrixTypeInfo(x_type, &num_rows, &num_cols, &col_type,
|
|
&component_type) ||
|
|
num_rows != num_cols) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X to be a square matrix";
|
|
}
|
|
|
|
if (result_type != component_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X component type to be equal to "
|
|
<< "Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450MatrixInverse: {
|
|
uint32_t num_rows = 0;
|
|
uint32_t num_cols = 0;
|
|
uint32_t col_type = 0;
|
|
uint32_t component_type = 0;
|
|
if (!_.GetMatrixTypeInfo(result_type, &num_rows, &num_cols, &col_type,
|
|
&component_type) ||
|
|
num_rows != num_cols) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a square matrix";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
if (result_type != x_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X type to be equal to Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450Modf: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or vector float type";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t i_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
if (x_type != result_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X type to be equal to Result Type";
|
|
}
|
|
|
|
uint32_t i_storage_class = 0;
|
|
uint32_t i_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(i_type, &i_data_type, &i_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand I to be a pointer";
|
|
}
|
|
|
|
if (i_data_type != result_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand I data type to be equal to Result Type";
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450ModfStruct: {
|
|
std::vector<uint32_t> result_types;
|
|
if (!_.GetStructMemberTypes(result_type, &result_types) ||
|
|
result_types.size() != 2 ||
|
|
!_.IsFloatScalarOrVectorType(result_types[0]) ||
|
|
result_types[1] != result_types[0]) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a struct with two identical "
|
|
<< "scalar or vector float type members";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
if (x_type != result_types[0]) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X type to be equal to members of "
|
|
<< "Result Type struct";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450Frexp: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or vector float type";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t exp_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
if (x_type != result_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X type to be equal to Result Type";
|
|
}
|
|
|
|
uint32_t exp_storage_class = 0;
|
|
uint32_t exp_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(exp_type, &exp_data_type,
|
|
&exp_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Exp to be a pointer";
|
|
}
|
|
|
|
if (!_.IsIntScalarOrVectorType(exp_data_type) ||
|
|
(!_.HasExtension(kSPV_AMD_gpu_shader_int16) &&
|
|
_.GetBitWidth(exp_data_type) != 32) ||
|
|
(_.HasExtension(kSPV_AMD_gpu_shader_int16) &&
|
|
_.GetBitWidth(exp_data_type) != 16 &&
|
|
_.GetBitWidth(exp_data_type) != 32)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Exp data type to be a "
|
|
<< (_.HasExtension(kSPV_AMD_gpu_shader_int16)
|
|
? "16-bit or 32-bit "
|
|
: "32-bit ")
|
|
<< "int scalar or vector type";
|
|
}
|
|
|
|
if (_.GetDimension(result_type) != _.GetDimension(exp_data_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Exp data type to have the same component "
|
|
<< "number as Result Type";
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450Ldexp: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or vector float type";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t exp_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
if (x_type != result_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X type to be equal to Result Type";
|
|
}
|
|
|
|
if (!_.IsIntScalarOrVectorType(exp_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Exp to be a 32-bit int scalar "
|
|
<< "or vector type";
|
|
}
|
|
|
|
if (_.GetDimension(result_type) != _.GetDimension(exp_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Exp to have the same component "
|
|
<< "number as Result Type";
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450FrexpStruct: {
|
|
std::vector<uint32_t> result_types;
|
|
if (!_.GetStructMemberTypes(result_type, &result_types) ||
|
|
result_types.size() != 2 ||
|
|
!_.IsFloatScalarOrVectorType(result_types[0]) ||
|
|
!_.IsIntScalarOrVectorType(result_types[1]) ||
|
|
(!_.HasExtension(kSPV_AMD_gpu_shader_int16) &&
|
|
_.GetBitWidth(result_types[1]) != 32) ||
|
|
(_.HasExtension(kSPV_AMD_gpu_shader_int16) &&
|
|
_.GetBitWidth(result_types[1]) != 16 &&
|
|
_.GetBitWidth(result_types[1]) != 32) ||
|
|
_.GetDimension(result_types[0]) !=
|
|
_.GetDimension(result_types[1])) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a struct with two members, "
|
|
<< "first member a float scalar or vector, second member a "
|
|
<< (_.HasExtension(kSPV_AMD_gpu_shader_int16)
|
|
? "16-bit or 32-bit "
|
|
: "32-bit ")
|
|
<< "int scalar or vector with the same number of "
|
|
<< "components as the first member";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
if (x_type != result_types[0]) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X type to be equal to the first member "
|
|
<< "of Result Type struct";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450PackSnorm4x8:
|
|
case GLSLstd450PackUnorm4x8: {
|
|
if (!_.IsIntScalarType(result_type) ||
|
|
_.GetBitWidth(result_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be 32-bit int scalar type";
|
|
}
|
|
|
|
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 4 ||
|
|
_.GetBitWidth(v_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand V to be a 32-bit float vector of size 4";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450PackSnorm2x16:
|
|
case GLSLstd450PackUnorm2x16:
|
|
case GLSLstd450PackHalf2x16: {
|
|
if (!_.IsIntScalarType(result_type) ||
|
|
_.GetBitWidth(result_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be 32-bit int scalar type";
|
|
}
|
|
|
|
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsFloatVectorType(v_type) || _.GetDimension(v_type) != 2 ||
|
|
_.GetBitWidth(v_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand V to be a 32-bit float vector of size 2";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450PackDouble2x32: {
|
|
if (!_.IsFloatScalarType(result_type) ||
|
|
_.GetBitWidth(result_type) != 64) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be 64-bit float scalar type";
|
|
}
|
|
|
|
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsIntVectorType(v_type) || _.GetDimension(v_type) != 2 ||
|
|
_.GetBitWidth(v_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand V to be a 32-bit int vector of size 2";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450UnpackSnorm4x8:
|
|
case GLSLstd450UnpackUnorm4x8: {
|
|
if (!_.IsFloatVectorType(result_type) ||
|
|
_.GetDimension(result_type) != 4 ||
|
|
_.GetBitWidth(result_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a 32-bit float vector of size "
|
|
"4";
|
|
}
|
|
|
|
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P to be a 32-bit int scalar";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450UnpackSnorm2x16:
|
|
case GLSLstd450UnpackUnorm2x16:
|
|
case GLSLstd450UnpackHalf2x16: {
|
|
if (!_.IsFloatVectorType(result_type) ||
|
|
_.GetDimension(result_type) != 2 ||
|
|
_.GetBitWidth(result_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a 32-bit float vector of size "
|
|
"2";
|
|
}
|
|
|
|
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsIntScalarType(v_type) || _.GetBitWidth(v_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P to be a 32-bit int scalar";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450UnpackDouble2x32: {
|
|
if (!_.IsIntVectorType(result_type) ||
|
|
_.GetDimension(result_type) != 2 ||
|
|
_.GetBitWidth(result_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a 32-bit int vector of size "
|
|
"2";
|
|
}
|
|
|
|
const uint32_t v_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsFloatScalarType(v_type) || _.GetBitWidth(v_type) != 64) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand V to be a 64-bit float scalar";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450Length: {
|
|
if (!_.IsFloatScalarType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar type";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsFloatScalarOrVectorType(x_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X to be of float scalar or vector type";
|
|
}
|
|
|
|
if (result_type != _.GetComponentType(x_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X component type to be equal to Result "
|
|
"Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450Distance: {
|
|
if (!_.IsFloatScalarType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar type";
|
|
}
|
|
|
|
const uint32_t p0_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsFloatScalarOrVectorType(p0_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P0 to be of float scalar or vector type";
|
|
}
|
|
|
|
if (result_type != _.GetComponentType(p0_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P0 component type to be equal to "
|
|
<< "Result Type";
|
|
}
|
|
|
|
const uint32_t p1_type = _.GetOperandTypeId(inst, 5);
|
|
if (!_.IsFloatScalarOrVectorType(p1_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P1 to be of float scalar or vector type";
|
|
}
|
|
|
|
if (result_type != _.GetComponentType(p1_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P1 component type to be equal to "
|
|
<< "Result Type";
|
|
}
|
|
|
|
if (_.GetDimension(p0_type) != _.GetDimension(p1_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operands P0 and P1 to have the same number of "
|
|
<< "components";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450Cross: {
|
|
if (!_.IsFloatVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float vector type";
|
|
}
|
|
|
|
if (_.GetDimension(result_type) != 3) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to have 3 components";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t y_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
if (x_type != result_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X type to be equal to Result Type";
|
|
}
|
|
|
|
if (y_type != result_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Y type to be equal to Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450Refract: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar or vector type";
|
|
}
|
|
|
|
const uint32_t i_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t n_type = _.GetOperandTypeId(inst, 5);
|
|
const uint32_t eta_type = _.GetOperandTypeId(inst, 6);
|
|
|
|
if (result_type != i_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand I to be of type equal to Result Type";
|
|
}
|
|
|
|
if (result_type != n_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand N to be of type equal to Result Type";
|
|
}
|
|
|
|
if (!_.IsFloatScalarType(eta_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Eta to be a float scalar";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450InterpolateAtCentroid:
|
|
case GLSLstd450InterpolateAtSample:
|
|
case GLSLstd450InterpolateAtOffset: {
|
|
if (!_.HasCapability(SpvCapabilityInterpolationFunction)) {
|
|
return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst)
|
|
<< ext_inst_name()
|
|
<< " requires capability InterpolationFunction";
|
|
}
|
|
|
|
if (!_.IsFloatScalarOrVectorType(result_type) ||
|
|
_.GetBitWidth(result_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a 32-bit float scalar "
|
|
<< "or vector type";
|
|
}
|
|
|
|
const uint32_t interpolant_type = _.GetOperandTypeId(inst, 4);
|
|
uint32_t interpolant_storage_class = 0;
|
|
uint32_t interpolant_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(interpolant_type, &interpolant_data_type,
|
|
&interpolant_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Interpolant to be a pointer";
|
|
}
|
|
|
|
if (result_type != interpolant_data_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Interpolant data type to be equal to Result Type";
|
|
}
|
|
|
|
if (interpolant_storage_class != SpvStorageClassInput) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Interpolant storage class to be Input";
|
|
}
|
|
|
|
if (ext_inst_key == GLSLstd450InterpolateAtSample) {
|
|
const uint32_t sample_type = _.GetOperandTypeId(inst, 5);
|
|
if (!_.IsIntScalarType(sample_type) ||
|
|
_.GetBitWidth(sample_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Sample to be 32-bit integer";
|
|
}
|
|
}
|
|
|
|
if (ext_inst_key == GLSLstd450InterpolateAtOffset) {
|
|
const uint32_t offset_type = _.GetOperandTypeId(inst, 5);
|
|
if (!_.IsFloatVectorType(offset_type) ||
|
|
_.GetDimension(offset_type) != 2 ||
|
|
_.GetBitWidth(offset_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Offset to be a vector of 2 32-bit floats";
|
|
}
|
|
}
|
|
|
|
_.function(inst->function()->id())
|
|
->RegisterExecutionModelLimitation(
|
|
SpvExecutionModelFragment,
|
|
ext_inst_name() +
|
|
std::string(" requires Fragment execution model"));
|
|
break;
|
|
}
|
|
|
|
case GLSLstd450IMix: {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Extended instruction GLSLstd450IMix is not supported";
|
|
}
|
|
|
|
case GLSLstd450Bad: {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< "Encountered extended instruction GLSLstd450Bad";
|
|
}
|
|
|
|
case GLSLstd450Count: {
|
|
assert(0);
|
|
break;
|
|
}
|
|
}
|
|
} else if (ext_inst_type == SPV_EXT_INST_TYPE_OPENCL_STD) {
|
|
const OpenCLLIB::Entrypoints ext_inst_key =
|
|
OpenCLLIB::Entrypoints(ext_inst_index);
|
|
switch (ext_inst_key) {
|
|
case OpenCLLIB::Acos:
|
|
case OpenCLLIB::Acosh:
|
|
case OpenCLLIB::Acospi:
|
|
case OpenCLLIB::Asin:
|
|
case OpenCLLIB::Asinh:
|
|
case OpenCLLIB::Asinpi:
|
|
case OpenCLLIB::Atan:
|
|
case OpenCLLIB::Atan2:
|
|
case OpenCLLIB::Atanh:
|
|
case OpenCLLIB::Atanpi:
|
|
case OpenCLLIB::Atan2pi:
|
|
case OpenCLLIB::Cbrt:
|
|
case OpenCLLIB::Ceil:
|
|
case OpenCLLIB::Copysign:
|
|
case OpenCLLIB::Cos:
|
|
case OpenCLLIB::Cosh:
|
|
case OpenCLLIB::Cospi:
|
|
case OpenCLLIB::Erfc:
|
|
case OpenCLLIB::Erf:
|
|
case OpenCLLIB::Exp:
|
|
case OpenCLLIB::Exp2:
|
|
case OpenCLLIB::Exp10:
|
|
case OpenCLLIB::Expm1:
|
|
case OpenCLLIB::Fabs:
|
|
case OpenCLLIB::Fdim:
|
|
case OpenCLLIB::Floor:
|
|
case OpenCLLIB::Fma:
|
|
case OpenCLLIB::Fmax:
|
|
case OpenCLLIB::Fmin:
|
|
case OpenCLLIB::Fmod:
|
|
case OpenCLLIB::Hypot:
|
|
case OpenCLLIB::Lgamma:
|
|
case OpenCLLIB::Log:
|
|
case OpenCLLIB::Log2:
|
|
case OpenCLLIB::Log10:
|
|
case OpenCLLIB::Log1p:
|
|
case OpenCLLIB::Logb:
|
|
case OpenCLLIB::Mad:
|
|
case OpenCLLIB::Maxmag:
|
|
case OpenCLLIB::Minmag:
|
|
case OpenCLLIB::Nextafter:
|
|
case OpenCLLIB::Pow:
|
|
case OpenCLLIB::Powr:
|
|
case OpenCLLIB::Remainder:
|
|
case OpenCLLIB::Rint:
|
|
case OpenCLLIB::Round:
|
|
case OpenCLLIB::Rsqrt:
|
|
case OpenCLLIB::Sin:
|
|
case OpenCLLIB::Sinh:
|
|
case OpenCLLIB::Sinpi:
|
|
case OpenCLLIB::Sqrt:
|
|
case OpenCLLIB::Tan:
|
|
case OpenCLLIB::Tanh:
|
|
case OpenCLLIB::Tanpi:
|
|
case OpenCLLIB::Tgamma:
|
|
case OpenCLLIB::Trunc:
|
|
case OpenCLLIB::Half_cos:
|
|
case OpenCLLIB::Half_divide:
|
|
case OpenCLLIB::Half_exp:
|
|
case OpenCLLIB::Half_exp2:
|
|
case OpenCLLIB::Half_exp10:
|
|
case OpenCLLIB::Half_log:
|
|
case OpenCLLIB::Half_log2:
|
|
case OpenCLLIB::Half_log10:
|
|
case OpenCLLIB::Half_powr:
|
|
case OpenCLLIB::Half_recip:
|
|
case OpenCLLIB::Half_rsqrt:
|
|
case OpenCLLIB::Half_sin:
|
|
case OpenCLLIB::Half_sqrt:
|
|
case OpenCLLIB::Half_tan:
|
|
case OpenCLLIB::Native_cos:
|
|
case OpenCLLIB::Native_divide:
|
|
case OpenCLLIB::Native_exp:
|
|
case OpenCLLIB::Native_exp2:
|
|
case OpenCLLIB::Native_exp10:
|
|
case OpenCLLIB::Native_log:
|
|
case OpenCLLIB::Native_log2:
|
|
case OpenCLLIB::Native_log10:
|
|
case OpenCLLIB::Native_powr:
|
|
case OpenCLLIB::Native_recip:
|
|
case OpenCLLIB::Native_rsqrt:
|
|
case OpenCLLIB::Native_sin:
|
|
case OpenCLLIB::Native_sqrt:
|
|
case OpenCLLIB::Native_tan:
|
|
case OpenCLLIB::FClamp:
|
|
case OpenCLLIB::Degrees:
|
|
case OpenCLLIB::FMax_common:
|
|
case OpenCLLIB::FMin_common:
|
|
case OpenCLLIB::Mix:
|
|
case OpenCLLIB::Radians:
|
|
case OpenCLLIB::Step:
|
|
case OpenCLLIB::Smoothstep:
|
|
case OpenCLLIB::Sign: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar or vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
for (uint32_t operand_index = 4; operand_index < num_operands;
|
|
++operand_index) {
|
|
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
|
|
if (result_type != operand_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected types of all operands to be equal to Result "
|
|
"Type";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Fract:
|
|
case OpenCLLIB::Modf:
|
|
case OpenCLLIB::Sincos:
|
|
case OpenCLLIB::Remquo: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar or vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
uint32_t operand_index = 4;
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++);
|
|
if (result_type != x_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected type of operand X to be equal to Result Type";
|
|
}
|
|
|
|
if (ext_inst_key == OpenCLLIB::Remquo) {
|
|
const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++);
|
|
if (result_type != y_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected type of operand Y to be equal to Result Type";
|
|
}
|
|
}
|
|
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, operand_index++);
|
|
uint32_t p_storage_class = 0;
|
|
uint32_t p_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected the last operand to be a pointer";
|
|
}
|
|
|
|
if (p_storage_class != SpvStorageClassGeneric &&
|
|
p_storage_class != SpvStorageClassCrossWorkgroup &&
|
|
p_storage_class != SpvStorageClassWorkgroup &&
|
|
p_storage_class != SpvStorageClassFunction) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected storage class of the pointer to be Generic, "
|
|
"CrossWorkgroup, Workgroup or Function";
|
|
}
|
|
|
|
if (result_type != p_data_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected data type of the pointer to be equal to Result "
|
|
"Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Frexp:
|
|
case OpenCLLIB::Lgamma_r: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar or vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
if (result_type != x_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected type of operand X to be equal to Result Type";
|
|
}
|
|
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, 5);
|
|
uint32_t p_storage_class = 0;
|
|
uint32_t p_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected the last operand to be a pointer";
|
|
}
|
|
|
|
if (p_storage_class != SpvStorageClassGeneric &&
|
|
p_storage_class != SpvStorageClassCrossWorkgroup &&
|
|
p_storage_class != SpvStorageClassWorkgroup &&
|
|
p_storage_class != SpvStorageClassFunction) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected storage class of the pointer to be Generic, "
|
|
"CrossWorkgroup, Workgroup or Function";
|
|
}
|
|
|
|
if (!_.IsIntScalarOrVectorType(p_data_type) ||
|
|
_.GetBitWidth(p_data_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected data type of the pointer to be a 32-bit int "
|
|
"scalar or vector type";
|
|
}
|
|
|
|
if (_.GetDimension(p_data_type) != num_components) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected data type of the pointer to have the same number "
|
|
"of components as Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Ilogb: {
|
|
if (!_.IsIntScalarOrVectorType(result_type) ||
|
|
_.GetBitWidth(result_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a 32-bit int scalar or vector "
|
|
"type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsFloatScalarOrVectorType(x_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X to be a float scalar or vector";
|
|
}
|
|
|
|
if (_.GetDimension(x_type) != num_components) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X to have the same number of components "
|
|
"as Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Ldexp:
|
|
case OpenCLLIB::Pown:
|
|
case OpenCLLIB::Rootn: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar or vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
if (result_type != x_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected type of operand X to be equal to Result Type";
|
|
}
|
|
|
|
const uint32_t exp_type = _.GetOperandTypeId(inst, 5);
|
|
if (!_.IsIntScalarOrVectorType(exp_type) ||
|
|
_.GetBitWidth(exp_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected the exponent to be a 32-bit int scalar or vector";
|
|
}
|
|
|
|
if (_.GetDimension(exp_type) != num_components) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected the exponent to have the same number of "
|
|
"components as Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Nan: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar or vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t nancode_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsIntScalarOrVectorType(nancode_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Nancode to be an int scalar or vector type";
|
|
}
|
|
|
|
if (_.GetDimension(nancode_type) != num_components) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Nancode to have the same number of components as "
|
|
"Result Type";
|
|
}
|
|
|
|
if (_.GetBitWidth(result_type) != _.GetBitWidth(nancode_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Nancode to have the same bit width as Result "
|
|
"Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::SAbs:
|
|
case OpenCLLIB::SAbs_diff:
|
|
case OpenCLLIB::SAdd_sat:
|
|
case OpenCLLIB::UAdd_sat:
|
|
case OpenCLLIB::SHadd:
|
|
case OpenCLLIB::UHadd:
|
|
case OpenCLLIB::SRhadd:
|
|
case OpenCLLIB::URhadd:
|
|
case OpenCLLIB::SClamp:
|
|
case OpenCLLIB::UClamp:
|
|
case OpenCLLIB::Clz:
|
|
case OpenCLLIB::Ctz:
|
|
case OpenCLLIB::SMad_hi:
|
|
case OpenCLLIB::UMad_sat:
|
|
case OpenCLLIB::SMad_sat:
|
|
case OpenCLLIB::SMax:
|
|
case OpenCLLIB::UMax:
|
|
case OpenCLLIB::SMin:
|
|
case OpenCLLIB::UMin:
|
|
case OpenCLLIB::SMul_hi:
|
|
case OpenCLLIB::Rotate:
|
|
case OpenCLLIB::SSub_sat:
|
|
case OpenCLLIB::USub_sat:
|
|
case OpenCLLIB::Popcount:
|
|
case OpenCLLIB::UAbs:
|
|
case OpenCLLIB::UAbs_diff:
|
|
case OpenCLLIB::UMul_hi:
|
|
case OpenCLLIB::UMad_hi: {
|
|
if (!_.IsIntScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be an int scalar or vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
for (uint32_t operand_index = 4; operand_index < num_operands;
|
|
++operand_index) {
|
|
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
|
|
if (result_type != operand_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected types of all operands to be equal to Result "
|
|
"Type";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::U_Upsample:
|
|
case OpenCLLIB::S_Upsample: {
|
|
if (!_.IsIntScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be an int scalar or vector "
|
|
"type";
|
|
}
|
|
|
|
const uint32_t result_num_components = _.GetDimension(result_type);
|
|
if (result_num_components > 4 && result_num_components != 8 &&
|
|
result_num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t result_bit_width = _.GetBitWidth(result_type);
|
|
if (result_bit_width != 16 && result_bit_width != 32 &&
|
|
result_bit_width != 64) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected bit width of Result Type components to be 16, 32 "
|
|
"or 64";
|
|
}
|
|
|
|
const uint32_t hi_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t lo_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
if (hi_type != lo_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Hi and Lo operands to have the same type";
|
|
}
|
|
|
|
if (result_num_components != _.GetDimension(hi_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Hi and Lo operands to have the same number of "
|
|
"components as Result Type";
|
|
}
|
|
|
|
if (result_bit_width != 2 * _.GetBitWidth(hi_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected bit width of components of Hi and Lo operands to "
|
|
"be half of the bit width of components of Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::SMad24:
|
|
case OpenCLLIB::UMad24:
|
|
case OpenCLLIB::SMul24:
|
|
case OpenCLLIB::UMul24: {
|
|
if (!_.IsIntScalarOrVectorType(result_type) ||
|
|
_.GetBitWidth(result_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a 32-bit int scalar or vector "
|
|
"type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
for (uint32_t operand_index = 4; operand_index < num_operands;
|
|
++operand_index) {
|
|
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
|
|
if (result_type != operand_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected types of all operands to be equal to Result "
|
|
"Type";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Cross: {
|
|
if (!_.IsFloatVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components != 3 && num_components != 4) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to have 3 or 4 components";
|
|
}
|
|
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t y_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
if (x_type != result_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X type to be equal to Result Type";
|
|
}
|
|
|
|
if (y_type != result_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Y type to be equal to Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Distance:
|
|
case OpenCLLIB::Fast_distance: {
|
|
if (!_.IsFloatScalarType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar type";
|
|
}
|
|
|
|
const uint32_t p0_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsFloatScalarOrVectorType(p0_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P0 to be of float scalar or vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(p0_type);
|
|
if (num_components > 4) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P0 to have no more than 4 components";
|
|
}
|
|
|
|
if (result_type != _.GetComponentType(p0_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P0 component type to be equal to "
|
|
<< "Result Type";
|
|
}
|
|
|
|
const uint32_t p1_type = _.GetOperandTypeId(inst, 5);
|
|
if (p0_type != p1_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operands P0 and P1 to be of the same type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Length:
|
|
case OpenCLLIB::Fast_length: {
|
|
if (!_.IsFloatScalarType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar type";
|
|
}
|
|
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, 4);
|
|
if (!_.IsFloatScalarOrVectorType(p_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P to be a float scalar or vector";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(p_type);
|
|
if (num_components > 4) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P to have no more than 4 components";
|
|
}
|
|
|
|
if (result_type != _.GetComponentType(p_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P component type to be equal to Result "
|
|
"Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Normalize:
|
|
case OpenCLLIB::Fast_normalize: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar or vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to have no more than 4 components";
|
|
}
|
|
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, 4);
|
|
if (p_type != result_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P type to be equal to Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Bitselect: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type) &&
|
|
!_.IsIntScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be an int or float scalar or "
|
|
"vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
for (uint32_t operand_index = 4; operand_index < num_operands;
|
|
++operand_index) {
|
|
const uint32_t operand_type = _.GetOperandTypeId(inst, operand_index);
|
|
if (result_type != operand_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected types of all operands to be equal to Result "
|
|
"Type";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Select: {
|
|
if (!_.IsFloatScalarOrVectorType(result_type) &&
|
|
!_.IsIntScalarOrVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be an int or float scalar or "
|
|
"vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t a_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t b_type = _.GetOperandTypeId(inst, 5);
|
|
const uint32_t c_type = _.GetOperandTypeId(inst, 6);
|
|
|
|
if (result_type != a_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand A type to be equal to Result Type";
|
|
}
|
|
|
|
if (result_type != b_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand B type to be equal to Result Type";
|
|
}
|
|
|
|
if (!_.IsIntScalarOrVectorType(c_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand C to be an int scalar or vector";
|
|
}
|
|
|
|
if (num_components != _.GetDimension(c_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand C to have the same number of components "
|
|
"as Result Type";
|
|
}
|
|
|
|
if (_.GetBitWidth(result_type) != _.GetBitWidth(c_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand C to have the same bit width as Result "
|
|
"Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Vloadn: {
|
|
if (!_.IsFloatVectorType(result_type) &&
|
|
!_.IsIntVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be an int or float vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to have 2, 3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t offset_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
|
|
if (!size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name()
|
|
<< " can only be used with physical addressing models";
|
|
}
|
|
|
|
if (!_.IsIntScalarType(offset_type) ||
|
|
_.GetBitWidth(offset_type) != size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Offset to be of type size_t ("
|
|
<< size_t_bit_width
|
|
<< "-bit integer for the addressing model used in the module)";
|
|
}
|
|
|
|
uint32_t p_storage_class = 0;
|
|
uint32_t p_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P to be a pointer";
|
|
}
|
|
|
|
if (p_storage_class != SpvStorageClassUniformConstant &&
|
|
p_storage_class != SpvStorageClassGeneric &&
|
|
p_storage_class != SpvStorageClassCrossWorkgroup &&
|
|
p_storage_class != SpvStorageClassWorkgroup &&
|
|
p_storage_class != SpvStorageClassFunction) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P storage class to be UniformConstant, "
|
|
"Generic, CrossWorkgroup, Workgroup or Function";
|
|
}
|
|
|
|
if (_.GetComponentType(result_type) != p_data_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P data type to be equal to component "
|
|
"type of Result Type";
|
|
}
|
|
|
|
const uint32_t n_value = inst->word(7);
|
|
if (num_components != n_value) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected literal N to be equal to the number of "
|
|
"components of Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Vstoren: {
|
|
if (_.GetIdOpcode(result_type) != SpvOpTypeVoid) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": expected Result Type to be void";
|
|
}
|
|
|
|
const uint32_t data_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t offset_type = _.GetOperandTypeId(inst, 5);
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, 6);
|
|
|
|
if (!_.IsFloatVectorType(data_type) && !_.IsIntVectorType(data_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Data to be an int or float vector";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(data_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Data to have 2, 3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
|
|
if (!size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name()
|
|
<< " can only be used with physical addressing models";
|
|
}
|
|
|
|
if (!_.IsIntScalarType(offset_type) ||
|
|
_.GetBitWidth(offset_type) != size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Offset to be of type size_t ("
|
|
<< size_t_bit_width
|
|
<< "-bit integer for the addressing model used in the module)";
|
|
}
|
|
|
|
uint32_t p_storage_class = 0;
|
|
uint32_t p_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P to be a pointer";
|
|
}
|
|
|
|
if (p_storage_class != SpvStorageClassGeneric &&
|
|
p_storage_class != SpvStorageClassCrossWorkgroup &&
|
|
p_storage_class != SpvStorageClassWorkgroup &&
|
|
p_storage_class != SpvStorageClassFunction) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P storage class to be Generic, "
|
|
"CrossWorkgroup, Workgroup or Function";
|
|
}
|
|
|
|
if (_.GetComponentType(data_type) != p_data_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P data type to be equal to the type of "
|
|
"operand Data components";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Vload_half: {
|
|
if (!_.IsFloatScalarType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float scalar type";
|
|
}
|
|
|
|
const uint32_t offset_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
|
|
if (!size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name()
|
|
<< " can only be used with physical addressing models";
|
|
}
|
|
|
|
if (!_.IsIntScalarType(offset_type) ||
|
|
_.GetBitWidth(offset_type) != size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Offset to be of type size_t ("
|
|
<< size_t_bit_width
|
|
<< "-bit integer for the addressing model used in the module)";
|
|
}
|
|
|
|
uint32_t p_storage_class = 0;
|
|
uint32_t p_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P to be a pointer";
|
|
}
|
|
|
|
if (p_storage_class != SpvStorageClassUniformConstant &&
|
|
p_storage_class != SpvStorageClassGeneric &&
|
|
p_storage_class != SpvStorageClassCrossWorkgroup &&
|
|
p_storage_class != SpvStorageClassWorkgroup &&
|
|
p_storage_class != SpvStorageClassFunction) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P storage class to be UniformConstant, "
|
|
"Generic, CrossWorkgroup, Workgroup or Function";
|
|
}
|
|
|
|
if (!_.IsFloatScalarType(p_data_type) ||
|
|
_.GetBitWidth(p_data_type) != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P data type to be 16-bit float scalar";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Vload_halfn:
|
|
case OpenCLLIB::Vloada_halfn: {
|
|
if (!_.IsFloatVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a float vector type";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(result_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to have 2, 3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t offset_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
|
|
if (!size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name()
|
|
<< " can only be used with physical addressing models";
|
|
}
|
|
|
|
if (!_.IsIntScalarType(offset_type) ||
|
|
_.GetBitWidth(offset_type) != size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Offset to be of type size_t ("
|
|
<< size_t_bit_width
|
|
<< "-bit integer for the addressing model used in the module)";
|
|
}
|
|
|
|
uint32_t p_storage_class = 0;
|
|
uint32_t p_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P to be a pointer";
|
|
}
|
|
|
|
if (p_storage_class != SpvStorageClassUniformConstant &&
|
|
p_storage_class != SpvStorageClassGeneric &&
|
|
p_storage_class != SpvStorageClassCrossWorkgroup &&
|
|
p_storage_class != SpvStorageClassWorkgroup &&
|
|
p_storage_class != SpvStorageClassFunction) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P storage class to be UniformConstant, "
|
|
"Generic, CrossWorkgroup, Workgroup or Function";
|
|
}
|
|
|
|
if (!_.IsFloatScalarType(p_data_type) ||
|
|
_.GetBitWidth(p_data_type) != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P data type to be 16-bit float scalar";
|
|
}
|
|
|
|
const uint32_t n_value = inst->word(7);
|
|
if (num_components != n_value) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected literal N to be equal to the number of "
|
|
"components of Result Type";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Vstore_half:
|
|
case OpenCLLIB::Vstore_half_r:
|
|
case OpenCLLIB::Vstore_halfn:
|
|
case OpenCLLIB::Vstore_halfn_r:
|
|
case OpenCLLIB::Vstorea_halfn:
|
|
case OpenCLLIB::Vstorea_halfn_r: {
|
|
if (_.GetIdOpcode(result_type) != SpvOpTypeVoid) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": expected Result Type to be void";
|
|
}
|
|
|
|
const uint32_t data_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t offset_type = _.GetOperandTypeId(inst, 5);
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, 6);
|
|
const uint32_t data_type_bit_width = _.GetBitWidth(data_type);
|
|
|
|
if (ext_inst_key == OpenCLLIB::Vstore_half ||
|
|
ext_inst_key == OpenCLLIB::Vstore_half_r) {
|
|
if (!_.IsFloatScalarType(data_type) ||
|
|
(data_type_bit_width != 32 && data_type_bit_width != 64)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Data to be a 32 or 64-bit float scalar";
|
|
}
|
|
} else {
|
|
if (!_.IsFloatVectorType(data_type) ||
|
|
(data_type_bit_width != 32 && data_type_bit_width != 64)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Data to be a 32 or 64-bit float vector";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(data_type);
|
|
if (num_components > 4 && num_components != 8 &&
|
|
num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Data to have 2, 3, 4, 8 or 16 components";
|
|
}
|
|
}
|
|
|
|
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
|
|
if (!size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name()
|
|
<< " can only be used with physical addressing models";
|
|
}
|
|
|
|
if (!_.IsIntScalarType(offset_type) ||
|
|
_.GetBitWidth(offset_type) != size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Offset to be of type size_t ("
|
|
<< size_t_bit_width
|
|
<< "-bit integer for the addressing model used in the module)";
|
|
}
|
|
|
|
uint32_t p_storage_class = 0;
|
|
uint32_t p_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P to be a pointer";
|
|
}
|
|
|
|
if (p_storage_class != SpvStorageClassGeneric &&
|
|
p_storage_class != SpvStorageClassCrossWorkgroup &&
|
|
p_storage_class != SpvStorageClassWorkgroup &&
|
|
p_storage_class != SpvStorageClassFunction) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P storage class to be Generic, "
|
|
"CrossWorkgroup, Workgroup or Function";
|
|
}
|
|
|
|
if (!_.IsFloatScalarType(p_data_type) ||
|
|
_.GetBitWidth(p_data_type) != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand P data type to be 16-bit float scalar";
|
|
}
|
|
|
|
// Rounding mode enum is checked by assembler.
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Shuffle:
|
|
case OpenCLLIB::Shuffle2: {
|
|
if (!_.IsFloatVectorType(result_type) &&
|
|
!_.IsIntVectorType(result_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be an int or float vector type";
|
|
}
|
|
|
|
const uint32_t result_num_components = _.GetDimension(result_type);
|
|
if (result_num_components != 2 && result_num_components != 4 &&
|
|
result_num_components != 8 && result_num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to have 2, 4, 8 or 16 components";
|
|
}
|
|
|
|
uint32_t operand_index = 4;
|
|
const uint32_t x_type = _.GetOperandTypeId(inst, operand_index++);
|
|
|
|
if (ext_inst_key == OpenCLLIB::Shuffle2) {
|
|
const uint32_t y_type = _.GetOperandTypeId(inst, operand_index++);
|
|
if (x_type != y_type) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operands X and Y to be of the same type";
|
|
}
|
|
}
|
|
|
|
const uint32_t shuffle_mask_type =
|
|
_.GetOperandTypeId(inst, operand_index++);
|
|
|
|
if (!_.IsFloatVectorType(x_type) && !_.IsIntVectorType(x_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X to be an int or float vector";
|
|
}
|
|
|
|
const uint32_t x_num_components = _.GetDimension(x_type);
|
|
if (x_num_components != 2 && x_num_components != 4 &&
|
|
x_num_components != 8 && x_num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X to have 2, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t result_component_type = _.GetComponentType(result_type);
|
|
|
|
if (result_component_type != _.GetComponentType(x_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand X and Result Type to have equal "
|
|
"component types";
|
|
}
|
|
|
|
if (!_.IsIntVectorType(shuffle_mask_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Shuffle Mask to be an int vector";
|
|
}
|
|
|
|
if (result_num_components != _.GetDimension(shuffle_mask_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Shuffle Mask to have the same number of "
|
|
"components as Result Type";
|
|
}
|
|
|
|
if (_.GetBitWidth(result_component_type) !=
|
|
_.GetBitWidth(shuffle_mask_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Shuffle Mask components to have the same "
|
|
"bit width as Result Type components";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Printf: {
|
|
if (!_.IsIntScalarType(result_type) ||
|
|
_.GetBitWidth(result_type) != 32) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a 32-bit int type";
|
|
}
|
|
|
|
const uint32_t format_type = _.GetOperandTypeId(inst, 4);
|
|
uint32_t format_storage_class = 0;
|
|
uint32_t format_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(format_type, &format_data_type,
|
|
&format_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Format to be a pointer";
|
|
}
|
|
|
|
if (format_storage_class != SpvStorageClassUniformConstant) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Format storage class to be UniformConstant";
|
|
}
|
|
|
|
if (!_.IsIntScalarType(format_data_type) ||
|
|
_.GetBitWidth(format_data_type) != 8) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Format data type to be 8-bit int";
|
|
}
|
|
break;
|
|
}
|
|
|
|
case OpenCLLIB::Prefetch: {
|
|
if (_.GetIdOpcode(result_type) != SpvOpTypeVoid) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": expected Result Type to be void";
|
|
}
|
|
|
|
const uint32_t p_type = _.GetOperandTypeId(inst, 4);
|
|
const uint32_t num_elements_type = _.GetOperandTypeId(inst, 5);
|
|
|
|
uint32_t p_storage_class = 0;
|
|
uint32_t p_data_type = 0;
|
|
if (!_.GetPointerTypeInfo(p_type, &p_data_type, &p_storage_class)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Ptr to be a pointer";
|
|
}
|
|
|
|
if (p_storage_class != SpvStorageClassCrossWorkgroup) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Ptr storage class to be CrossWorkgroup";
|
|
}
|
|
|
|
if (!_.IsFloatScalarOrVectorType(p_data_type) &&
|
|
!_.IsIntScalarOrVectorType(p_data_type)) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Ptr data type to be int or float scalar or "
|
|
"vector";
|
|
}
|
|
|
|
const uint32_t num_components = _.GetDimension(p_data_type);
|
|
if (num_components > 4 && num_components != 8 && num_components != 16) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected Result Type to be a scalar or a vector with 2, "
|
|
"3, 4, 8 or 16 components";
|
|
}
|
|
|
|
const uint32_t size_t_bit_width = GetSizeTBitWidth(_);
|
|
if (!size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name()
|
|
<< " can only be used with physical addressing models";
|
|
}
|
|
|
|
if (!_.IsIntScalarType(num_elements_type) ||
|
|
_.GetBitWidth(num_elements_type) != size_t_bit_width) {
|
|
return _.diag(SPV_ERROR_INVALID_DATA, inst)
|
|
<< ext_inst_name() << ": "
|
|
<< "expected operand Num Elements to be of type size_t ("
|
|
<< size_t_bit_width
|
|
<< "-bit integer for the addressing model used in the module)";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
spv_result_t ExtensionPass(ValidationState_t& _, const Instruction* inst) {
|
|
const SpvOp opcode = inst->opcode();
|
|
if (opcode == SpvOpExtension) return ValidateExtension(_, inst);
|
|
if (opcode == SpvOpExtInstImport) return ValidateExtInstImport(_, inst);
|
|
if (opcode == SpvOpExtInst) return ValidateExtInst(_, inst);
|
|
|
|
return SPV_SUCCESS;
|
|
}
|
|
|
|
} // namespace val
|
|
} // namespace spvtools
|