[Mesa-dev] [PATCH 1/8] nir: Make nir_copy_deref follow the "clone" pattern

Jason Ekstrand jason at jlekstrand.net
Tue Dec 27 14:50:16 UTC 2016


On Dec 27, 2016 8:35 AM, "Jason Ekstrand" <jason at jlekstrand.net> wrote:



On Dec 27, 2016 7:05 AM, "Eduardo Lima Mitev" <elima at igalia.com> wrote:

On 12/26/2016 06:13 PM, Jason Ekstrand wrote:
> We rename it to nir_deref_clone, re-order the sources to match the other
> clone functions, and expose nir_deref_var_clone.  This past part, in
> particular, lets us get rid of quite a few lines since we no longer have
> to call nir_copy_deref and wrap it in deref_to_var.
> ---
>

This patch brings a number of regressions in piglit at least, crashing
tests that were passing or failing before. All of them crash because
nir_deref_var_clone() gets called with a null 'deref' argument. The
attached diff fixes all crashes I found, but I only tried piglit, so
there could be more. Maybe the solution is just adding a check for
nullness to 'deref' argument inside nir_deref_var_clone() ?


I've already done that locally


It turns or that I put the fix in a later patch that I didn't send out.
I've pulled it into this patch and an running it through CI now.  Thanks
for catching it.

The list of regressions are:

spec/arb_shader_texture_lod/compiler/tex_grad-texturecube-cube-vec3.frag

spec/arb_shader_texture_lod/execution/arb_shader_texture_lod-texgradcube

spec/arb_shader_texture_lod/execution/tex-miplevel-selection *gradarb cube

spec/arb_texture_cube_map_array/compiler/tex_grad-01.frag

spec/ext_image_dma_buf_import/ext_image_dma_buf_import-sample_nv12

spec/ext_image_dma_buf_import/ext_image_dma_buf_import-sample_yuv420

spec/ext_image_dma_buf_import/ext_image_dma_buf_import-sample_yvu420

spec/glsl-1.30/execution/tex-miplevel-selection texturegrad cube

spec/glsl-1.30/execution/tex-miplevel-selection texturegrad cubearray

spec/glsl-1.30/execution/tex-miplevel-selection texturegrad cubeshadow


An example gdb backtrace:

Starting program: piglit/bin/glslparsertest
generated_tests/spec/arb_shader_texture_lod/compiler/tex_
grad-textureCube-Cube-vec3.frag
pass 1.10 GL_ARB_shader_texture_lod
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Program received signal SIGSEGV, Segmentation fault.
0x00007ffff1720f09 in nir_deref_var_clone (deref=0x0, mem_ctx=0x786c40)
at nir/nir.c:630
630        nir_deref_var *ret = nir_deref_var_create(mem_ctx, deref->var);
(gdb) bt
#0  0x00007ffff1720f09 in nir_deref_var_clone (deref=0x0,
mem_ctx=0x786c40) at nir/nir.c:630
#1  0x00007ffff1759f95 in get_texture_size (b=0x7fffffffd7e0,
tex=0x782260) at nir/nir_lower_tex.c:168
#2  0x00007ffff175af05 in lower_gradient_cube_map (b=0x7fffffffd7e0,
tex=0x782260) at nir/nir_lower_tex.c:363
#3  0x00007ffff175c6bc in nir_lower_tex_block (block=0x781000,
b=0x7fffffffd7e0, options=0x7ffff1a42ce0 <tex_options>) at
nir/nir_lower_tex.c:786
#4  0x00007ffff175c78b in nir_lower_tex_impl (impl=0x780f10,
options=0x7ffff1a42ce0 <tex_options>) at nir/nir_lower_tex.c:811
#5  0x00007ffff175c810 in nir_lower_tex (shader=0x7878e0,
options=0x7ffff1a42ce0 <tex_options>) at nir/nir_lower_tex.c:826
#6  0x00007ffff18c7152 in brw_preprocess_nir (compiler=0x62e760,
nir=0x7878e0) at brw_nir.c:494
#7  0x00007ffff17c1b6b in brw_create_nir (brw=0x7ffff7f80040,
shader_prog=0x8f42d0, prog=0x780680, stage=MESA_SHADER_FRAGMENT,
is_scalar=true) at brw_program.c:93
#8  0x00007ffff17b927e in brw_link_shader (ctx=0x7ffff7f80040,
shProg=0x8f42d0) at brw_link.cpp:245
#9  0x00007ffff162a676 in _mesa_glsl_link_shader (ctx=0x7ffff7f80040,
prog=0x8f42d0) at program/ir_to_mesa.cpp:3066
#10 0x00007ffff14bd7bc in _mesa_link_program (ctx=0x7ffff7f80040,
shProg=0x8f42d0) at main/shaderapi.c:1089
#11 0x00007ffff14be87d in _mesa_LinkProgram (programObj=2) at
main/shaderapi.c:1595
#12 0x00007ffff7ac9c3d in stub_glLinkProgram (program=2) at
tests/util/piglit-dispatch-gen.c:33005
#13 0x000000000040206f in test () at
tests/glslparsertest/glslparsertest.c:345
#14 0x00000000004026ed in piglit_init (argc=5, argv=0x7fffffffdd68) at
tests/glslparsertest/glslparsertest.c:543
#15 0x00007ffff7b3b0b0 in run_test (gl_fw=0x615c20, argc=5,
argv=0x7fffffffdd68) at
tests/util/piglit-framework-gl/piglit_winsys_framework.c:73
#16 0x00007ffff7b1fbe4 in piglit_gl_test_run (argc=5,
argv=0x7fffffffdd68, config=0x7fffffffdc20) at
tests/util/piglit-framework-gl.c:203
#17 0x000000000040196e in main (argc=5, argv=0x7fffffffdd68) at
tests/glslparsertest/glslparsertest.c:90

