[Mesa-dev] [PATCH 1/2] nir: Add a nir_deref_foreach_leaf helper

[Kenneth Graunke]

On Friday, July 15, 2016 3:47:39 PM PDT Jason Ekstrand wrote:
> Signed-off-by: Jason Ekstrand <jason at jlekstrand.net>
> Cc: "12.0" <mesa-stable at lists.freedesktop.org>
> Cc: Connor Abbott <cwabbott0 at gmail.com>
> ---
>  src/compiler/nir/nir.c               | 107 +++++++++++++++++++++++++++++++++++
>  src/compiler/nir/nir.h               |   4 ++
>  src/compiler/nir/nir_lower_returns.c |   9 +--
>  3 files changed, 116 insertions(+), 4 deletions(-)
> 
> diff --git a/src/compiler/nir/nir.c b/src/compiler/nir/nir.c
> index 3c8b4e0..a4a28a3 100644
> --- a/src/compiler/nir/nir.c
> +++ b/src/compiler/nir/nir.c
> @@ -659,6 +659,113 @@ nir_copy_deref(void *mem_ctx, nir_deref *deref)
>     return NULL;
>  }
>  
> +/* This is the second step in the recursion.  We've found the tail and made a
> + * copy.  Now we need to iterate over all possible leaves and call the
> + * callback on each one.
> + */
> +static bool
> +deref_foreach_leaf_build_recur(nir_deref_var *deref, nir_deref *tail,
> +                               nir_deref_foreach_leaf_cb cb, void *state)
> +{
> +   unsigned length;
> +   union {
> +      nir_deref_array arr;
> +      nir_deref_struct str;
> +   } tmp;
> +
> +   assert(tail->child == NULL);
> +   switch (glsl_get_base_type(tail->type)) {
> +   case GLSL_TYPE_ARRAY:
> +      tmp.arr.deref.deref_type = nir_deref_type_array;
> +      tmp.arr.deref.child = NULL;
> +      tmp.arr.deref.type = glsl_get_array_element(tail->type);
> +      tmp.arr.deref_array_type = nir_deref_array_type_direct;
> +      tmp.arr.indirect = NIR_SRC_INIT;
> +      tail->child = &tmp.arr.deref;
> +
> +      length = glsl_get_length(tail->type);
> +      for (unsigned i = 0; i < length; i++) {
> +         tmp.arr.base_offset = i;
> +         if (!deref_foreach_leaf_build_recur(deref, &tmp.arr.deref, cb, state))
> +            return false;
> +      }
> +      return true;
> +
> +   case GLSL_TYPE_STRUCT:
> +      tmp.str.deref.deref_type = nir_deref_type_struct;
> +      tmp.str.deref.child = NULL;
> +      tail->child = &tmp.str.deref;
> +
> +      length = glsl_get_length(tail->type);
> +      for (unsigned i = 0; i < length; i++) {
> +         tmp.str.deref.type = glsl_get_struct_field(tail->type, i);
> +         tmp.str.index = i;
> +         if (!deref_foreach_leaf_build_recur(deref, &tmp.arr.deref, cb, state))
> +            return false;
> +      }
> +      return true;
> +
> +   default:
> +      return cb(deref, state);
> +   }
> +}
> +
> +/* This is the first step of the foreach_leaf recursion.  In this step we are
> + * walking to the end of the deref chain and making a copy in the stack as we
> + * go.  This is because we don't want to mutate the deref chain that was
> + * passed in by the caller.  The downside is that this deref chain is on the
> + * stack and , if the caller wants to do anything with it, they will have to
> + * make their own copy because this one will go away.
> + */
> +static bool
> +deref_foreach_leaf_copy_recur(nir_deref_var *deref, nir_deref *tail,
> +                              nir_deref_foreach_leaf_cb cb, void *state)
> +{
> +   union {
> +      nir_deref_array arr;
> +      nir_deref_struct str;
> +   } c;
> +
> +   if (tail->child) {
> +      switch (tail->child->deref_type) {
> +      case nir_deref_type_array:
> +         c.arr = *nir_deref_as_array(tail->child);
> +         tail->child = &c.arr.deref;
> +         return deref_foreach_leaf_copy_recur(deref, &c.arr.deref, cb, state);
> +
> +      case nir_deref_type_struct:
> +         c.str = *nir_deref_as_struct(tail->child);
> +         tail->child = &c.str.deref;
> +         return deref_foreach_leaf_copy_recur(deref, &c.str.deref, cb, state);
> +
> +      case nir_deref_type_var:
> +      default:
> +         unreachable("Invalid deref type for a child");
> +      }
> +   } else {
> +      /* We've gotten to the end of the original deref.  Time to start
> +       * building our own derefs.
> +       */
> +      return deref_foreach_leaf_build_recur(deref, tail, cb, state);
> +   }
> +}
> +
> +/**
> + * This function iterates over all of the possible derefs that can be created
> + * with the given deref as the head.  It then calls the provided callback with
> + * a full deref for each one.
> + *
> + * The deref passed to the callback will be allocated on the stack.  You will
> + * need to make a copy if you want it to hang around.
> + */
> +bool
> +nir_deref_foreach_leaf(nir_deref_var *deref,
> +                       nir_deref_foreach_leaf_cb cb, void *state)
> +{
> +   nir_deref_var copy = *deref;
> +   return deref_foreach_leaf_copy_recur(&copy, &copy.deref, cb, state);
> +}
> +
>  /* Returns a load_const instruction that represents the constant
>   * initializer for the given deref chain.  The caller is responsible for
>   * ensuring that there actually is a constant initializer.
> diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h
> index a7921ee..79716b1 100644
> --- a/src/compiler/nir/nir.h
> +++ b/src/compiler/nir/nir.h
> @@ -1929,6 +1929,10 @@ nir_deref_struct *nir_deref_struct_create(void *mem_ctx, unsigned field_index);
>  
>  nir_deref *nir_copy_deref(void *mem_ctx, nir_deref *deref);
>  
> +typedef bool (*nir_deref_foreach_leaf_cb)(nir_deref_var *deref, void *state);
> +bool nir_deref_foreach_leaf(nir_deref_var *deref,
> +                            nir_deref_foreach_leaf_cb cb, void *state);
> +
>  nir_load_const_instr *
>  nir_deref_get_const_initializer_load(nir_shader *shader, nir_deref_var *deref);

The above code is:
Reviewed-by: Kenneth Graunke <kenneth at whitecape.org>

>  
> diff --git a/src/compiler/nir/nir_lower_returns.c b/src/compiler/nir/nir_lower_returns.c
> index 8dbea6e..cf49d5b 100644
> --- a/src/compiler/nir/nir_lower_returns.c
> +++ b/src/compiler/nir/nir_lower_returns.c
> @@ -147,17 +147,18 @@ lower_returns_in_block(nir_block *block, struct lower_returns_state *state)
>     nir_instr_remove(&jump->instr);
>  
>     nir_builder *b = &state->builder;
> -   b->cursor = nir_after_block(block);
>  
>     /* Set the return flag */
>     if (state->return_flag == NULL) {
>        state->return_flag =
>           nir_local_variable_create(b->impl, glsl_bool_type(), "return");
>  
> -      /* Set a default value of false */
> -      state->return_flag->constant_initializer =
> -         rzalloc(state->return_flag, nir_constant);
> +      /* Initialize the variable to 0 */
> +      b->cursor = nir_before_cf_list(&b->impl->body);
> +      nir_store_var(b, state->return_flag, nir_imm_int(b, NIR_FALSE), 1);
>     }
> +
> +   b->cursor = nir_after_block(block);
>     nir_store_var(b, state->return_flag, nir_imm_int(b, NIR_TRUE), 1);
>  
>     if (state->loop) {
> 

Please drop this code.  I believe it got squashed in accidentally,
and actually belongs in your "get rid of constant_initializer" series.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 819 bytes
Desc: This is a digitally signed message part.
URL: <https://lists.freedesktop.org/archives/mesa-dev/attachments/20160720/1068d528/attachment.sig>