static void
ssa_decoration_cb(struct vtn_builder *b, struct vtn_value *val, int member,
- const struct vtn_decoration *dec, void *void_ssa)
+ const struct vtn_decoration *dec, void *void_ctx)
{
- struct vtn_ssa_value *ssa = void_ssa;
-
switch (dec->decoration) {
case SpvDecorationNonUniformEXT:
- ssa->access |= ACCESS_NON_UNIFORM;
+ if (val->value_type == vtn_value_type_ssa) {
+ val->ssa->access |= ACCESS_NON_UNIFORM;
+ } else if (val->value_type == vtn_value_type_pointer) {
+ val->pointer->access |= ACCESS_NON_UNIFORM;
+ } else if (val->value_type == vtn_value_type_sampled_image) {
+ val->sampled_image->image->access |= ACCESS_NON_UNIFORM;
+ } else if (val->value_type == vtn_value_type_image_pointer) {
+ val->image->image->access |= ACCESS_NON_UNIFORM;
+ }
break;
default:
} else {
val = vtn_push_value(b, value_id, vtn_value_type_ssa);
val->ssa = ssa;
- vtn_foreach_decoration(b, val, ssa_decoration_cb, val->ssa);
+ vtn_foreach_decoration(b, val, ssa_decoration_cb, NULL);
}
return val;
}
+void
+vtn_copy_value(struct vtn_builder *b, uint32_t src_value_id,
+ uint32_t dst_value_id)
+{
+ struct vtn_value *src = vtn_untyped_value(b, src_value_id);
+ struct vtn_value *dst = vtn_push_value(b, dst_value_id, src->value_type);
+ struct vtn_value src_copy = *src;
+
+ vtn_fail_if(dst->type->id != src->type->id,
+ "Result Type must equal Operand type");
+
+ src_copy.name = dst->name;
+ src_copy.decoration = dst->decoration;
+ src_copy.type = dst->type;
+ *dst = src_copy;
+
+ vtn_foreach_decoration(b, dst, ssa_decoration_cb, NULL);
+}
+
static struct vtn_access_chain *
vtn_access_chain_create(struct vtn_builder *b, unsigned length)
{
}
}
-struct vtn_pointer *
-vtn_pointer_for_variable(struct vtn_builder *b,
- struct vtn_variable *var, struct vtn_type *ptr_type)
-{
- struct vtn_pointer *pointer = rzalloc(b, struct vtn_pointer);
-
- pointer->mode = var->mode;
- pointer->type = var->type;
- vtn_assert(ptr_type->base_type == vtn_base_type_pointer);
- vtn_assert(ptr_type->deref->type == var->type->type);
- pointer->ptr_type = ptr_type;
- pointer->var = var;
- pointer->access = var->access | var->type->access;
-
- return pointer;
-}
-
/* Returns an atomic_uint type based on the original uint type. The returned
* type will be equivalent to the original one but will have an atomic_uint
* type as leaf instead of an uint.
struct vtn_ssa_value *val = vtn_create_ssa_value(b, dest_tail->type);
_vtn_local_load_store(b, true, dest_tail, val, access);
- if (nir_src_is_const(dest->arr.index))
- val->def = vtn_vector_insert(b, val->def, src->def,
- nir_src_as_uint(dest->arr.index));
- else
- val->def = vtn_vector_insert_dynamic(b, val->def, src->def,
- dest->arr.index.ssa);
+ val->def = nir_vector_insert(&b->nb, val->def, src->def,
+ dest->arr.index.ssa);
_vtn_local_load_store(b, false, dest_tail, val, access);
} else {
_vtn_local_load_store(b, false, dest_tail, src, access);
case SpvDecorationRestrict:
var_data->access |= ACCESS_RESTRICT;
break;
+ case SpvDecorationAliased:
+ var_data->access &= ~ACCESS_RESTRICT;
+ break;
case SpvDecorationVolatile:
var_data->access |= ACCESS_VOLATILE;
break;
case SpvDecorationRowMajor:
case SpvDecorationColMajor:
case SpvDecorationMatrixStride:
- case SpvDecorationAliased:
case SpvDecorationUniform:
case SpvDecorationUniformId:
case SpvDecorationLinkageAttributes:
break;
case SpvDecorationUserSemantic:
+ case SpvDecorationUserTypeGOOGLE:
/* User semantic decorations can safely be ignored by the driver. */
break;
var->mode = mode;
var->base_location = -1;
- vtn_assert(val->value_type == vtn_value_type_pointer);
- val->pointer = vtn_pointer_for_variable(b, var, ptr_type);
+ val->pointer = rzalloc(b, struct vtn_pointer);
+ val->pointer->mode = var->mode;
+ val->pointer->type = var->type;
+ val->pointer->ptr_type = ptr_type;
+ val->pointer->var = var;
+ val->pointer->access = var->type->access;
switch (var->mode) {
case vtn_variable_mode_function:
if (var_initializer)
var->var->pointer_initializer = var_initializer;
+ if (var->mode == vtn_variable_mode_uniform ||
+ var->mode == vtn_variable_mode_ssbo) {
+ /* SSBOs and images are assumed to not alias in the Simple, GLSL and Vulkan memory models */
+ var->var->data.access |= b->mem_model != SpvMemoryModelOpenCL ? ACCESS_RESTRICT : 0;
+ }
+
vtn_foreach_decoration(b, val, var_decoration_cb, var);
vtn_foreach_decoration(b, val, ptr_decoration_cb, val->pointer);
+ /* Propagate access flags from the OpVariable decorations. */
+ val->pointer->access |= var->access;
+
if ((var->mode == vtn_variable_mode_input ||
var->mode == vtn_variable_mode_output) &&
var->var->members) {
case SpvOpConvertUToPtr: {
struct vtn_value *ptr_val =
vtn_push_value(b, w[2], vtn_value_type_pointer);
- struct vtn_value *u_val = vtn_value(b, w[3], vtn_value_type_ssa);
+ struct vtn_value *u_val = vtn_untyped_value(b, w[3]);
vtn_fail_if(ptr_val->type->type == NULL,
"OpConvertUToPtr can only be used on physical pointers");
"OpConvertUToPtr can only be used to cast from a vector or "
"scalar type");
- nir_ssa_def *ptr_ssa = nir_sloppy_bitcast(&b->nb, u_val->ssa->def,
+ struct vtn_ssa_value *u_ssa = vtn_ssa_value(b, w[3]);
+ nir_ssa_def *ptr_ssa = nir_sloppy_bitcast(&b->nb, u_ssa->def,
ptr_val->type->type);
ptr_val->pointer = vtn_pointer_from_ssa(b, ptr_ssa, ptr_val->type);
vtn_foreach_decoration(b, ptr_val, ptr_decoration_cb, ptr_val->pointer);
projects / mesa.git / blobdiff