nir: Use a single list for all shader variables

[mesa.git] / src / compiler / nir / nir_clone.c

diff --git a/src/compiler/nir/nir_clone.c b/src/compiler/nir/nir_clone.c
index 803923e2578aad6dfce32db524e53bf9bcf5c54c..f57fce599c1c7af127bb5bc24b7920520667b106 100644 (file)
--- a/src/compiler/nir/nir_clone.c
+++ b/src/compiler/nir/nir_clone.c
@@ -85,6 +85,11 @@ _lookup_ptr(clone_state *state, const void *ptr, bool global)
    if (!state->global_clone && global)
       return (void *)ptr;
 
+   if (unlikely(!state->remap_table)) {
+      assert(state->allow_remap_fallback);
+      return (void *)ptr;
+   }
+
    entry = _mesa_hash_table_search(state->remap_table, ptr);
    if (!entry) {
       assert(state->allow_remap_fallback);
@@ -254,7 +259,8 @@ __clone_dst(clone_state *state, nir_instr *ninstr,
    if (dst->is_ssa) {
       nir_ssa_dest_init(ninstr, ndst, dst->ssa.num_components,
                         dst->ssa.bit_size, dst->ssa.name);
-      add_remap(state, &ndst->ssa, &dst->ssa);
+      if (likely(state->remap_table))
+         add_remap(state, &ndst->ssa, &dst->ssa);
    } else {
       ndst->reg.reg = remap_reg(state, dst->reg.reg);
       if (dst->reg.indirect) {
@@ -265,31 +271,13 @@ __clone_dst(clone_state *state, nir_instr *ninstr,
    }
 }
 
-nir_alu_instr *
-nir_alu_instr_clone(nir_shader *shader, const nir_alu_instr *orig)
-{
-   nir_alu_instr *clone = nir_alu_instr_create(shader, orig->op);
-
-   clone->exact = orig->exact;
-
-   for (unsigned i = 0; i < nir_op_infos[orig->op].num_inputs; i++)
-      nir_alu_src_copy(&clone->src[i], &orig->src[i], clone);
-
-   nir_ssa_dest_init(&clone->instr,
-                     &clone->dest.dest,
-                     orig->dest.dest.ssa.num_components,
-                     orig->dest.dest.ssa.bit_size,
-                     orig->dest.dest.ssa.name);
-   clone->dest.write_mask = orig->dest.write_mask;
-
-   return clone;
-}
-
 static nir_alu_instr *
 clone_alu(clone_state *state, const nir_alu_instr *alu)
 {
    nir_alu_instr *nalu = nir_alu_instr_create(state->ns, alu->op);
    nalu->exact = alu->exact;
+   nalu->no_signed_wrap = alu->no_signed_wrap;
+   nalu->no_unsigned_wrap = alu->no_unsigned_wrap;
 
    __clone_dst(state, &nalu->instr, &nalu->dest.dest, &alu->dest.dest);
    nalu->dest.saturate = alu->dest.saturate;
@@ -306,6 +294,16 @@ clone_alu(clone_state *state, const nir_alu_instr *alu)
    return nalu;
 }
 
+nir_alu_instr *
+nir_alu_instr_clone(nir_shader *shader, const nir_alu_instr *orig)
+{
+   clone_state state = {
+      .allow_remap_fallback = true,
+      .ns = shader,
+   };
+   return clone_alu(&state, orig);
+}
+
 static nir_deref_instr *
 clone_deref_instr(clone_state *state, const nir_deref_instr *deref)
 {
@@ -417,9 +415,11 @@ clone_tex(clone_state *state, const nir_tex_instr *tex)
    memcpy(ntex->tg4_offsets, tex->tg4_offsets, sizeof(tex->tg4_offsets));
 
    ntex->texture_index = tex->texture_index;
-   ntex->texture_array_size = tex->texture_array_size;
    ntex->sampler_index = tex->sampler_index;
 
+   ntex->texture_non_uniform = tex->texture_non_uniform;
+   ntex->sampler_non_uniform = tex->sampler_non_uniform;
+
    return ntex;
 }
 
@@ -627,7 +627,7 @@ fixup_phi_srcs(clone_state *state)
          list_addtail(&src->src.use_link, &src->src.reg.reg->uses);
       }
    }
-   assert(list_empty(&state->phi_srcs));
+   assert(list_is_empty(&state->phi_srcs));
 }
 
 void
@@ -667,7 +667,7 @@ clone_function_impl(clone_state *state, const nir_function_impl *fi)
    clone_reg_list(state, &nfi->registers, &fi->registers);
    nfi->reg_alloc = fi->reg_alloc;
 
-   assert(list_empty(&state->phi_srcs));
+   assert(list_is_empty(&state->phi_srcs));
 
    clone_cf_list(state, &nfi->body, &fi->body);
 
@@ -704,8 +704,10 @@ clone_function(clone_state *state, const nir_function *fxn, nir_shader *ns)
    add_remap(state, nfxn, fxn);
 
    nfxn->num_params = fxn->num_params;
-   nfxn->params = ralloc_array(state->ns, nir_parameter, fxn->num_params);
-   memcpy(nfxn->params, fxn->params, sizeof(nir_parameter) * fxn->num_params);
+   if (fxn->num_params) {
+           nfxn->params = ralloc_array(state->ns, nir_parameter, fxn->num_params);
+           memcpy(nfxn->params, fxn->params, sizeof(nir_parameter) * fxn->num_params);
+   }
    nfxn->is_entrypoint = fxn->is_entrypoint;
 
    /* At first glance, it looks like we should clone the function_impl here.
@@ -726,12 +728,7 @@ nir_shader_clone(void *mem_ctx, const nir_shader *s)
    nir_shader *ns = nir_shader_create(mem_ctx, s->info.stage, s->options, NULL);
    state.ns = ns;
 
-   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);
+   clone_var_list(&state, &ns->variables, &s->variables);
 
    /* Go through and clone functions */
    foreach_list_typed(nir_function, fxn, node, &s->functions)
@@ -794,12 +791,7 @@ nir_shader_replace(nir_shader *dst, nir_shader *src)
    /* We have to move all the linked lists over separately because we need the
     * pointers in the list elements to point to the lists in dst and not src.
     */
-   exec_list_move_nodes_to(&src->uniforms,      &dst->uniforms);
-   exec_list_move_nodes_to(&src->inputs,        &dst->inputs);
-   exec_list_move_nodes_to(&src->outputs,       &dst->outputs);
-   exec_list_move_nodes_to(&src->shared,        &dst->shared);
-   exec_list_move_nodes_to(&src->globals,       &dst->globals);
-   exec_list_move_nodes_to(&src->system_values, &dst->system_values);
+   exec_list_move_nodes_to(&src->variables, &dst->variables);
 
    /* Now move the functions over.  This takes a tiny bit more work */
    exec_list_move_nodes_to(&src->functions, &dst->functions);