1 files changed, 89 insertions, 37 deletions

diff --git a/src/compiler/nir/nir_clone.c b/src/compiler/nir/nir_clone.c
index 5eff743d835..bc6df56b753 100644
--- a/src/compiler/nir/nir_clone.c
+++ b/src/compiler/nir/nir_clone.c
@@ -32,8 +32,11 @@
  */
 
 typedef struct {
+   /* True if we are cloning an entire shader. */
+   bool global_clone;
+
    /* maps orig ptr -> cloned ptr: */
-   struct hash_table *ptr_table;
+   struct hash_table *remap_table;
 
    /* List of phi sources. */
    struct list_head phi_srcs;
@@ -43,28 +46,32 @@ typedef struct {
 } clone_state;
 
 static void
-init_clone_state(clone_state *state)
+init_clone_state(clone_state *state, bool global)
 {
-   state->ptr_table = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
-                                              _mesa_key_pointer_equal);
+   state->global_clone = global;
+   state->remap_table = _mesa_hash_table_create(NULL, _mesa_hash_pointer,
+                                                _mesa_key_pointer_equal);
    list_inithead(&state->phi_srcs);
 }
 
 static void
 free_clone_state(clone_state *state)
 {
-   _mesa_hash_table_destroy(state->ptr_table, NULL);
+   _mesa_hash_table_destroy(state->remap_table, NULL);
 }
 
-static void *
-lookup_ptr(clone_state *state, const void *ptr)
+static inline void *
+_lookup_ptr(clone_state *state, const void *ptr, bool global)
 {
    struct hash_entry *entry;
 
    if (!ptr)
       return NULL;
 
-   entry = _mesa_hash_table_search(state->ptr_table, ptr);
+   if (!state->global_clone && global)
+      return (void *)ptr;
+
+   entry = _mesa_hash_table_search(state->remap_table, ptr);
    assert(entry && "Failed to find pointer!");
    if (!entry)
       return NULL;
@@ -73,13 +80,37 @@ lookup_ptr(clone_state *state, const void *ptr)
 }
 
 static void
-store_ptr(clone_state *state, void *nptr, const void *ptr)
+add_remap(clone_state *state, void *nptr, const void *ptr)
+{
+   _mesa_hash_table_insert(state->remap_table, ptr, nptr);
+}
+
+static void *
+remap_local(clone_state *state, const void *ptr)
 {
-   _mesa_hash_table_insert(state->ptr_table, ptr, nptr);
+   return _lookup_ptr(state, ptr, false);
 }
 
