case SpvOpTypeImage: {
val->type->base_type = vtn_base_type_image;
- const struct glsl_type *sampled_type =
- vtn_value(b, w[2], vtn_value_type_type)->type->type;
+ const struct vtn_type *sampled_type =
+ vtn_value(b, w[2], vtn_value_type_type)->type;
- vtn_assert(glsl_type_is_vector_or_scalar(sampled_type));
+ vtn_fail_if(sampled_type->base_type != vtn_base_type_scalar ||
+ glsl_get_bit_size(sampled_type->type) != 32,
+ "Sampled type of OpTypeImage must be a 32-bit scalar");
enum glsl_sampler_dim dim;
switch ((SpvDim)w[3]) {
case SpvDimBuffer: dim = GLSL_SAMPLER_DIM_BUF; break;
case SpvDimSubpassData: dim = GLSL_SAMPLER_DIM_SUBPASS; break;
default:
- vtn_fail("Invalid SPIR-V Sampler dimension");
+ vtn_fail("Invalid SPIR-V image dimensionality");
}
bool is_shadow = w[4];
val->type->image_format = translate_image_format(b, format);
+ enum glsl_base_type sampled_base_type =
+ glsl_get_base_type(sampled_type->type);
if (sampled == 1) {
val->type->sampled = true;
val->type->type = glsl_sampler_type(dim, is_shadow, is_array,
- glsl_get_base_type(sampled_type));
+ sampled_base_type);
} else if (sampled == 2) {
vtn_assert(!is_shadow);
val->type->sampled = false;
- val->type->type = glsl_image_type(dim, is_array,
- glsl_get_base_type(sampled_type));
+ val->type->type = glsl_image_type(dim, is_array, sampled_base_type);
} else {
vtn_fail("We need to know if the image will be sampled");
}
val->constant = rzalloc(b, nir_constant);
switch (opcode) {
case SpvOpConstantTrue:
- vtn_assert(val->type->type == glsl_bool_type());
- val->constant->values[0].u32[0] = NIR_TRUE;
- break;
case SpvOpConstantFalse:
- vtn_assert(val->type->type == glsl_bool_type());
- val->constant->values[0].u32[0] = NIR_FALSE;
- break;
-
case SpvOpSpecConstantTrue:
case SpvOpSpecConstantFalse: {
- vtn_assert(val->type->type == glsl_bool_type());
- uint32_t int_val =
- get_specialization(b, val, (opcode == SpvOpSpecConstantTrue));
+ vtn_fail_if(val->type->type != glsl_bool_type(),
+ "Result type of %s must be OpTypeBool",
+ spirv_op_to_string(opcode));
+
+ uint32_t int_val = (opcode == SpvOpConstantTrue ||
+ opcode == SpvOpSpecConstantTrue);
+
+ if (opcode == SpvOpSpecConstantTrue ||
+ opcode == SpvOpSpecConstantFalse)
+ int_val = get_specialization(b, val, int_val);
+
val->constant->values[0].u32[0] = int_val ? NIR_TRUE : NIR_FALSE;
break;
}
case SpvOpConstant: {
- vtn_assert(glsl_type_is_scalar(val->type->type));
+ vtn_fail_if(val->type->base_type != vtn_base_type_scalar,
+ "Result type of %s must be a scalar",
+ spirv_op_to_string(opcode));
int bit_size = glsl_get_bit_size(val->type->type);
switch (bit_size) {
case 64:
}
break;
}
+
case SpvOpSpecConstant: {
- vtn_assert(glsl_type_is_scalar(val->type->type));
- val->constant->values[0].u32[0] = get_specialization(b, val, w[3]);
+ vtn_fail_if(val->type->base_type != vtn_base_type_scalar,
+ "Result type of %s must be a scalar",
+ spirv_op_to_string(opcode));
int bit_size = glsl_get_bit_size(val->type->type);
switch (bit_size) {
case 64:
}
break;
}
+
case SpvOpSpecConstantComposite:
case SpvOpConstantComposite: {
unsigned elem_count = count - 3;
+ vtn_fail_if(elem_count != val->type->length,
+ "%s has %u constituents, expected %u",
+ spirv_op_to_string(opcode), elem_count, val->type->length);
+
nir_constant **elems = ralloc_array(b, nir_constant *, elem_count);
for (unsigned i = 0; i < elem_count; i++)
elems[i] = vtn_value(b, w[i + 3], vtn_value_type_constant)->constant;
- switch (glsl_get_base_type(val->type->type)) {
- case GLSL_TYPE_UINT:
- case GLSL_TYPE_INT:
- case GLSL_TYPE_UINT16:
- case GLSL_TYPE_INT16:
- case GLSL_TYPE_UINT64:
- case GLSL_TYPE_INT64:
- case GLSL_TYPE_FLOAT:
- case GLSL_TYPE_FLOAT16:
- case GLSL_TYPE_BOOL:
- case GLSL_TYPE_DOUBLE: {
+ switch (val->type->base_type) {
+ case vtn_base_type_vector: {
+ assert(glsl_type_is_vector(val->type->type));
int bit_size = glsl_get_bit_size(val->type->type);
- if (glsl_type_is_matrix(val->type->type)) {
- vtn_assert(glsl_get_matrix_columns(val->type->type) == elem_count);
- for (unsigned i = 0; i < elem_count; i++)
- val->constant->values[i] = elems[i]->values[0];
- } else {
- vtn_assert(glsl_type_is_vector(val->type->type));
- vtn_assert(glsl_get_vector_elements(val->type->type) == elem_count);
- for (unsigned i = 0; i < elem_count; i++) {
- switch (bit_size) {
- case 64:
- val->constant->values[0].u64[i] = elems[i]->values[0].u64[0];
- break;
- case 32:
- val->constant->values[0].u32[i] = elems[i]->values[0].u32[0];
- break;
- case 16:
- val->constant->values[0].u16[i] = elems[i]->values[0].u16[0];
- break;
- default:
- vtn_fail("Invalid SpvOpConstantComposite bit size");
- }
+ for (unsigned i = 0; i < elem_count; i++) {
+ switch (bit_size) {
+ case 64:
+ val->constant->values[0].u64[i] = elems[i]->values[0].u64[0];
+ break;
+ case 32:
+ val->constant->values[0].u32[i] = elems[i]->values[0].u32[0];
+ break;
+ case 16:
+ val->constant->values[0].u16[i] = elems[i]->values[0].u16[0];
+ break;
+ default:
+ vtn_fail("Invalid SpvOpConstantComposite bit size");
}
}
- ralloc_free(elems);
break;
}
- case GLSL_TYPE_STRUCT:
- case GLSL_TYPE_ARRAY:
+
+ case vtn_base_type_matrix:
+ assert(glsl_type_is_matrix(val->type->type));
+ for (unsigned i = 0; i < elem_count; i++)
+ val->constant->values[i] = elems[i]->values[0];
+ break;
+
+ case vtn_base_type_struct:
+ case vtn_base_type_array:
ralloc_steal(val->constant, elems);
val->constant->num_elements = elem_count;
val->constant->elements = elems;
break;
default:
- vtn_fail("Unsupported type for constants");
+ vtn_fail("Result type of %s must be a composite type",
+ spirv_op_to_string(opcode));
}
break;
}
int elem = -1;
int col = 0;
- const struct glsl_type *type = comp->type->type;
+ const struct vtn_type *type = comp->type;
for (unsigned i = deref_start; i < count; i++) {
- switch (glsl_get_base_type(type)) {
- case GLSL_TYPE_UINT:
- case GLSL_TYPE_INT:
- case GLSL_TYPE_UINT16:
- case GLSL_TYPE_INT16:
- case GLSL_TYPE_UINT64:
- case GLSL_TYPE_INT64:
- case GLSL_TYPE_FLOAT:
- case GLSL_TYPE_FLOAT16:
- case GLSL_TYPE_DOUBLE:
- case GLSL_TYPE_BOOL:
- /* If we hit this granularity, we're picking off an element */
- if (glsl_type_is_matrix(type)) {
- vtn_assert(col == 0 && elem == -1);
- col = w[i];
- elem = 0;
- type = glsl_get_column_type(type);
- } else {
- vtn_assert(elem <= 0 && glsl_type_is_vector(type));
- elem = w[i];
- type = glsl_scalar_type(glsl_get_base_type(type));
- }
- continue;
-
- case GLSL_TYPE_ARRAY:
+ vtn_fail_if(w[i] > type->length,
+ "%uth index of %s is %u but the type has only "
+ "%u elements", i - deref_start,
+ spirv_op_to_string(opcode), w[i], type->length);
+
+ switch (type->base_type) {
+ case vtn_base_type_vector:
+ elem = w[i];
+ type = type->array_element;
+ break;
+
+ case vtn_base_type_matrix:
+ assert(col == 0 && elem == -1);
+ col = w[i];
+ elem = 0;
+ type = type->array_element;
+ break;
+
+ case vtn_base_type_array:
c = &(*c)->elements[w[i]];
- type = glsl_get_array_element(type);
- continue;
+ type = type->array_element;
+ break;
- case GLSL_TYPE_STRUCT:
+ case vtn_base_type_struct:
c = &(*c)->elements[w[i]];
- type = glsl_get_struct_field(type, w[i]);
- continue;
+ type = type->members[w[i]];
+ break;
default:
- vtn_fail("Invalid constant type");
+ vtn_fail("%s must only index into composite types",
+ spirv_op_to_string(opcode));
}
}
if (elem == -1) {
val->constant = *c;
} else {
- unsigned num_components = glsl_get_vector_elements(type);
- unsigned bit_size = glsl_get_bit_size(type);
+ unsigned num_components = type->length;
+ unsigned bit_size = glsl_get_bit_size(type->type);
for (unsigned i = 0; i < num_components; i++)
switch(bit_size) {
case 64:
} else {
struct vtn_value *insert =
vtn_value(b, w[4], vtn_value_type_constant);
- vtn_assert(insert->type->type == type);
+ vtn_assert(insert->type == type);
if (elem == -1) {
*c = insert->constant;
} else {
- unsigned num_components = glsl_get_vector_elements(type);
- unsigned bit_size = glsl_get_bit_size(type);
+ unsigned num_components = type->length;
+ unsigned bit_size = glsl_get_bit_size(type->type);
for (unsigned i = 0; i < num_components; i++)
switch (bit_size) {
case 64:
projects / mesa.git / blobdiff