From: Jason Ekstrand Date: Fri, 23 Mar 2018 15:22:54 +0000 (-0700) Subject: spirv: Allow pointers to have a deref at the base X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=d5930c222c0452becffb157052833e2b35ad6fbd;p=mesa.git spirv: Allow pointers to have a deref at the base Previously, pointers fell into two categories: index/offset for UBOs, SSBOs, etc. and var + access chain for logical pointers. This commit adds another logical pointer mode that's deref + access chain. It's tempting to think that we can just replace variable-based pointers with deref-based or at least replace the access chain with a deref chain. Unfortunately, there are a few sticky bits that prevent this: 1) We can't return deref-based pointers from OpVariable because those opcodes may come outside of a function so there's no place to emit the deref instructions. 2) We can't always use variable-based pointers because we may not always know the variable. (We do now, but he upcoming function rework will take that option away.) 3) We also can't replace the access chain struct with a deref. Due to the re-ordering we do in order to handle loop continues, the derefs we would emit as part of OpAccessChain may not dominate their uses. We normally fix this up with nir_repair_ssa but that generates phi nodes which we don't want in the middle of our deref chains. All in all, we have no real better option than to support partial access chains while also re-emitting the deref instructions on the spot. Acked-by: Rob Clark Acked-by: Bas Nieuwenhuizen Acked-by: Dave Airlie Reviewed-by: Kenneth Graunke --- diff --git a/src/compiler/spirv/vtn_private.h b/src/compiler/spirv/vtn_private.h index 26c5a03aa51..bd4d28b4f37 100644 --- a/src/compiler/spirv/vtn_private.h +++ b/src/compiler/spirv/vtn_private.h @@ -433,10 +433,17 @@ struct vtn_pointer { /** The referenced variable, if known * * This field may be NULL if the pointer uses a (block_index, offset) pair - * instead of an access chain. + * instead of an access chain or if the access chain starts at a deref. */ struct vtn_variable *var; + /** The deref at the base of the chain + * + * This field may be NULL if the pointer uses a (block_index, offset) pair + * instead of an access chain or if the access chain starts at a variable. + */ + nir_deref_instr *deref; + /** 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 or diff --git a/src/compiler/spirv/vtn_variables.c b/src/compiler/spirv/vtn_variables.c index 4ad1ce65d1a..94016ac82f4 100644 --- a/src/compiler/spirv/vtn_variables.c +++ b/src/compiler/spirv/vtn_variables.c @@ -112,6 +112,7 @@ vtn_access_chain_pointer_dereference(struct vtn_builder *b, ptr->mode = base->mode; ptr->type = type; ptr->var = base->var; + ptr->deref = base->deref; ptr->chain = chain; return ptr; @@ -377,46 +378,30 @@ nir_deref_instr * vtn_pointer_to_deref(struct vtn_builder *b, struct vtn_pointer *ptr) { /* Do on-the-fly copy propagation for samplers. */ - if (ptr->var->copy_prop_sampler) + if (ptr->var && ptr->var->copy_prop_sampler) return vtn_pointer_to_deref(b, ptr->var->copy_prop_sampler); - nir_deref_instr *deref_var = - nir_deref_instr_create(b->nb.shader, nir_deref_type_var); - nir_ssa_dest_init(&deref_var->instr, &deref_var->dest, 1, 32, NULL); - nir_builder_instr_insert(&b->nb, &deref_var->instr); + nir_deref_instr *tail; + if (ptr->deref) { + tail = ptr->deref; + } else { + assert(ptr->var && ptr->var->var); + tail = nir_build_deref_var(&b->nb, ptr->var->var); + } - assert(ptr->var->var); - deref_var->mode = ptr->var->var->data.mode; - deref_var->type = ptr->var->var->type; - deref_var->var = ptr->var->var; /* Raw variable access */ if (!ptr->chain) - return deref_var; + return tail; struct vtn_access_chain *chain = ptr->chain; vtn_assert(chain); - struct vtn_type *deref_type = ptr->var->type; - nir_deref_instr *tail = deref_var; - for (unsigned i = 0; i < chain->length; i++) { - enum glsl_base_type base_type = glsl_get_base_type(deref_type->type); - switch (base_type) { - case GLSL_TYPE_UINT: - case GLSL_TYPE_INT: - case GLSL_TYPE_UINT16: - case GLSL_TYPE_INT16: - case GLSL_TYPE_UINT8: - case GLSL_TYPE_INT8: - case GLSL_TYPE_UINT64: - case GLSL_TYPE_INT64: - case GLSL_TYPE_FLOAT: - case GLSL_TYPE_FLOAT16: - case GLSL_TYPE_DOUBLE: - case GLSL_TYPE_BOOL: - case GLSL_TYPE_ARRAY: { - deref_type = deref_type->array_element; - + if (glsl_type_is_struct(tail->type)) { + vtn_assert(chain->link[i].mode == vtn_access_mode_literal); + unsigned idx = chain->link[i].id; + tail = nir_build_deref_struct(&b->nb, tail, idx); + } else { nir_ssa_def *index; if (chain->link[i].mode == vtn_access_mode_literal) { index = nir_imm_int(&b->nb, chain->link[i].id); @@ -425,18 +410,6 @@ vtn_pointer_to_deref(struct vtn_builder *b, struct vtn_pointer *ptr) index = vtn_ssa_value(b, chain->link[i].id)->def; } tail = nir_build_deref_array(&b->nb, tail, index); - break; - } - - case GLSL_TYPE_STRUCT: { - vtn_assert(chain->link[i].mode == vtn_access_mode_literal); - unsigned idx = chain->link[i].id; - deref_type = deref_type->members[idx]; - tail = nir_build_deref_struct(&b->nb, tail, idx); - break; - } - default: - vtn_fail("Invalid type for deref"); } }