fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-21 22:20:14 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

spirv: Rename vtn_type::deref to vtn_type::pointed

Browse source 
To avoid confusion with the vtn_pointer::deref that is a NIR deref.  New
name comes from description of OpTypePointer, where is described as the
"type of the object pointed to".

Reviewed-by: Faith Ekstrand <faith.ekstrand@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/31069>
This commit is contained in:
Caio Oliveira 2024-09-06 11:06:40 -07:00 • committed by Marge Bot
parent c92e49e8f4
commit 95d08643ed
5 changed files with 34 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/compiler/spirv/spirv_to_nir.c
View file

@ -1081,7 +1081,7 @@ vtn_types_compatible(struct vtn_builder *b,
vtn_types_compatible(b, t1->array_element, t2->array_element); vtn_types_compatible(b, t1->array_element, t2->array_element);
case vtn_base_type_pointer: case vtn_base_type_pointer:
return vtn_types_compatible(b, t1->deref, t2->deref); return vtn_types_compatible(b, t1->pointed, t2->pointed);
case vtn_base_type_struct: case vtn_base_type_struct:
if (t1->length != t2->length) if (t1->length != t2->length)
@ -1945,9 +1945,9 @@ vtn_handle_type(struct vtn_builder *b, SpvOp opcode,
"OpTypeForwardPointer is only allowed in Vulkan with " "OpTypeForwardPointer is only allowed in Vulkan with "
"the PhysicalStorageBuffer storage class"); "the PhysicalStorageBuffer storage class");
struct vtn_type *deref_type = NULL; struct vtn_type *pointed_type = NULL;
if (opcode == SpvOpTypePointer) if (opcode == SpvOpTypePointer)
deref_type = vtn_get_type(b, w[3]); pointed_type = vtn_get_type(b, w[3]);
bool has_forward_pointer = false; bool has_forward_pointer = false;
if (val->value_type == vtn_value_type_invalid) { if (val->value_type == vtn_value_type_invalid) {
@ -1961,7 +1961,7 @@ vtn_handle_type(struct vtn_builder *b, SpvOp opcode,
* values so they need a real glsl_type. * values so they need a real glsl_type.
*/ */
enum vtn_variable_mode mode = vtn_storage_class_to_mode( enum vtn_variable_mode mode = vtn_storage_class_to_mode(
b, storage_class, deref_type, NULL); b, storage_class, pointed_type, NULL);
/* The deref type should only matter for the UniformConstant storage /* The deref type should only matter for the UniformConstant storage
* class. In particular, it should never matter for any storage * class. In particular, it should never matter for any storage
@ -1984,17 +1984,17 @@ vtn_handle_type(struct vtn_builder *b, SpvOp opcode,
} }
if (opcode == SpvOpTypePointer) { if (opcode == SpvOpTypePointer) {
vtn_fail_if(val->type->deref != NULL, vtn_fail_if(val->type->pointed != NULL,
"While OpTypeForwardPointer can be used to provide a " "While OpTypeForwardPointer can be used to provide a "
"forward declaration of a pointer, OpTypePointer can " "forward declaration of a pointer, OpTypePointer can "
"only be used once for a given id."); "only be used once for a given id.");
vtn_fail_if(has_forward_pointer && vtn_fail_if(has_forward_pointer &&
deref_type->base_type != vtn_base_type_struct, pointed_type->base_type != vtn_base_type_struct,
"An OpTypePointer instruction must declare " "An OpTypePointer instruction must declare "
"Pointer Type to be a pointer to an OpTypeStruct."); "Pointer Type to be a pointer to an OpTypeStruct.");
val->type->deref = deref_type; val->type->pointed = pointed_type;
/* Only certain storage classes use ArrayStride. */ /* Only certain storage classes use ArrayStride. */
switch (storage_class) { switch (storage_class) {
@ -2222,7 +2222,7 @@ vtn_null_constant(struct vtn_builder *b, struct vtn_type *type)
case vtn_base_type_pointer: { case vtn_base_type_pointer: {
enum vtn_variable_mode mode = vtn_storage_class_to_mode( enum vtn_variable_mode mode = vtn_storage_class_to_mode(
b, type->storage_class, type->deref, NULL); b, type->storage_class, type->pointed, NULL);
nir_address_format addr_format = vtn_mode_to_address_format(b, mode); nir_address_format addr_format = vtn_mode_to_address_format(b, mode);
const nir_const_value *null_value = nir_address_format_null_value(addr_format); const nir_const_value *null_value = nir_address_format_null_value(addr_format);
@ -5767,7 +5767,7 @@ vtn_handle_ptr(struct vtn_builder *b, SpvOp opcode,
case SpvOpPtrDiff: { case SpvOpPtrDiff: {
/* OpPtrDiff returns the difference in number of elements (not byte offset). */ /* OpPtrDiff returns the difference in number of elements (not byte offset). */
unsigned elem_size, elem_align; unsigned elem_size, elem_align;
glsl_get_natural_size_align_bytes(type1->deref->type, glsl_get_natural_size_align_bytes(type1->pointed->type,
&elem_size, &elem_align); &elem_size, &elem_align);
def = nir_build_addr_isub(&b->nb, def = nir_build_addr_isub(&b->nb,
@ -6792,7 +6792,7 @@ vtn_emit_kernel_entry_point_wrapper(struct vtn_builder *b,
if (is_by_val) { if (is_by_val) {
in_var->data.mode = nir_var_uniform; in_var->data.mode = nir_var_uniform;
in_var->type = param_type->deref->type; in_var->type = param_type->pointed->type;
} else if (param_type->base_type == vtn_base_type_image) { } else if (param_type->base_type == vtn_base_type_image) {
in_var->data.mode = nir_var_image; in_var->data.mode = nir_var_image;
in_var->type = param_type->glsl_image; in_var->type = param_type->glsl_image;
@ -7328,7 +7328,7 @@ vtn_print_value(struct vtn_builder *b, struct vtn_value *val, FILE *f)
fprintf(f, " %s", vtn_base_type_to_string(type->base_type)); fprintf(f, " %s", vtn_base_type_to_string(type->base_type));
switch (type->base_type) { switch (type->base_type) {
case vtn_base_type_pointer: case vtn_base_type_pointer:
fprintf(f, " deref=%d", vtn_id_for_type(b, type->deref)); fprintf(f, " deref=%d", vtn_id_for_type(b, type->pointed));
fprintf(f, " %s", spirv_storageclass_to_string(val->type->storage_class)); fprintf(f, " %s", spirv_storageclass_to_string(val->type->storage_class));
break; break;
default: default:

2
src/compiler/spirv/vtn_cfg.c
View file

@ -149,7 +149,7 @@ vtn_ssa_value_load_function_param(struct vtn_builder *b,
if (glsl_type_is_vector_or_scalar(value->type)) { if (glsl_type_is_vector_or_scalar(value->type)) {
/* if the parameter is passed by value, we need to create a local copy if it's a pointer */ /* if the parameter is passed by value, we need to create a local copy if it's a pointer */
if (info->by_value && type && type->base_type == vtn_base_type_pointer) { if (info->by_value && type && type->base_type == vtn_base_type_pointer) {
struct vtn_type *pointee_type = type->deref; struct vtn_type *pointee_type = type->pointed;
nir_variable *copy = nir_variable *copy =
nir_local_variable_create(b->nb.impl, pointee_type->type, NULL); nir_local_variable_create(b->nb.impl, pointee_type->type, NULL);

16
src/compiler/spirv/vtn_opencl.c
View file

@ -70,8 +70,8 @@ vtn_opencl_mangle(const char *in_name,
if (address_space > 0) if (address_space > 0)
args_str += sprintf(args_str, "U3AS%d", address_space); args_str += sprintf(args_str, "U3AS%d", address_space);
type = src_types[i]->deref->type; type = src_types[i]->pointed->type;
base_type = src_types[i]->deref->base_type; base_type = src_types[i]->pointed->base_type;
} }
if (const_mask & (1 << i)) if (const_mask & (1 << i))
@ -86,7 +86,7 @@ vtn_opencl_mangle(const char *in_name,
bool substitution = false; bool substitution = false;
for (unsigned j = 0; j < i; ++j) { for (unsigned j = 0; j < i; ++j) {
const struct glsl_type *other_type = src_types[j]->base_type == vtn_base_type_pointer ? const struct glsl_type *other_type = src_types[j]->base_type == vtn_base_type_pointer ?
src_types[j]->deref->type : src_types[j]->type; src_types[j]->pointed->type : src_types[j]->type;
if (type == other_type) { if (type == other_type) {
substitution = true; substitution = true;
break; break;
@ -403,7 +403,7 @@ get_pointer_type(struct vtn_builder *b, struct vtn_type *t, SpvStorageClass stor
b, vtn_storage_class_to_mode(b, storage_class, NULL, NULL))); b, vtn_storage_class_to_mode(b, storage_class, NULL, NULL)));
ret->base_type = vtn_base_type_pointer; ret->base_type = vtn_base_type_pointer;
ret->storage_class = storage_class; ret->storage_class = storage_class;
ret->deref = t; ret->pointed = t;
return ret; return ret;
} }
@ -411,7 +411,7 @@ static struct vtn_type *
get_signed_type(struct vtn_builder *b, struct vtn_type *t) get_signed_type(struct vtn_builder *b, struct vtn_type *t)
{ {
if (t->base_type == vtn_base_type_pointer) { if (t->base_type == vtn_base_type_pointer) {
return get_pointer_type(b, get_signed_type(b, t->deref), t->storage_class); return get_pointer_type(b, get_signed_type(b, t->pointed), t->storage_class);
} }
return get_vtn_type_for_glsl_type( return get_vtn_type_for_glsl_type(
b, glsl_vector_type(glsl_signed_base_type_of(glsl_get_base_type(t->type)), b, glsl_vector_type(glsl_signed_base_type_of(glsl_get_base_type(t->type)),
@ -596,11 +596,11 @@ handle_core(struct vtn_builder *b, uint32_t opcode,
*/ */
for (unsigned i = 0; i < num_srcs; ++i) { for (unsigned i = 0; i < num_srcs; ++i) {
if (src_types[i]->base_type == vtn_base_type_pointer && if (src_types[i]->base_type == vtn_base_type_pointer &&
src_types[i]->deref->base_type == vtn_base_type_vector && src_types[i]->pointed->base_type == vtn_base_type_vector &&
src_types[i]->deref->length == 3) { src_types[i]->pointed->length == 3) {
src_types[i] = src_types[i] =
get_pointer_type(b, get_pointer_type(b,
get_vtn_type_for_glsl_type(b, glsl_replace_vector_type(src_types[i]->deref->type, 4)), get_vtn_type_for_glsl_type(b, glsl_replace_vector_type(src_types[i]->pointed->type, 4)),
src_types[i]->storage_class); src_types[i]->storage_class);
} }
} }

4
src/compiler/spirv/vtn_private.h
View file

@ -364,8 +364,8 @@ struct vtn_type {
/* Members for pointer types */ /* Members for pointer types */
struct { struct {
/* For pointers, the vtn_type for dereferenced type */ /* For pointers, the vtn_type of the object pointed to. */
struct vtn_type *deref; struct vtn_type *pointed;
/* Storage class for pointers */ /* Storage class for pointers */
SpvStorageClass storage_class; SpvStorageClass storage_class;

24
src/compiler/spirv/vtn_variables.c
View file

@ -1956,16 +1956,16 @@ vtn_pointer_from_ssa(struct vtn_builder *b, nir_def *ssa,
struct vtn_pointer *ptr = vtn_zalloc(b, struct vtn_pointer); struct vtn_pointer *ptr = vtn_zalloc(b, struct vtn_pointer);
struct vtn_type *without_array = struct vtn_type *without_array =
vtn_type_without_array(ptr_type->deref); vtn_type_without_array(ptr_type->pointed);
nir_variable_mode nir_mode; nir_variable_mode nir_mode;
ptr->mode = vtn_storage_class_to_mode(b, ptr_type->storage_class, ptr->mode = vtn_storage_class_to_mode(b, ptr_type->storage_class,
without_array, &nir_mode); without_array, &nir_mode);
ptr->type = ptr_type->deref; ptr->type = ptr_type->pointed;
ptr->ptr_type = ptr_type; ptr->ptr_type = ptr_type;
const struct glsl_type *deref_type = const struct glsl_type *deref_type =
vtn_type_get_nir_type(b, ptr_type->deref, ptr->mode); vtn_type_get_nir_type(b, ptr_type->pointed, ptr->mode);
if (!vtn_pointer_is_external_block(b, ptr) && if (!vtn_pointer_is_external_block(b, ptr) &&
ptr->mode != vtn_variable_mode_accel_struct) { ptr->mode != vtn_variable_mode_accel_struct) {
ptr->deref = nir_build_deref_cast(&b->nb, ssa, nir_mode, ptr->deref = nir_build_deref_cast(&b->nb, ssa, nir_mode,
@ -2088,9 +2088,9 @@ vtn_create_variable(struct vtn_builder *b, struct vtn_value *val,
struct vtn_value *initializer) struct vtn_value *initializer)
{ {
vtn_assert(ptr_type->base_type == vtn_base_type_pointer); vtn_assert(ptr_type->base_type == vtn_base_type_pointer);
struct vtn_type *type = ptr_type->deref; struct vtn_type *type = ptr_type->pointed;
struct vtn_type *without_array = vtn_type_without_array(ptr_type->deref); struct vtn_type *without_array = vtn_type_without_array(ptr_type->pointed);
enum vtn_variable_mode mode; enum vtn_variable_mode mode;
nir_variable_mode nir_mode; nir_variable_mode nir_mode;
@ -2669,7 +2669,7 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
struct vtn_type *ptr_type = vtn_zalloc(b, struct vtn_type); struct vtn_type *ptr_type = vtn_zalloc(b, struct vtn_type);
ptr_type->base_type = vtn_base_type_pointer; ptr_type->base_type = vtn_base_type_pointer;
ptr_type->deref = sampler_type; ptr_type->pointed = sampler_type;
ptr_type->storage_class = SpvStorageClassUniform; ptr_type->storage_class = SpvStorageClassUniform;
ptr_type->type = nir_address_format_to_glsl_type( ptr_type->type = nir_address_format_to_glsl_type(
@ -2736,8 +2736,8 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
struct vtn_pointer *dest = vtn_value_to_pointer(b, dest_val); struct vtn_pointer *dest = vtn_value_to_pointer(b, dest_val);
struct vtn_pointer *src = vtn_value_to_pointer(b, src_val); struct vtn_pointer *src = vtn_value_to_pointer(b, src_val);
vtn_assert_types_equal(b, opcode, dest_val->type->deref, vtn_assert_types_equal(b, opcode, dest_val->type->pointed,
src_val->type->deref); src_val->type->pointed);
unsigned idx = 3, dest_alignment, src_alignment; unsigned idx = 3, dest_alignment, src_alignment;
SpvMemoryAccessMask dest_access, src_access; SpvMemoryAccessMask dest_access, src_access;
@ -2800,7 +2800,7 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
struct vtn_value *src_val = vtn_value(b, w[3], vtn_value_type_pointer); struct vtn_value *src_val = vtn_value(b, w[3], vtn_value_type_pointer);
struct vtn_pointer *src = vtn_value_to_pointer(b, src_val); struct vtn_pointer *src = vtn_value_to_pointer(b, src_val);
vtn_assert_types_equal(b, opcode, res_type, src_val->type->deref); vtn_assert_types_equal(b, opcode, res_type, src_val->type->pointed);
unsigned idx = 4, alignment; unsigned idx = 4, alignment;
SpvMemoryAccessMask access; SpvMemoryAccessMask access;
@ -2842,7 +2842,7 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
break; break;
} }
vtn_assert_types_equal(b, opcode, dest_val->type->deref, src_val->type); vtn_assert_types_equal(b, opcode, dest_val->type->pointed, src_val->type);
unsigned idx = 3, alignment; unsigned idx = 3, alignment;
SpvMemoryAccessMask access; SpvMemoryAccessMask access;
@ -2936,7 +2936,7 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
"storage class specified in the instruction"); "storage class specified in the instruction");
vtn_fail_if(src_type->base_type != vtn_base_type_pointer || vtn_fail_if(src_type->base_type != vtn_base_type_pointer ||
src_type->deref->id != dst_type->deref->id, src_type->pointed->id != dst_type->pointed->id,
"Source pointer of an SpvOpGenericCastToPtrExplicit must " "Source pointer of an SpvOpGenericCastToPtrExplicit must "
"have a type of OpTypePointer whose Type is the same as " "have a type of OpTypePointer whose Type is the same as "
"the Type of Result Type"); "the Type of Result Type");
@ -2955,7 +2955,7 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
nir_variable_mode nir_mode; nir_variable_mode nir_mode;
enum vtn_variable_mode mode = enum vtn_variable_mode mode =
vtn_storage_class_to_mode(b, storage_class, dst_type->deref, &nir_mode); vtn_storage_class_to_mode(b, storage_class, dst_type->pointed, &nir_mode);
nir_address_format addr_format = vtn_mode_to_address_format(b, mode); nir_address_format addr_format = vtn_mode_to_address_format(b, mode);
nir_def *null_value = nir_def *null_value =