Eduardo

>  src/compiler/glsl/glsl_to_nir.cpp                  |  3 +--
>  src/compiler/nir/nir.c                             | 22
+++++++++++-----------
>  src/compiler/nir/nir.h                             |  4 ++--
>  src/compiler/nir/nir_builder.h                     |  6 +++---
>  src/compiler/nir/nir_inline_functions.c            |  2 +-
>  src/compiler/nir/nir_lower_indirect_derefs.c       |  6 ++----
>  src/compiler/nir/nir_lower_tex.c                   | 18
++++++------------
>  src/compiler/nir/nir_lower_var_copies.c            |  4 ++--
>  src/compiler/nir/nir_split_var_copies.c            | 17 +++++++----------
>  src/compiler/spirv/spirv_to_nir.c                  | 22
++++++++++------------
>  src/compiler/spirv/vtn_glsl450.c                   |  3 +--
>  src/compiler/spirv/vtn_variables.c                 |  3 +--
>  src/intel/vulkan/anv_nir_lower_input_attachments.c |  3 +--
>  13 files changed, 48 insertions(+), 65 deletions(-)
>
> diff --git a/src/compiler/glsl/glsl_to_nir.cpp
b/src/compiler/glsl/glsl_to_nir.cpp
> index fcaca9f..8efd030 100644
> --- a/src/compiler/glsl/glsl_to_nir.cpp
> +++ b/src/compiler/glsl/glsl_to_nir.cpp
> @@ -1179,8 +1179,7 @@ nir_visitor::visit(ir_assignment *ir)
>        nir_intrinsic_instr_create(this->shader, nir_intrinsic_store_var);
>     store->num_components = ir->lhs->type->vector_elements;
>     nir_intrinsic_set_write_mask(store, ir->write_mask);
> -   nir_deref *store_deref = nir_copy_deref(store, &lhs_deref->deref);
> -   store->variables[0] = nir_deref_as_var(store_deref);
> +   store->variables[0] = nir_deref_var_clone(lhs_deref, store);
>     store->src[0] = nir_src_for_ssa(src);
>
>     if (ir->condition) {
> diff --git a/src/compiler/nir/nir.c b/src/compiler/nir/nir.c
> index 885616e..6057143 100644
> --- a/src/compiler/nir/nir.c
> +++ b/src/compiler/nir/nir.c
> @@ -624,18 +624,18 @@ nir_deref_struct_create(void *mem_ctx, unsigned
field_index)
>     return deref;
>  }
>
> -static nir_deref_var *
> -copy_deref_var(void *mem_ctx, nir_deref_var *deref)
> +nir_deref_var *
> +nir_deref_var_clone(const nir_deref_var *deref, void *mem_ctx)
>  {
>     nir_deref_var *ret = nir_deref_var_create(mem_ctx, deref->var);
>     ret->deref.type = deref->deref.type;
>     if (deref->deref.child)
> -      ret->deref.child = nir_copy_deref(ret, deref->deref.child);
> +      ret->deref.child = nir_deref_clone(deref->deref.child, ret);
>     return ret;
>  }
>
>  static nir_deref_array *
> -copy_deref_array(void *mem_ctx, nir_deref_array *deref)
> +deref_array_clone(const nir_deref_array *deref, void *mem_ctx)
>  {
>     nir_deref_array *ret = nir_deref_array_create(mem_ctx);
>     ret->base_offset = deref->base_offset;
> @@ -645,33 +645,33 @@ copy_deref_array(void *mem_ctx, nir_deref_array
*deref)
>     }
>     ret->deref.type = deref->deref.type;
>     if (deref->deref.child)
> -      ret->deref.child = nir_copy_deref(ret, deref->deref.child);
> +      ret->deref.child = nir_deref_clone(deref->deref.child, ret);
>     return ret;
>  }
>
>  static nir_deref_struct *
> -copy_deref_struct(void *mem_ctx, nir_deref_struct *deref)
> +deref_struct_clone(const nir_deref_struct *deref, void *mem_ctx)
>  {
>     nir_deref_struct *ret = nir_deref_struct_create(mem_ctx,
deref->index);
>     ret->deref.type = deref->deref.type;
>     if (deref->deref.child)
> -      ret->deref.child = nir_copy_deref(ret, deref->deref.child);
> +      ret->deref.child = nir_deref_clone(deref->deref.child, ret);
>     return ret;
>  }
>
>  nir_deref *
> -nir_copy_deref(void *mem_ctx, nir_deref *deref)
> +nir_deref_clone(const nir_deref *deref, void *mem_ctx)
>  {
>     if (deref == NULL)
>        return NULL;
>
>     switch (deref->deref_type) {
>     case nir_deref_type_var:
> -      return &copy_deref_var(mem_ctx, nir_deref_as_var(deref))->deref;
> +      return &nir_deref_var_clone(nir_deref_as_var(deref),
mem_ctx)->deref;
>     case nir_deref_type_array:
> -      return &copy_deref_array(mem_ctx, nir_deref_as_array(deref))->de
ref;
> +      return &deref_array_clone(nir_deref_as_array(deref),
mem_ctx)->deref;
>     case nir_deref_type_struct:
> -      return &copy_deref_struct(mem_ctx, nir_deref_as_struct(deref))->d
eref;
> +      return &deref_struct_clone(nir_deref_as_struct(deref),
mem_ctx)->deref;
>     default:
>        unreachable("Invalid dereference type");
>     }
> diff --git a/src/compiler/nir/nir.h b/src/compiler/nir/nir.h
> index 6557631..d896679 100644
> --- a/src/compiler/nir/nir.h
> +++ b/src/compiler/nir/nir.h
> @@ -1927,8 +1927,6 @@ nir_deref_var *nir_deref_var_create(void *mem_ctx,
nir_variable *var);
>  nir_deref_array *nir_deref_array_create(void *mem_ctx);
>  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);
> @@ -2236,6 +2234,8 @@ nir_shader *nir_shader_clone(void *mem_ctx, const
nir_shader *s);
>  nir_function_impl *nir_function_impl_clone(const nir_function_impl *fi);
>  nir_constant *nir_constant_clone(const nir_constant *c, nir_variable
*var);
>  nir_variable *nir_variable_clone(const nir_variable *c, nir_shader
*shader);
> +nir_deref *nir_deref_clone(const nir_deref *deref, void *mem_ctx);
> +nir_deref_var *nir_deref_var_clone(const nir_deref_var *deref, void
*mem_ctx);
>
>  #ifdef DEBUG
>  void nir_validate_shader(nir_shader *shader);
> diff --git a/src/compiler/nir/nir_builder.h b/src/compiler/nir/nir_builder
.h
> index 0ee7d1a..2ea9af1 100644
> --- a/src/compiler/nir/nir_builder.h
> +++ b/src/compiler/nir/nir_builder.h
> @@ -437,7 +437,7 @@ nir_store_deref_var(nir_builder *build, nir_deref_var
*deref,
>        nir_intrinsic_instr_create(build->shader, nir_intrinsic_store_var);
>     store->num_components = num_components;
>     store->const_index[0] = writemask & ((1 << num_components) - 1);
> -   store->variables[0] = nir_deref_as_var(nir_copy_deref(store,
&deref->deref));
> +   store->variables[0] = nir_deref_var_clone(deref, store);
>     store->src[0] = nir_src_for_ssa(value);
>     nir_builder_instr_insert(build, &store->instr);
>  }
> @@ -450,8 +450,8 @@ nir_copy_deref_var(nir_builder *build, nir_deref_var
*dest, nir_deref_var *src)
>
>     nir_intrinsic_instr *copy =
>        nir_intrinsic_instr_create(build->shader, nir_intrinsic_copy_var);
> -   copy->variables[0] = nir_deref_as_var(nir_copy_deref(copy,
&dest->deref));
> -   copy->variables[1] = nir_deref_as_var(nir_copy_deref(copy,
&src->deref));
> +   copy->variables[0] = nir_deref_var_clone(dest, copy);
> +   copy->variables[1] = nir_deref_var_clone(src, copy);
>     nir_builder_instr_insert(build, &copy->instr);
>  }
>
> diff --git a/src/compiler/nir/nir_inline_functions.c
b/src/compiler/nir/nir_inline_functions.c
> index c36748d..b91e7bc 100644
> --- a/src/compiler/nir/nir_inline_functions.c
> +++ b/src/compiler/nir/nir_inline_functions.c
> @@ -49,7 +49,7 @@ convert_deref_to_param_deref(nir_instr *instr,
nir_deref_var **deref,
>     /* Now we make a new deref by concatenating the deref in the call's
>      * parameter with the deref we were given.
>      */
> -   nir_deref_var *new_deref = nir_deref_as_var(nir_copy_deref(instr,
&call_deref->deref));
> +   nir_deref_var *new_deref = nir_deref_var_clone(call_deref, instr);
>     nir_deref *new_tail = nir_deref_tail(&new_deref->deref);
>     new_tail->child = (*deref)->deref.child;
>     ralloc_steal(new_tail, new_tail->child);
> diff --git a/src/compiler/nir/nir_lower_indirect_derefs.c
b/src/compiler/nir/nir_lower_indirect_derefs.c
> index 5c97dc8e..09cc9a3 100644
> --- a/src/compiler/nir/nir_lower_indirect_derefs.c
> +++ b/src/compiler/nir/nir_lower_indirect_derefs.c
> @@ -122,8 +122,7 @@ emit_load_store(nir_builder *b, nir_intrinsic_instr
*orig_instr,
>        nir_intrinsic_instr *load =
>           nir_intrinsic_instr_create(b->shader, nir_intrinsic_load_var);
>        load->num_components = orig_instr->num_components;
> -      load->variables[0] =
> -         nir_deref_as_var(nir_copy_deref(load, &deref->deref));
> +      load->variables[0] = nir_deref_var_clone(deref, load);
>        unsigned bit_size = orig_instr->dest.ssa.bit_size;
>        nir_ssa_dest_init(&load->instr, &load->dest,
>                          load->num_components, bit_size, NULL);
> @@ -135,8 +134,7 @@ emit_load_store(nir_builder *b, nir_intrinsic_instr
*orig_instr,
>           nir_intrinsic_instr_create(b->shader, nir_intrinsic_store_var);
>        store->num_components = orig_instr->num_components;
>        nir_intrinsic_set_write_mask(store, nir_intrinsic_write_mask(orig_
instr));
> -      store->variables[0] =
> -         nir_deref_as_var(nir_copy_deref(store, &deref->deref));
> +      store->variables[0] = nir_deref_var_clone(deref, store);
>        store->src[0] = nir_src_for_ssa(src);
>        nir_builder_instr_insert(b, &store->instr);
>     }
> diff --git a/src/compiler/nir/nir_lower_tex.c
b/src/compiler/nir/nir_lower_tex.c
> index 3e3ac8c..66e2317 100644
> --- a/src/compiler/nir/nir_lower_tex.c
> +++ b/src/compiler/nir/nir_lower_tex.c
> @@ -163,11 +163,9 @@ get_texture_size(nir_builder *b, nir_tex_instr *tex)
>     txs->is_shadow = tex->is_shadow;
>     txs->is_new_style_shadow = tex->is_new_style_shadow;
>     txs->texture_index = tex->texture_index;
> -   txs->texture = (nir_deref_var *)
> -      nir_copy_deref(txs, &tex->texture->deref);
> +   txs->texture = nir_deref_var_clone(tex->texture, txs);
>     txs->sampler_index = tex->sampler_index;
> -   txs->sampler = (nir_deref_var *)
> -      nir_copy_deref(txs, &tex->sampler->deref);
> +   txs->sampler = nir_deref_var_clone(tex->sampler, txs);
>     txs->dest_type = nir_type_int;
>
>     /* only single src, the lod: */
> @@ -221,11 +219,9 @@ sample_plane(nir_builder *b, nir_tex_instr *tex, int
plane)
>     plane_tex->coord_components = 2;
>
>     plane_tex->texture_index = tex->texture_index;
> -   plane_tex->texture = (nir_deref_var *)
> -      nir_copy_deref(plane_tex, &tex->texture->deref);
> +   plane_tex->texture = nir_deref_var_clone(tex->texture, plane_tex);
>     plane_tex->sampler_index = tex->sampler_index;
> -   plane_tex->sampler = (nir_deref_var *)
> -      nir_copy_deref(plane_tex, &tex->sampler->deref);
> +   plane_tex->sampler = nir_deref_var_clone(tex->sampler, plane_tex);
>
>     nir_ssa_dest_init(&plane_tex->instr, &plane_tex->dest, 4, 32, NULL);
>
> @@ -325,10 +321,8 @@ replace_gradient_with_lod(nir_builder *b,
nir_ssa_def *lod, nir_tex_instr *tex)
>     txl->is_shadow = tex->is_shadow;
>     txl->is_new_style_shadow = tex->is_new_style_shadow;
>     txl->sampler_index = tex->sampler_index;
> -   txl->texture = (nir_deref_var *)
> -      nir_copy_deref(txl, &tex->texture->deref);
> -   txl->sampler = (nir_deref_var *)
> -      nir_copy_deref(txl, &tex->sampler->deref);
> +   txl->texture = nir_deref_var_clone(tex->texture, txl);
> +   txl->sampler = nir_deref_var_clone(tex->sampler, txl);
>     txl->coord_components = tex->coord_components;
>
>     nir_ssa_dest_init(&txl->instr, &txl->dest, 4, 32, NULL);
> diff --git a/src/compiler/nir/nir_lower_var_copies.c
b/src/compiler/nir/nir_lower_var_copies.c
> index b7e9989..b12d953 100644
> --- a/src/compiler/nir/nir_lower_var_copies.c
> +++ b/src/compiler/nir/nir_lower_var_copies.c
> @@ -121,7 +121,7 @@ emit_copy_load_store(nir_intrinsic_instr *copy_instr,
>        nir_intrinsic_instr *load =
>           nir_intrinsic_instr_create(mem_ctx, nir_intrinsic_load_var);
>        load->num_components = num_components;
> -      load->variables[0] = nir_deref_as_var(nir_copy_deref(load,
&src_head->deref));
> +      load->variables[0] = nir_deref_var_clone(src_head, load);
>        nir_ssa_dest_init(&load->instr, &load->dest, num_components,
bit_size,
>                          NULL);
>
> @@ -131,7 +131,7 @@ emit_copy_load_store(nir_intrinsic_instr *copy_instr,
>           nir_intrinsic_instr_create(mem_ctx, nir_intrinsic_store_var);
>        store->num_components = num_components;
>        nir_intrinsic_set_write_mask(store, (1 << num_components) - 1);
> -      store->variables[0] = nir_deref_as_var(nir_copy_deref(store,
&dest_head->deref));
> +      store->variables[0] = nir_deref_var_clone(dest_head, store);
>
>        store->src[0].is_ssa = true;
>        store->src[0].ssa = &load->dest.ssa;
> diff --git a/src/compiler/nir/nir_split_var_copies.c
b/src/compiler/nir/nir_split_var_copies.c
> index 63a7611..cfebb0b 100644
> --- a/src/compiler/nir/nir_split_var_copies.c
> +++ b/src/compiler/nir/nir_split_var_copies.c
> @@ -82,7 +82,7 @@ struct split_var_copies_state {
>   */
>  static void
>  split_var_copy_instr(nir_intrinsic_instr *old_copy,
> -                     nir_deref *dest_head, nir_deref *src_head,
> +                     nir_deref_var *dest_head, nir_deref_var *src_head,
>                       nir_deref *dest_tail, nir_deref *src_tail,
>                       struct split_var_copies_state *state)
>  {
> @@ -182,11 +182,8 @@ split_var_copy_instr(nir_intrinsic_instr *old_copy,
>            * belongs to the copy instruction and b) the deref chains may
>            * have some of the same links due to the way we constructed
them
>            */
> -         nir_deref *src = nir_copy_deref(new_copy, src_head);
> -         nir_deref *dest = nir_copy_deref(new_copy, dest_head);
> -
> -         new_copy->variables[0] = nir_deref_as_var(dest);
> -         new_copy->variables[1] = nir_deref_as_var(src);
> +         new_copy->variables[0] = nir_deref_var_clone(dest_head,
new_copy);
> +         new_copy->variables[1] = nir_deref_var_clone(src_head,
new_copy);
>
>           /* Emit the copy instruction after the old instruction.  We'll
>            * remove the old one later.
> @@ -216,10 +213,10 @@ split_var_copies_block(nir_block *block, struct
split_var_copies_state *state)
>        if (intrinsic->intrinsic != nir_intrinsic_copy_var)
>           continue;
>
> -      nir_deref *dest_head = &intrinsic->variables[0]->deref;
> -      nir_deref *src_head = &intrinsic->variables[1]->deref;
> -      nir_deref *dest_tail = nir_deref_tail(dest_head);
> -      nir_deref *src_tail = nir_deref_tail(src_head);
> +      nir_deref_var *dest_head = intrinsic->variables[0];
> +      nir_deref_var *src_head = intrinsic->variables[1];
> +      nir_deref *dest_tail = nir_deref_tail(&dest_head->deref);
> +      nir_deref *src_tail = nir_deref_tail(&src_head->deref);
>
>        switch (glsl_get_base_type(src_tail->type)) {
>        case GLSL_TYPE_ARRAY:
> diff --git a/src/compiler/spirv/spirv_to_nir.c
b/src/compiler/spirv/spirv_to_nir.c
> index 57d0886..739fa71 100644
> --- a/src/compiler/spirv/spirv_to_nir.c
> +++ b/src/compiler/spirv/spirv_to_nir.c
> @@ -1206,7 +1206,7 @@ vtn_handle_function_call(struct vtn_builder *b,
SpvOp opcode,
>        struct vtn_value *arg = vtn_untyped_value(b, arg_id);
>        if (arg->value_type == vtn_value_type_access_chain) {
>           nir_deref_var *d = vtn_access_chain_to_deref(b,
arg->access_chain);
> -         call->params[i] = nir_deref_as_var(nir_copy_deref(call,
&d->deref));
> +         call->params[i] = nir_deref_var_clone(d, call);
>        } else {
>           struct vtn_ssa_value *arg_ssa = vtn_ssa_value(b, arg_id);
>
> @@ -1542,15 +1542,15 @@ vtn_handle_texture(struct vtn_builder *b, SpvOp
opcode,
>     }
>
>     nir_deref_var *sampler = vtn_access_chain_to_deref(b,
sampled.sampler);
> -   nir_deref *texture;
> +   nir_deref_var *texture;
>     if (sampled.image) {
>        nir_deref_var *image = vtn_access_chain_to_deref(b, sampled.image);
> -      texture = &image->deref;
> +      texture = image;
>     } else {
> -      texture = &sampler->deref;
> +      texture = sampler;
>     }
>
> -   instr->texture = nir_deref_as_var(nir_copy_deref(instr, texture));
> +   instr->texture = nir_deref_var_clone(texture, instr);
>
>     switch (instr->op) {
>     case nir_texop_tex:
> @@ -1558,7 +1558,7 @@ vtn_handle_texture(struct vtn_builder *b, SpvOp
opcode,
>     case nir_texop_txl:
>     case nir_texop_txd:
>        /* These operations require a sampler */
> -      instr->sampler = nir_deref_as_var(nir_copy_deref(instr,
&sampler->deref));
> +      instr->sampler = nir_deref_var_clone(sampler, instr);
>        break;
>     case nir_texop_txf:
>     case nir_texop_txf_ms:
> @@ -1599,8 +1599,7 @@ vtn_handle_texture(struct vtn_builder *b, SpvOp
opcode,
>           instrs[i]->is_new_style_shadow = instr->is_new_style_shadow;
>           instrs[i]->component = instr->component;
>           instrs[i]->dest_type = instr->dest_type;
> -         instrs[i]->texture =
> -            nir_deref_as_var(nir_copy_deref(instrs[i], texture));
> +         instrs[i]->texture = nir_deref_var_clone(texture, instrs[i]);
>           instrs[i]->sampler = NULL;
>
>           memcpy(instrs[i]->src, srcs, instr->num_srcs *
sizeof(*instr->src));
> @@ -1807,8 +1806,7 @@ vtn_handle_image(struct vtn_builder *b, SpvOp
opcode,
>     nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(b->shader,
op);
>
>     nir_deref_var *image_deref = vtn_access_chain_to_deref(b,
image.image);
> -   intrin->variables[0] =
> -      nir_deref_as_var(nir_copy_deref(&intrin->instr,
&image_deref->deref));
> +   intrin->variables[0] = nir_deref_var_clone(image_deref, intrin);
>
>     /* ImageQuerySize doesn't take any extra parameters */
>     if (opcode != SpvOpImageQuerySize) {
> @@ -1967,10 +1965,10 @@ vtn_handle_ssbo_or_shared_atomic(struct
vtn_builder *b, SpvOp opcode,
>
>     if (chain->var->mode == vtn_variable_mode_workgroup) {
>        struct vtn_type *type = chain->var->type;
> -      nir_deref *deref = &vtn_access_chain_to_deref(b, chain)->deref;
> +      nir_deref_var *deref = vtn_access_chain_to_deref(b, chain);
>        nir_intrinsic_op op = get_shared_nir_atomic_op(opcode);
>        atomic = nir_intrinsic_instr_create(b->nb.shader, op);
> -      atomic->variables[0] = nir_deref_as_var(nir_copy_deref(atomic,
deref));
> +      atomic->variables[0] = nir_deref_var_clone(deref, atomic);
>
>        switch (opcode) {
>        case SpvOpAtomicLoad:
> diff --git a/src/compiler/spirv/vtn_glsl450.c
b/src/compiler/spirv/vtn_glsl450.c
> index fbc7ce6..a19676f 100644
> --- a/src/compiler/spirv/vtn_glsl450.c
> +++ b/src/compiler/spirv/vtn_glsl450.c
> @@ -667,8 +667,7 @@ handle_glsl450_interpolation(struct vtn_builder *b,
enum GLSLstd450 opcode,
>     nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(b->nb.shader,
op);
>
>     nir_deref_var *deref = vtn_nir_deref(b, w[5]);
> -   intrin->variables[0] =
> -      nir_deref_as_var(nir_copy_deref(intrin, &deref->deref));
> +   intrin->variables[0] = nir_deref_var_clone(deref, intrin);
>
>     switch (opcode) {
>     case GLSLstd450InterpolateAtCentroid:
> diff --git a/src/compiler/spirv/vtn_variables.c
b/src/compiler/spirv/vtn_variables.c
> index be64dd9..de7c8fe 100644
> --- a/src/compiler/spirv/vtn_variables.c
> +++ b/src/compiler/spirv/vtn_variables.c
> @@ -186,8 +186,7 @@ _vtn_local_load_store(struct vtn_builder *b, bool
load, nir_deref_var *deref,
>                                     nir_intrinsic_store_var;
>
>        nir_intrinsic_instr *intrin = nir_intrinsic_instr_create(b->shader,
op);
> -      intrin->variables[0] =
> -         nir_deref_as_var(nir_copy_deref(intrin, &deref->deref));
> +      intrin->variables[0] = nir_deref_var_clone(deref, intrin);
>        intrin->num_components = glsl_get_vector_elements(tail->type);
>
>        if (load) {
> diff --git a/src/intel/vulkan/anv_nir_lower_input_attachments.c
b/src/intel/vulkan/anv_nir_lower_input_attachments.c
> index e11b563..1d6f727 100644
> --- a/src/intel/vulkan/anv_nir_lower_input_attachments.c
> +++ b/src/intel/vulkan/anv_nir_lower_input_attachments.c
> @@ -86,8 +86,7 @@ try_lower_input_load(nir_function_impl *impl,
nir_intrinsic_instr *load)
>     tex->is_array = true;
>     tex->is_shadow = false;
>
> -   tex->texture =
> -      nir_deref_as_var(nir_copy_deref(tex, &load->variables[0]->deref));
> +   tex->texture = nir_deref_var_clone(load->variables[0], tex);
>     tex->sampler = NULL;
>     tex->texture_index = 0;
>     tex->sampler_index = 0;
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.freedesktop.org/archives/mesa-dev/attachments/20161227/c383d5fe/attachment-0001.html>


More information about the mesa-dev mailing list