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);
static nir_register *
remap_reg(clone_state *state, const nir_register *reg)
{
- return _lookup_ptr(state, reg, reg->is_global);
+ return _lookup_ptr(state, reg, false);
}
static nir_variable *
nvar->name = ralloc_strdup(nvar, var->name);
nvar->data = var->data;
nvar->num_state_slots = var->num_state_slots;
- nvar->state_slots = ralloc_array(nvar, nir_state_slot, var->num_state_slots);
- memcpy(nvar->state_slots, var->state_slots,
- var->num_state_slots * sizeof(nir_state_slot));
+ if (var->num_state_slots) {
+ nvar->state_slots = ralloc_array(nvar, nir_state_slot, var->num_state_slots);
+ memcpy(nvar->state_slots, var->state_slots,
+ var->num_state_slots * sizeof(nir_state_slot));
+ }
if (var->constant_initializer) {
nvar->constant_initializer =
nir_constant_clone(var->constant_initializer, nvar);
nreg->num_array_elems = reg->num_array_elems;
nreg->index = reg->index;
nreg->name = ralloc_strdup(nreg, reg->name);
- nreg->is_global = reg->is_global;
/* reconstructing uses/defs/if_uses handled by nir_instr_insert() */
list_inithead(&nreg->uses);
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) {
{
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;
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)
{
nir_load_const_instr_create(state->ns, lc->def.num_components,
lc->def.bit_size);
- memcpy(&nlc->value, &lc->value, sizeof(nlc->value));
+ memcpy(&nlc->value, &lc->value, sizeof(*nlc->value) * lc->def.num_components);
add_remap(state, &nlc->def, &lc->def);
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;
}
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
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);
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.
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)
nfxn->impl->function = nfxn;
}
- clone_reg_list(&state, &ns->registers, &s->registers);
- ns->reg_alloc = s->reg_alloc;
-
ns->info = s->info;
ns->info.name = ralloc_strdup(ns, ns->info.name);
if (ns->info.label)
ns->num_uniforms = s->num_uniforms;
ns->num_outputs = s->num_outputs;
ns->num_shared = s->num_shared;
+ ns->scratch_size = s->scratch_size;
ns->constant_data_size = s->constant_data_size;
if (s->constant_data_size > 0) {
return ns;
}
+
+/** Overwrites dst and replaces its contents with src
+ *
+ * Everything ralloc parented to dst and src itself (but not its children)
+ * will be freed.
+ *
+ * This should only be used by test code which needs to swap out shaders with
+ * a cloned or deserialized version.
+ */
+void
+nir_shader_replace(nir_shader *dst, nir_shader *src)
+{
+ /* Delete all of dest's ralloc children */
+ void *dead_ctx = ralloc_context(NULL);
+ ralloc_adopt(dead_ctx, dst);
+ ralloc_free(dead_ctx);
+
+ /* Re-parent all of src's ralloc children to dst */
+ ralloc_adopt(dst, src);
+
+ memcpy(dst, src, sizeof(*dst));
+
+ /* 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->variables, &dst->variables);
+
+ /* Now move the functions over. This takes a tiny bit more work */
+ exec_list_move_nodes_to(&src->functions, &dst->functions);
+ nir_foreach_function(function, dst)
+ function->shader = dst;
+
+ ralloc_free(src);
+}