-static nir_constant *
-clone_constant(clone_state *state, const nir_constant *c, nir_variable *nvar)
+static void *
+remap_global(clone_state *state, const void *ptr)
+{
+   return _lookup_ptr(state, ptr, true);
+}
+
+static nir_register *
+remap_reg(clone_state *state, const nir_register *reg)
+{
+   return _lookup_ptr(state, reg, reg->is_global);
+}
+
+static nir_variable *
+remap_var(clone_state *state, const nir_variable *var)
+{
+   return _lookup_ptr(state, var, var->data.mode != nir_var_local);
+}
+
+nir_constant *
+nir_constant_clone(const nir_constant *c, nir_variable *nvar)
 {
    nir_constant *nc = ralloc(nvar, nir_constant);
 
@@ -87,7 +118,7 @@ clone_constant(clone_state *state, const nir_constant *c, nir_variable *nvar)
    nc->num_elements = c->num_elements;
    nc->elements = ralloc_array(nvar, nir_constant *, c->num_elements);
    for (unsigned i = 0; i < c->num_elements; i++) {
-      nc->elements[i] = clone_constant(state, c->elements[i], nvar);
+      nc->elements[i] = nir_constant_clone(c->elements[i], nvar);
    }
 
    return nc;
@@ -100,7 +131,7 @@ static nir_variable *
 clone_variable(clone_state *state, const nir_variable *var)
 {
    nir_variable *nvar = rzalloc(state->ns, nir_variable);
-   store_ptr(state, nvar, var);
+   add_remap(state, nvar, var);
 
    nvar->type = var->type;
    nvar->name = ralloc_strdup(nvar, var->name);
@@ -111,7 +142,7 @@ clone_variable(clone_state *state, const nir_variable *var)
           var->num_state_slots * sizeof(nir_state_slot));
    if (var->constant_initializer) {
       nvar->constant_initializer =
-         clone_constant(state, var->constant_initializer, nvar);
+         nir_constant_clone(var->constant_initializer, nvar);
    }
    nvar->interface_type = var->interface_type;
 
@@ -137,7 +168,7 @@ static nir_register *
 clone_register(clone_state *state, const nir_register *reg)
 {
    nir_register *nreg = rzalloc(state->ns, nir_register);
-   store_ptr(state, nreg, reg);
+   add_remap(state, nreg, reg);
 
    nreg->num_components = reg->num_components;
    nreg->num_array_elems = reg->num_array_elems;
@@ -172,9 +203,9 @@ __clone_src(clone_state *state, void *ninstr_or_if,
 {
    nsrc->is_ssa = src->is_ssa;
    if (src->is_ssa) {
-      nsrc->ssa = lookup_ptr(state, src->ssa);
+      nsrc->ssa = remap_local(state, src->ssa);
    } else {
-      nsrc->reg.reg = lookup_ptr(state, src->reg.reg);
+      nsrc->reg.reg = remap_reg(state, src->reg.reg);
       if (src->reg.indirect) {
          nsrc->reg.indirect = ralloc(ninstr_or_if, nir_src);
          __clone_src(state, ninstr_or_if, nsrc->reg.indirect, src->reg.indirect);
@@ -190,9 +221,9 @@ __clone_dst(clone_state *state, nir_instr *ninstr,
    ndst->is_ssa = dst->is_ssa;
    if (dst->is_ssa) {
       nir_ssa_dest_init(ninstr, ndst, dst->ssa.num_components, dst->ssa.name);
-      store_ptr(state, &ndst->ssa, &dst->ssa);
+      add_remap(state, &ndst->ssa, &dst->ssa);
    } else {
-      ndst->reg.reg = lookup_ptr(state, dst->reg.reg);
+      ndst->reg.reg = remap_reg(state, dst->reg.reg);
       if (dst->reg.indirect) {
          ndst->reg.indirect = ralloc(ninstr, nir_src);
          __clone_src(state, ninstr, ndst->reg.indirect, dst->reg.indirect);
@@ -208,7 +239,7 @@ static nir_deref_var *
 clone_deref_var(clone_state *state, const nir_deref_var *dvar,
                 nir_instr *ninstr)
 {
-   nir_variable *nvar = lookup_ptr(state, dvar->var);
+   nir_variable *nvar = remap_var(state, dvar->var);
    nir_deref_var *ndvar = nir_deref_var_create(ninstr, nvar);
 
    if (dvar->deref.child)
@@ -322,7 +353,7 @@ clone_load_const(clone_state *state, const nir_load_const_instr *lc)
 
    memcpy(&nlc->value, &lc->value, sizeof(nlc->value));
 
-   store_ptr(state, &nlc->def, &lc->def);
+   add_remap(state, &nlc->def, &lc->def);
 
    return nlc;
 }
@@ -333,7 +364,7 @@ clone_ssa_undef(clone_state *state, const nir_ssa_undef_instr *sa)
    nir_ssa_undef_instr *nsa =
       nir_ssa_undef_instr_create(state->ns, sa->def.num_components);
 
-   store_ptr(state, &nsa->def, &sa->def);
+   add_remap(state, &nsa->def, &sa->def);
 
    return nsa;
 }
@@ -357,8 +388,11 @@ clone_tex(clone_state *state, const nir_tex_instr *tex)
    ntex->is_new_style_shadow = tex->is_new_style_shadow;
    memcpy(ntex->const_offset, tex->const_offset, sizeof(ntex->const_offset));
    ntex->component = tex->component;
+   ntex->texture_index = tex->texture_index;
+   ntex->texture_array_size = tex->texture_array_size;
+   if (tex->texture)
+      ntex->texture = clone_deref_var(state, tex->texture, &ntex->instr);
    ntex->sampler_index = tex->sampler_index;
-   ntex->sampler_array_size = tex->sampler_array_size;
    if (tex->sampler)
       ntex->sampler = clone_deref_var(state, tex->sampler, &ntex->instr);
 
@@ -420,7 +454,7 @@ clone_jump(clone_state *state, const nir_jump_instr *jmp)
 static nir_call_instr *
 clone_call(clone_state *state, const nir_call_instr *call)
 {
-   nir_function *ncallee = lookup_ptr(state, call->callee);
+   nir_function *ncallee = remap_global(state, call->callee);
    nir_call_instr *ncall = nir_call_instr_create(state->ns, ncallee);
 
    for (unsigned i = 0; i < ncall->num_params; i++)
@@ -473,7 +507,7 @@ clone_block(clone_state *state, struct exec_list *cf_list, const nir_block *blk)
    assert(exec_list_is_empty(&nblk->instr_list));
 
    /* We need this for phi sources */
-   store_ptr(state, nblk, blk);
+   add_remap(state, nblk, blk);
 
    nir_foreach_instr(blk, instr) {
       if (instr->type == nir_instr_type_phi) {
@@ -546,10 +580,9 @@ clone_cf_list(clone_state *state, struct exec_list *dst,
 }
 
 static nir_function_impl *
-clone_function_impl(clone_state *state, const nir_function_impl *fi,
-                    nir_function *nfxn)
+clone_function_impl(clone_state *state, const nir_function_impl *fi)
 {
-   nir_function_impl *nfi = nir_function_impl_create(nfxn);
+   nir_function_impl *nfi = nir_function_impl_create_bare(state->ns);
 
    clone_var_list(state, &nfi->locals, &fi->locals);
    clone_reg_list(state, &nfi->registers, &fi->registers);
@@ -558,9 +591,9 @@ clone_function_impl(clone_state *state, const nir_function_impl *fi,
    nfi->num_params = fi->num_params;
    nfi->params = ralloc_array(state->ns, nir_variable *, fi->num_params);
    for (unsigned i = 0; i < fi->num_params; i++) {
-      nfi->params[i] = lookup_ptr(state, fi->params[i]);
+      nfi->params[i] = remap_local(state, fi->params[i]);
    }
-   nfi->return_var = lookup_ptr(state, fi->return_var);
+   nfi->return_var = remap_local(state, fi->return_var);
 
    assert(list_empty(&state->phi_srcs));
 
@@ -572,9 +605,9 @@ clone_function_impl(clone_state *state, const nir_function_impl *fi,
     * add it to the phi_srcs list and we fix it up here.
     */
    list_for_each_entry_safe(nir_phi_src, src, &state->phi_srcs, src.use_link) {
-      src->pred = lookup_ptr(state, src->pred);
+      src->pred = remap_local(state, src->pred);
       assert(src->src.is_ssa);
-      src->src.ssa = lookup_ptr(state, src->src.ssa);
+      src->src.ssa = remap_local(state, src->src.ssa);
 
       /* Remove from this list and place in the uses of the SSA def */
       list_del(&src->src.use_link);
@@ -588,6 +621,22 @@ clone_function_impl(clone_state *state, const nir_function_impl *fi,
    return nfi;
 }
 
+nir_function_impl *
+nir_function_impl_clone(const nir_function_impl *fi)
+{
+   clone_state state;
+   init_clone_state(&state, false);
+
+   /* We use the same shader */
+   state.ns = fi->function->shader;
+
+   nir_function_impl *nfi = clone_function_impl(&state, fi);
+
+   free_clone_state(&state);
+
+   return nfi;
+}
+
 static nir_function *
 clone_function(clone_state *state, const nir_function *fxn, nir_shader *ns)
 {
@@ -595,7 +644,7 @@ clone_function(clone_state *state, const nir_function *fxn, nir_shader *ns)
    nir_function *nfxn = nir_function_create(ns, fxn->name);
 
    /* Needed for call instructions */
-   store_ptr(state, nfxn, fxn);
+   add_remap(state, nfxn, fxn);
 
    nfxn->num_params = fxn->num_params;
    nfxn->params = ralloc_array(state->ns, nir_parameter, fxn->num_params);
@@ -616,7 +665,7 @@ nir_shader *
 nir_shader_clone(void *mem_ctx, const nir_shader *s)
 {
    clone_state state;
-   init_clone_state(&state);
+   init_clone_state(&state, true);
 
    nir_shader *ns = nir_shader_create(mem_ctx, s->stage, s->options);
    state.ns = ns;
@@ -624,6 +673,7 @@ nir_shader_clone(void *mem_ctx, const nir_shader *s)
    clone_var_list(&state, &ns->uniforms, &s->uniforms);
    clone_var_list(&state, &ns->inputs,   &s->inputs);
    clone_var_list(&state, &ns->outputs,  &s->outputs);
+   clone_var_list(&state, &ns->shared,   &s->shared);
    clone_var_list(&state, &ns->globals,  &s->globals);
    clone_var_list(&state, &ns->system_values, &s->system_values);
 
@@ -637,8 +687,9 @@ nir_shader_clone(void *mem_ctx, const nir_shader *s)
     * will have in the list.
     */
    nir_foreach_function(s, fxn) {
-      nir_function *nfxn = lookup_ptr(&state, fxn);
-      clone_function_impl(&state, fxn->impl, nfxn);
+      nir_function *nfxn = remap_global(&state, fxn);
+      nfxn->impl = clone_function_impl(&state, fxn->impl);
+      nfxn->impl->function = nfxn;
    }
 
    clone_reg_list(&state, &ns->registers, &s->registers);
@@ -652,6 +703,7 @@ nir_shader_clone(void *mem_ctx, const nir_shader *s)
    ns->num_inputs = s->num_inputs;
    ns->num_uniforms = s->num_uniforms;
    ns->num_outputs = s->num_outputs;
+   ns->num_shared = s->num_shared;
 
    free_clone_state(&state);