summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/compiler/spirv/spirv_to_nir.c17
-rw-r--r--src/compiler/spirv/vtn_cfg.c14
-rw-r--r--src/compiler/spirv/vtn_private.h43
-rw-r--r--src/compiler/spirv/vtn_variables.c272
4 files changed, 187 insertions, 159 deletions
diff --git a/src/compiler/spirv/spirv_to_nir.c b/src/compiler/spirv/spirv_to_nir.c
index 02b42f2f1fe..18e37341ef7 100644
--- a/src/compiler/spirv/spirv_to_nir.c
+++ b/src/compiler/spirv/spirv_to_nir.c
@@ -2069,7 +2069,7 @@ static void
vtn_handle_ssbo_or_shared_atomic(struct vtn_builder *b, SpvOp opcode,
const uint32_t *w, unsigned count)
{
- struct vtn_access_chain *ptr;
+ struct vtn_pointer *ptr;
nir_intrinsic_instr *atomic;
switch (opcode) {
@@ -2104,7 +2104,7 @@ vtn_handle_ssbo_or_shared_atomic(struct vtn_builder *b, SpvOp opcode,
SpvMemorySemanticsMask semantics = w[5];
*/
- if (ptr->var->mode == vtn_variable_mode_workgroup) {
+ if (ptr->mode == vtn_variable_mode_workgroup) {
nir_deref_var *deref = vtn_pointer_to_deref(b, ptr);
const struct glsl_type *deref_type = nir_deref_tail(&deref->deref)->type;
nir_intrinsic_op op = get_shared_nir_atomic_op(opcode);
@@ -2144,9 +2144,9 @@ vtn_handle_ssbo_or_shared_atomic(struct vtn_builder *b, SpvOp opcode,
}
} else {
- assert(ptr->var->mode == vtn_variable_mode_ssbo);
- struct vtn_type *type;
+ assert(ptr->mode == vtn_variable_mode_ssbo);
nir_ssa_def *offset, *index;
+ struct vtn_type *type;
offset = vtn_pointer_to_offset(b, ptr, &index, &type, NULL, false);
nir_intrinsic_op op = get_ssbo_nir_atomic_op(opcode);
@@ -2155,13 +2155,13 @@ vtn_handle_ssbo_or_shared_atomic(struct vtn_builder *b, SpvOp opcode,
switch (opcode) {
case SpvOpAtomicLoad:
- atomic->num_components = glsl_get_vector_elements(type->type);
+ atomic->num_components = glsl_get_vector_elements(ptr->type->type);
atomic->src[0] = nir_src_for_ssa(index);
atomic->src[1] = nir_src_for_ssa(offset);
break;
case SpvOpAtomicStore:
- atomic->num_components = glsl_get_vector_elements(type->type);
+ atomic->num_components = glsl_get_vector_elements(ptr->type->type);
nir_intrinsic_set_write_mask(atomic, (1 << atomic->num_components) - 1);
atomic->src[0] = nir_src_for_ssa(vtn_ssa_value(b, w[4])->def);
atomic->src[1] = nir_src_for_ssa(index);
@@ -3063,11 +3063,12 @@ vtn_handle_body_instruction(struct vtn_builder *b, SpvOp opcode,
break;
case SpvOpImageQuerySize: {
- struct vtn_access_chain *image =
+ struct vtn_pointer *image =
vtn_value(b, w[3], vtn_value_type_pointer)->pointer;
- if (glsl_type_is_image(image->var->var->interface_type)) {
+ if (image->mode == vtn_variable_mode_image) {
vtn_handle_image(b, opcode, w, count);
} else {
+ assert(image->mode == vtn_variable_mode_sampler);
vtn_handle_texture(b, opcode, w, count);
}
break;
diff --git a/src/compiler/spirv/vtn_cfg.c b/src/compiler/spirv/vtn_cfg.c
index 123a8c68201..b03db904cc8 100644
--- a/src/compiler/spirv/vtn_cfg.c
+++ b/src/compiler/spirv/vtn_cfg.c
@@ -84,8 +84,6 @@ vtn_cfg_handle_prepass_instruction(struct vtn_builder *b, SpvOp opcode,
break;
case SpvOpFunctionParameter: {
- struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_pointer);
-
struct vtn_type *type = vtn_value(b, w[1], vtn_value_type_type)->type;
assert(b->func_param_idx < b->func->impl->num_params);
@@ -93,14 +91,9 @@ vtn_cfg_handle_prepass_instruction(struct vtn_builder *b, SpvOp opcode,
assert(param->type == type->type);
- /* Name the parameter so it shows up nicely in NIR */
- param->name = ralloc_strdup(param, val->name);
-
struct vtn_variable *vtn_var = rzalloc(b, struct vtn_variable);
vtn_var->type = type;
vtn_var->var = param;
- vtn_var->ptr.var = vtn_var;
- vtn_var->ptr.length = 0;
struct vtn_type *without_array = type;
while(glsl_type_is_array(without_array->type))
@@ -116,7 +109,12 @@ vtn_cfg_handle_prepass_instruction(struct vtn_builder *b, SpvOp opcode,
vtn_var->mode = vtn_variable_mode_param;
}
- val->pointer = &vtn_var->ptr;
+ struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_pointer);
+
+ /* Name the parameter so it shows up nicely in NIR */
+ param->name = ralloc_strdup(param, val->name);
+
+ val->pointer = vtn_pointer_for_variable(b, vtn_var);
break;
}
diff --git a/src/compiler/spirv/vtn_private.h b/src/compiler/spirv/vtn_private.h
index a7f86ae104c..b025eea49e3 100644
--- a/src/compiler/spirv/vtn_private.h
+++ b/src/compiler/spirv/vtn_private.h
@@ -253,8 +253,6 @@ struct vtn_access_link {
};
struct vtn_access_chain {
- struct vtn_variable *var;
-
uint32_t length;
/* Struct elements and array offsets */
@@ -275,6 +273,23 @@ enum vtn_variable_mode {
vtn_variable_mode_output,
};
+struct vtn_pointer {
+ /** The variable mode for the referenced data */
+ enum vtn_variable_mode mode;
+
+ /** The dereferenced type of this pointer */
+ struct vtn_type *type;
+
+ /** The referenced variable */
+ struct vtn_variable *var;
+
+ /** An access chain describing how to get from var to the referenced data
+ *
+ * This field may be NULL if the pointer references the entire variable.
+ */
+ struct vtn_access_chain *chain;
+};
+
struct vtn_variable {
enum vtn_variable_mode mode;
@@ -300,20 +315,18 @@ struct vtn_variable {
* around this GLSLang issue in SPIR-V -> NIR. Hopefully, we can drop this
* hack at some point in the future.
*/
- struct vtn_access_chain *copy_prop_sampler;
-
- struct vtn_access_chain ptr;
+ struct vtn_pointer *copy_prop_sampler;
};
struct vtn_image_pointer {
- struct vtn_access_chain *image;
+ struct vtn_pointer *image;
nir_ssa_def *coord;
nir_ssa_def *sample;
};
struct vtn_sampled_image {
- struct vtn_access_chain *image; /* Image or array of images */
- struct vtn_access_chain *sampler; /* Sampler */
+ struct vtn_pointer *image; /* Image or array of images */
+ struct vtn_pointer *sampler; /* Sampler */
};
struct vtn_value {
@@ -328,7 +341,7 @@ struct vtn_value {
nir_constant *constant;
const struct glsl_type *const_type;
};
- struct vtn_access_chain *pointer;
+ struct vtn_pointer *pointer;
struct vtn_image_pointer *image;
struct vtn_sampled_image *sampled_image;
struct vtn_function *func;
@@ -459,11 +472,13 @@ nir_ssa_def *vtn_vector_insert_dynamic(struct vtn_builder *b, nir_ssa_def *src,
nir_deref_var *vtn_nir_deref(struct vtn_builder *b, uint32_t id);
+struct vtn_pointer *vtn_pointer_for_variable(struct vtn_builder *b,
+ struct vtn_variable *var);
+
nir_deref_var *vtn_pointer_to_deref(struct vtn_builder *b,
- struct vtn_access_chain *ptr);
+ struct vtn_pointer *ptr);
nir_ssa_def *
-vtn_pointer_to_offset(struct vtn_builder *b,
- struct vtn_access_chain *ptr,
+vtn_pointer_to_offset(struct vtn_builder *b, struct vtn_pointer *ptr,
nir_ssa_def **index_out, struct vtn_type **type_out,
unsigned *end_idx_out, bool stop_at_matrix);
@@ -473,10 +488,10 @@ void vtn_local_store(struct vtn_builder *b, struct vtn_ssa_value *src,
nir_deref_var *dest);
struct vtn_ssa_value *
-vtn_variable_load(struct vtn_builder *b, struct vtn_access_chain *src);
+vtn_variable_load(struct vtn_builder *b, struct vtn_pointer *src);
void vtn_variable_store(struct vtn_builder *b, struct vtn_ssa_value *src,
- struct vtn_access_chain *dest);
+ struct vtn_pointer *dest);
void vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
const uint32_t *w, unsigned count);
diff --git a/src/compiler/spirv/vtn_variables.c b/src/compiler/spirv/vtn_variables.c
index 5e4e772b2f7..e9020e7e0dc 100644
--- a/src/compiler/spirv/vtn_variables.c
+++ b/src/compiler/spirv/vtn_variables.c
@@ -34,14 +34,14 @@ vtn_access_chain_extend(struct vtn_builder *b, struct vtn_access_chain *old,
{
struct vtn_access_chain *chain;
- unsigned new_len = old->length + new_ids;
+ unsigned old_len = old ? old->length : 0;
+ unsigned new_len = old_len + new_ids;
/* TODO: don't use rzalloc */
chain = rzalloc_size(b, sizeof(*chain) + new_len * sizeof(chain->link[0]));
- chain->var = old->var;
chain->length = new_len;
- for (unsigned i = 0; i < old->length; i++)
+ for (unsigned i = 0; i < old_len; i++)
chain->link[i] = old->link[i];
return chain;
@@ -62,22 +62,6 @@ vtn_access_link_as_ssa(struct vtn_builder *b, struct vtn_access_link link,
}
}
-static struct vtn_type *
-vtn_access_chain_tail_type(struct vtn_builder *b,
- struct vtn_access_chain *chain)
-{
- struct vtn_type *type = chain->var->type;
- for (unsigned i = 0; i < chain->length; i++) {
- if (glsl_type_is_struct(type->type)) {
- assert(chain->link[i].mode == vtn_access_mode_literal);
- type = type->members[chain->link[i].id];
- } else {
- type = type->array_element;
- }
- }
- return type;
-}
-
/* Crawls a chain of array derefs and rewrites the types so that the
* lengths stay the same but the terminal type is the one given by
* tail_type. This is useful for split structures.
@@ -93,26 +77,45 @@ rewrite_deref_types(nir_deref *deref, const struct glsl_type *type)
}
}
+struct vtn_pointer *
+vtn_pointer_for_variable(struct vtn_builder *b,
+ struct vtn_variable *var)
+{
+ struct vtn_pointer *pointer = rzalloc(b, struct vtn_pointer);
+
+ pointer->mode = var->mode;
+ pointer->type = var->type;
+ pointer->var = var;
+
+ return pointer;
+}
+
nir_deref_var *
-vtn_pointer_to_deref(struct vtn_builder *b, struct vtn_access_chain *chain)
+vtn_pointer_to_deref(struct vtn_builder *b, struct vtn_pointer *ptr)
{
/* Do on-the-fly copy propagation for samplers. */
- if (chain->var->copy_prop_sampler)
- return vtn_pointer_to_deref(b, chain->var->copy_prop_sampler);
+ if (ptr->var->copy_prop_sampler)
+ return vtn_pointer_to_deref(b, ptr->var->copy_prop_sampler);
nir_deref_var *deref_var;
- if (chain->var->var) {
- deref_var = nir_deref_var_create(b, chain->var->var);
+ if (ptr->var->var) {
+ deref_var = nir_deref_var_create(b, ptr->var->var);
+ /* Raw variable access */
+ if (!ptr->chain)
+ return deref_var;
} else {
- assert(chain->var->members);
+ assert(ptr->var->members);
/* Create the deref_var manually. It will get filled out later. */
deref_var = rzalloc(b, nir_deref_var);
deref_var->deref.deref_type = nir_deref_type_var;
}
- struct vtn_type *deref_type = chain->var->type;
+ struct vtn_access_chain *chain = ptr->chain;
+ assert(chain);
+
+ struct vtn_type *deref_type = ptr->var->type;
nir_deref *tail = &deref_var->deref;
- nir_variable **members = chain->var->members;
+ nir_variable **members = ptr->var->members;
for (unsigned i = 0; i < chain->length; i++) {
enum glsl_base_type base_type = glsl_get_base_type(deref_type->type);
@@ -236,10 +239,8 @@ _vtn_local_load_store(struct vtn_builder *b, bool load, nir_deref_var *deref,
nir_deref_var *
vtn_nir_deref(struct vtn_builder *b, uint32_t id)
{
- struct vtn_access_chain *chain =
- vtn_value(b, id, vtn_value_type_pointer)->pointer;
-
- return vtn_pointer_to_deref(b, chain);
+ struct vtn_pointer *ptr = vtn_value(b, id, vtn_value_type_pointer)->pointer;
+ return vtn_pointer_to_deref(b, ptr);
}
/*
@@ -302,34 +303,34 @@ vtn_local_store(struct vtn_builder *b, struct vtn_ssa_value *src,
}
static nir_ssa_def *
-get_vulkan_resource_index(struct vtn_builder *b, struct vtn_access_chain *chain,
+get_vulkan_resource_index(struct vtn_builder *b, struct vtn_pointer *ptr,
struct vtn_type **type, unsigned *chain_idx)
{
/* Push constants have no explicit binding */
- if (chain->var->mode == vtn_variable_mode_push_constant) {
+ if (ptr->mode == vtn_variable_mode_push_constant) {
*chain_idx = 0;
- *type = chain->var->type;
+ *type = ptr->var->type;
return NULL;
}
nir_ssa_def *array_index;
- if (glsl_type_is_array(chain->var->type->type)) {
- assert(chain->length > 0);
- array_index = vtn_access_link_as_ssa(b, chain->link[0], 1);
+ if (glsl_type_is_array(ptr->var->type->type)) {
+ assert(ptr->chain->length > 0);
+ array_index = vtn_access_link_as_ssa(b, ptr->chain->link[0], 1);
*chain_idx = 1;
- *type = chain->var->type->array_element;
+ *type = ptr->var->type->array_element;
} else {
array_index = nir_imm_int(&b->nb, 0);
*chain_idx = 0;
- *type = chain->var->type;
+ *type = ptr->var->type;
}
nir_intrinsic_instr *instr =
nir_intrinsic_instr_create(b->nb.shader,
nir_intrinsic_vulkan_resource_index);
instr->src[0] = nir_src_for_ssa(array_index);
- nir_intrinsic_set_desc_set(instr, chain->var->descriptor_set);
- nir_intrinsic_set_binding(instr, chain->var->binding);
+ nir_intrinsic_set_desc_set(instr, ptr->var->descriptor_set);
+ nir_intrinsic_set_binding(instr, ptr->var->binding);
nir_ssa_dest_init(&instr->instr, &instr->dest, 1, 32, NULL);
nir_builder_instr_insert(&b->nb, &instr->instr);
@@ -338,17 +339,16 @@ get_vulkan_resource_index(struct vtn_builder *b, struct vtn_access_chain *chain,
}
nir_ssa_def *
-vtn_pointer_to_offset(struct vtn_builder *b,
- struct vtn_access_chain *chain,
+vtn_pointer_to_offset(struct vtn_builder *b, struct vtn_pointer *ptr,
nir_ssa_def **index_out, struct vtn_type **type_out,
unsigned *end_idx_out, bool stop_at_matrix)
{
unsigned idx = 0;
struct vtn_type *type;
- *index_out = get_vulkan_resource_index(b, chain, &type, &idx);
+ *index_out = get_vulkan_resource_index(b, ptr, &type, &idx);
nir_ssa_def *offset = nir_imm_int(&b->nb, 0);
- for (; idx < chain->length; idx++) {
+ for (; idx < ptr->chain->length; idx++) {
enum glsl_base_type base_type = glsl_get_base_type(type->type);
switch (base_type) {
case GLSL_TYPE_UINT:
@@ -365,15 +365,15 @@ vtn_pointer_to_offset(struct vtn_builder *b,
case GLSL_TYPE_ARRAY:
offset = nir_iadd(&b->nb, offset,
- vtn_access_link_as_ssa(b, chain->link[idx],
+ vtn_access_link_as_ssa(b, ptr->chain->link[idx],
type->stride));
type = type->array_element;
break;
case GLSL_TYPE_STRUCT: {
- assert(chain->link[idx].mode == vtn_access_mode_literal);
- unsigned member = chain->link[idx].id;
+ assert(ptr->chain->link[idx].mode == vtn_access_mode_literal);
+ unsigned member = ptr->chain->link[idx].id;
offset = nir_iadd(&b->nb, offset,
nir_imm_int(&b->nb, type->offsets[member]));
type = type->members[member];
@@ -447,14 +447,10 @@ vtn_type_block_size(struct vtn_type *type)
static void
vtn_access_chain_get_offset_size(struct vtn_access_chain *chain,
+ struct vtn_type *type,
unsigned *access_offset,
unsigned *access_size)
{
- /* Only valid for push constants accesses now. */
- assert(chain->var->mode == vtn_variable_mode_push_constant);
-
- struct vtn_type *type = chain->var->type;
-
*access_offset = 0;
for (unsigned i = 0; i < chain->length; i++) {
@@ -690,11 +686,11 @@ _vtn_block_load_store(struct vtn_builder *b, nir_intrinsic_op op, bool load,
}
static struct vtn_ssa_value *
-vtn_block_load(struct vtn_builder *b, struct vtn_access_chain *src)
+vtn_block_load(struct vtn_builder *b, struct vtn_pointer *src)
{
nir_intrinsic_op op;
unsigned access_offset = 0, access_size = 0;
- switch (src->var->mode) {
+ switch (src->mode) {
case vtn_variable_mode_ubo:
op = nir_intrinsic_load_ubo;
break;
@@ -703,35 +699,36 @@ vtn_block_load(struct vtn_builder *b, struct vtn_access_chain *src)
break;
case vtn_variable_mode_push_constant:
op = nir_intrinsic_load_push_constant;
- vtn_access_chain_get_offset_size(src, &access_offset, &access_size);
+ vtn_access_chain_get_offset_size(src->chain, src->var->type,
+ &access_offset, &access_size);
break;
default:
assert(!"Invalid block variable mode");
}
nir_ssa_def *offset, *index = NULL;
- struct vtn_type *type;
unsigned chain_idx;
+ struct vtn_type *type;
offset = vtn_pointer_to_offset(b, src, &index, &type, &chain_idx, true);
struct vtn_ssa_value *value = NULL;
_vtn_block_load_store(b, op, true, index, offset,
access_offset, access_size,
- src, chain_idx, type, &value);
+ src->chain, chain_idx, type, &value);
return value;
}
static void
vtn_block_store(struct vtn_builder *b, struct vtn_ssa_value *src,
- struct vtn_access_chain *dst)
+ struct vtn_pointer *dst)
{
nir_ssa_def *offset, *index = NULL;
- struct vtn_type *type;
unsigned chain_idx;
+ struct vtn_type *type;
offset = vtn_pointer_to_offset(b, dst, &index, &type, &chain_idx, true);
_vtn_block_load_store(b, nir_intrinsic_store_ssbo, false, index, offset,
- 0, 0, dst, chain_idx, type, &src);
+ 0, 0, dst->chain, chain_idx, type, &src);
}
static bool
@@ -744,11 +741,10 @@ vtn_variable_is_external_block(struct vtn_variable *var)
static void
_vtn_variable_load_store(struct vtn_builder *b, bool load,
- struct vtn_access_chain *chain,
- struct vtn_type *tail_type,
+ struct vtn_pointer *ptr,
struct vtn_ssa_value **inout)
{
- enum glsl_base_type base_type = glsl_get_base_type(tail_type->type);
+ enum glsl_base_type base_type = glsl_get_base_type(ptr->type->type);
switch (base_type) {
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
@@ -764,30 +760,31 @@ _vtn_variable_load_store(struct vtn_builder *b, bool load,
* are storred row-major in a UBO.
*/
if (load) {
- *inout = vtn_local_load(b, vtn_pointer_to_deref(b, chain));
+ *inout = vtn_local_load(b, vtn_pointer_to_deref(b, ptr));
} else {
- vtn_local_store(b, *inout, vtn_pointer_to_deref(b, chain));
+ vtn_local_store(b, *inout, vtn_pointer_to_deref(b, ptr));
}
return;
case GLSL_TYPE_ARRAY:
case GLSL_TYPE_STRUCT: {
- struct vtn_access_chain *new_chain =
- vtn_access_chain_extend(b, chain, 1);
- new_chain->link[chain->length].mode = vtn_access_mode_literal;
- unsigned elems = glsl_get_length(tail_type->type);
+ unsigned elems = glsl_get_length(ptr->type->type);
if (load) {
assert(*inout == NULL);
*inout = rzalloc(b, struct vtn_ssa_value);
- (*inout)->type = tail_type->type;
+ (*inout)->type = ptr->type->type;
(*inout)->elems = rzalloc_array(b, struct vtn_ssa_value *, elems);
}
+
+ struct vtn_pointer elem = *ptr;
+ elem.chain = vtn_access_chain_extend(b, ptr->chain, 1);
+ unsigned link_idx = ptr->chain ? ptr->chain->length : 0;
+ elem.chain->link[link_idx].mode = vtn_access_mode_literal;
for (unsigned i = 0; i < elems; i++) {
- new_chain->link[chain->length].id = i;
- struct vtn_type *elem_type = base_type == GLSL_TYPE_ARRAY ?
- tail_type->array_element : tail_type->members[i];
- _vtn_variable_load_store(b, load, new_chain, elem_type,
- &(*inout)->elems[i]);
+ elem.chain->link[link_idx].id = i;
+ elem.type = (base_type == GLSL_TYPE_ARRAY) ? ptr->type->array_element :
+ ptr->type->members[i];
+ _vtn_variable_load_store(b, load, &elem, &(*inout)->elems[i]);
}
return;
}
@@ -798,36 +795,35 @@ _vtn_variable_load_store(struct vtn_builder *b, bool load,
}
struct vtn_ssa_value *
-vtn_variable_load(struct vtn_builder *b, struct vtn_access_chain *src)
+vtn_variable_load(struct vtn_builder *b, struct vtn_pointer *src)
{
if (vtn_variable_is_external_block(src->var)) {
return vtn_block_load(b, src);
} else {
- struct vtn_type *tail_type = vtn_access_chain_tail_type(b, src);
struct vtn_ssa_value *val = NULL;
- _vtn_variable_load_store(b, true, src, tail_type, &val);
+ _vtn_variable_load_store(b, true, src, &val);
return val;
}
}
void
vtn_variable_store(struct vtn_builder *b, struct vtn_ssa_value *src,
- struct vtn_access_chain *dest)
+ struct vtn_pointer *dest)
{
if (vtn_variable_is_external_block(dest->var)) {
assert(dest->var->mode == vtn_variable_mode_ssbo);
vtn_block_store(b, src, dest);
} else {
- struct vtn_type *tail_type = vtn_access_chain_tail_type(b, dest);
- _vtn_variable_load_store(b, false, dest, tail_type, &src);
+ _vtn_variable_load_store(b, false, dest, &src);
}
}
static void
-_vtn_variable_copy(struct vtn_builder *b, struct vtn_access_chain *dest,
- struct vtn_access_chain *src, struct vtn_type *tail_type)
+_vtn_variable_copy(struct vtn_builder *b, struct vtn_pointer *dest,
+ struct vtn_pointer *src)
{
- enum glsl_base_type base_type = glsl_get_base_type(tail_type->type);
+ assert(src->type->type == dest->type->type);
+ enum glsl_base_type base_type = glsl_get_base_type(src->type->type);
switch (base_type) {
case GLSL_TYPE_UINT:
case GLSL_TYPE_INT:
@@ -847,18 +843,24 @@ _vtn_variable_copy(struct vtn_builder *b, struct vtn_access_chain *dest,
case GLSL_TYPE_ARRAY:
case GLSL_TYPE_STRUCT: {
- struct vtn_access_chain *new_src, *new_dest;
- new_src = vtn_access_chain_extend(b, src, 1);
- new_dest = vtn_access_chain_extend(b, dest, 1);
- new_src->link[src->length].mode = vtn_access_mode_literal;
- new_dest->link[dest->length].mode = vtn_access_mode_literal;
- unsigned elems = glsl_get_length(tail_type->type);
+ struct vtn_pointer src_elem = *src, dest_elem = *dest;
+ src_elem.chain = vtn_access_chain_extend(b, src->chain, 1);
+ dest_elem.chain = vtn_access_chain_extend(b, dest->chain, 1);
+ src_elem.chain->link[src_elem.chain->length - 1].mode = vtn_access_mode_literal;
+ dest_elem.chain->link[dest_elem.chain->length - 1].mode = vtn_access_mode_literal;
+
+ unsigned elems = glsl_get_length(src->type->type);
for (unsigned i = 0; i < elems; i++) {
- new_src->link[src->length].id = i;
- new_dest->link[dest->length].id = i;
- struct vtn_type *elem_type = base_type == GLSL_TYPE_ARRAY ?
- tail_type->array_element : tail_type->members[i];
- _vtn_variable_copy(b, new_dest, new_src, elem_type);
+ src_elem.chain->link[src_elem.chain->length - 1].id = i;
+ dest_elem.chain->link[dest_elem.chain->length - 1].id = i;
+ if (base_type == GLSL_TYPE_STRUCT) {
+ src_elem.type = src->type->members[i];
+ dest_elem.type = dest->type->members[i];
+ } else {
+ src_elem.type = src->type->array_element;
+ dest_elem.type = dest->type->array_element;
+ }
+ _vtn_variable_copy(b, &dest_elem, &src_elem);
}
return;
}
@@ -869,16 +871,13 @@ _vtn_variable_copy(struct vtn_builder *b, struct vtn_access_chain *dest,
}
static void
-vtn_variable_copy(struct vtn_builder *b, struct vtn_access_chain *dest,
- struct vtn_access_chain *src)
+vtn_variable_copy(struct vtn_builder *b, struct vtn_pointer *dest,
+ struct vtn_pointer *src)
{
- struct vtn_type *tail_type = vtn_access_chain_tail_type(b, src);
- assert(vtn_access_chain_tail_type(b, dest)->type == tail_type->type);
-
/* TODO: At some point, we should add a special-case for when we can
* just emit a copy_var intrinsic.
*/
- _vtn_variable_copy(b, dest, src, tail_type);
+ _vtn_variable_copy(b, dest, src);
}
static void
@@ -1216,8 +1215,8 @@ var_decoration_cb(struct vtn_builder *b, struct vtn_value *val, int member,
}
if (val->value_type == vtn_value_type_pointer) {
- assert(val->pointer->length == 0);
assert(val->pointer->var == void_var);
+ assert(val->pointer->chain == NULL);
assert(member == -1);
} else {
assert(val->value_type == vtn_value_type_type);
@@ -1386,23 +1385,17 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
}
case SpvOpVariable: {
- struct vtn_variable *var = rzalloc(b, struct vtn_variable);
- var->type = vtn_value(b, w[1], vtn_value_type_type)->type;
-
- var->ptr.var = var;
- var->ptr.length = 0;
-
- struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_pointer);
- val->pointer = &var->ptr;
+ struct vtn_type *type = vtn_value(b, w[1], vtn_value_type_type)->type;
- struct vtn_type *without_array = var->type;
+ struct vtn_type *without_array = type;
while(glsl_type_is_array(without_array->type))
without_array = without_array->array_element;
+ enum vtn_variable_mode mode;
nir_variable_mode nir_mode;
- var->mode = vtn_storage_class_to_mode(w[3], without_array, &nir_mode);
+ mode = vtn_storage_class_to_mode(w[3], without_array, &nir_mode);
- switch (var->mode) {
+ switch (mode) {
case vtn_variable_mode_ubo:
b->shader->info.num_ubos++;
break;
@@ -1416,13 +1409,20 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
b->shader->info.num_textures++;
break;
case vtn_variable_mode_push_constant:
- b->shader->num_uniforms = vtn_type_block_size(var->type);
+ b->shader->num_uniforms = vtn_type_block_size(type);
break;
default:
/* No tallying is needed */
break;
}
+ struct vtn_variable *var = rzalloc(b, struct vtn_variable);
+ var->type = type;
+ var->mode = mode;
+
+ struct vtn_value *val = vtn_push_value(b, w[2], vtn_value_type_pointer);
+ val->pointer = vtn_pointer_for_variable(b, var);
+
switch (var->mode) {
case vtn_variable_mode_local:
case vtn_variable_mode_global:
@@ -1582,7 +1582,7 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
case SpvOpAccessChain:
case SpvOpInBoundsAccessChain: {
- struct vtn_access_chain *base, *chain;
+ struct vtn_pointer *base, *ptr;
struct vtn_value *base_val = vtn_untyped_value(b, w[3]);
if (base_val->value_type == vtn_value_type_sampled_image) {
/* This is rather insane. SPIR-V allows you to use OpSampledImage
@@ -1598,9 +1598,11 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
base = base_val->pointer;
}
- chain = vtn_access_chain_extend(b, base, count - 4);
+ struct vtn_access_chain *chain =
+ vtn_access_chain_extend(b, base->chain, count - 4);
+ struct vtn_type *type = base->type;
- unsigned idx = base->length;
+ unsigned idx = base->chain ? base->chain->length : 0;
for (int i = 4; i < count; i++) {
struct vtn_value *link_val = vtn_untyped_value(b, w[i]);
if (link_val->value_type == vtn_value_type_constant) {
@@ -1610,19 +1612,31 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
chain->link[idx].mode = vtn_access_mode_id;
chain->link[idx].id = w[i];
}
+
+ if (glsl_type_is_struct(type->type)) {
+ assert(chain->link[idx].mode == vtn_access_mode_literal);
+ type = type->members[chain->link[idx].id];
+ } else {
+ type = type->array_element;
+ }
idx++;
}
+ ptr = ralloc(b, struct vtn_pointer);
+ *ptr = *base;
+ ptr->chain = chain;
+ ptr->type = type;
+
if (base_val->value_type == vtn_value_type_sampled_image) {
struct vtn_value *val =
vtn_push_value(b, w[2], vtn_value_type_sampled_image);
val->sampled_image = ralloc(b, struct vtn_sampled_image);
- val->sampled_image->image = chain;
+ val->sampled_image->image = ptr;
val->sampled_image->sampler = base_val->sampled_image->sampler;
} else {
struct vtn_value *val =
vtn_push_value(b, w[2], vtn_value_type_pointer);
- val->pointer = chain;
+ val->pointer = ptr;
}
break;
}
@@ -1636,11 +1650,11 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
}
case SpvOpLoad: {
- struct vtn_access_chain *src =
+ struct vtn_pointer *src =
vtn_value(b, w[3], vtn_value_type_pointer)->pointer;
- if (src->var->mode == vtn_variable_mode_image ||
- src->var->mode == vtn_variable_mode_sampler) {
+ if (src->mode == vtn_variable_mode_image ||
+ src->mode == vtn_variable_mode_sampler) {
vtn_push_value(b, w[2], vtn_value_type_pointer)->pointer = src;
return;
}
@@ -1651,10 +1665,10 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
}
case SpvOpStore: {
- struct vtn_access_chain *dest =
+ struct vtn_pointer *dest =
vtn_value(b, w[1], vtn_value_type_pointer)->pointer;
- if (glsl_type_is_sampler(dest->var->type->type)) {
+ if (glsl_type_is_sampler(dest->type->type)) {
vtn_warn("OpStore of a sampler detected. Doing on-the-fly copy "
"propagation to workaround the problem.");
assert(dest->var->copy_prop_sampler == NULL);
@@ -1669,16 +1683,16 @@ vtn_handle_variables(struct vtn_builder *b, SpvOp opcode,
}
case SpvOpArrayLength: {
- struct vtn_access_chain *chain =
+ struct vtn_pointer *ptr =
vtn_value(b, w[3], vtn_value_type_pointer)->pointer;
- const uint32_t offset = chain->var->type->offsets[w[4]];
- const uint32_t stride = chain->var->type->members[w[4]]->stride;
+ const uint32_t offset = ptr->var->type->offsets[w[4]];
+ const uint32_t stride = ptr->var->type->members[w[4]]->stride;
unsigned chain_idx;
struct vtn_type *type;
nir_ssa_def *index =
- get_vulkan_resource_index(b, chain, &type, &chain_idx);
+ get_vulkan_resource_index(b, ptr, &type, &chain_idx);
nir_intrinsic_instr *instr =
nir_intrinsic_instr_create(b->nb.shader,
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-19 13:01:47 +0000