Lines Matching refs:state
57 init_clone_state(clone_state *state, struct hash_table *remap_table,
60 state->global_clone = global;
61 state->allow_remap_fallback = allow_remap_fallback;
64 state->remap_table = remap_table;
66 state->remap_table = _mesa_pointer_hash_table_create(NULL);
69 list_inithead(&state->phi_srcs);
73 free_clone_state(clone_state *state)
75 _mesa_hash_table_destroy(state->remap_table, NULL);
79 _lookup_ptr(clone_state *state, const void *ptr, bool global)
86 if (!state->global_clone && global)
89 if (unlikely(!state->remap_table)) {
90 assert(state->allow_remap_fallback);
94 entry = _mesa_hash_table_search(state->remap_table, ptr);
96 assert(state->allow_remap_fallback);
104 add_remap(clone_state *state, void *nptr, const void *ptr)
106 _mesa_hash_table_insert(state->remap_table, ptr, nptr);
110 remap_local(clone_state *state, const void *ptr)
112 return _lookup_ptr(state, ptr, false);
116 remap_global(clone_state *state, const void *ptr)
118 return _lookup_ptr(state, ptr, true);
122 remap_reg(clone_state *state, const nir_register *reg)
124 return _lookup_ptr(state, reg, false);
128 remap_var(clone_state *state, const nir_variable *var)
130 return _lookup_ptr(state, var, nir_variable_is_global(var));
183 clone_variable(clone_state *state, const nir_variable *var)
185 nir_variable *nvar = nir_variable_clone(var, state->ns);
186 add_remap(state, nvar, var);
193 clone_var_list(clone_state *state, struct exec_list *dst,
198 nir_variable *nvar = clone_variable(state, var);
207 clone_register(clone_state *state, const nir_register *reg)
209 nir_register *nreg = rzalloc(state->ns, nir_register);
210 add_remap(state, nreg, reg);
227 clone_reg_list(clone_state *state, struct exec_list *dst,
232 nir_register *nreg = clone_register(state, reg);
238 __clone_src(clone_state *state, void *ninstr_or_if,
243 nsrc->ssa = remap_local(state, src->ssa);
245 nsrc->reg.reg = remap_reg(state, src->reg.reg);
248 __clone_src(state, ninstr_or_if, nsrc->reg.indirect, src->reg.indirect);
255 __clone_dst(clone_state *state, nir_instr *ninstr,
262 if (likely(state->remap_table))
263 add_remap(state, &ndst->ssa, &dst->ssa);
265 ndst->reg.reg = remap_reg(state, dst->reg.reg);
268 __clone_src(state, ninstr, ndst->reg.indirect, dst->reg.indirect);
275 clone_alu(clone_state *state, const nir_alu_instr *alu)
277 nir_alu_instr *nalu = nir_alu_instr_create(state->ns, alu->op);
282 __clone_dst(state, &nalu->instr, &nalu->dest.dest, &alu->dest.dest);
287 __clone_src(state, &nalu->instr, &nalu->src[i].src, &alu->src[i].src);
300 clone_state state = {
304 return clone_alu(&state, orig);
308 clone_deref_instr(clone_state *state, const nir_deref_instr *deref)
311 nir_deref_instr_create(state->ns, deref->deref_type);
313 __clone_dst(state, &nderef->instr, &nderef->dest, &deref->dest);
319 nderef->var = remap_var(state, deref->var);
323 __clone_src(state, &nderef->instr, &nderef->parent, &deref->parent);
332 __clone_src(state, &nderef->instr,
355 clone_intrinsic(clone_state *state, const nir_intrinsic_instr *itr)
358 nir_intrinsic_instr_create(state->ns, itr->intrinsic);
363 __clone_dst(state, &nitr->instr, &nitr->dest, &itr->dest);
369 __clone_src(state, &nitr->instr, &nitr->src[i], &itr->src[i]);
375 clone_load_const(clone_state *state, const nir_load_const_instr *lc)
378 nir_load_const_instr_create(state->ns, lc->def.num_components,
383 add_remap(state, &nlc->def, &lc->def);
389 clone_ssa_undef(clone_state *state, const nir_ssa_undef_instr *sa)
392 nir_ssa_undef_instr_create(state->ns, sa->def.num_components,
395 add_remap(state, &nsa->def, &sa->def);
401 clone_tex(clone_state *state, const nir_tex_instr *tex)
403 nir_tex_instr *ntex = nir_tex_instr_create(state->ns, tex->num_srcs);
408 __clone_dst(state, &ntex->instr, &ntex->dest, &tex->dest);
411 __clone_src(state, &ntex->instr, &ntex->src[i].src, &tex->src[i].src);
432 clone_phi(clone_state *state, const nir_phi_instr *phi, nir_block *nblk)
434 nir_phi_instr *nphi = nir_phi_instr_create(state->ns);
436 __clone_dst(state, &nphi->instr, &nphi->dest, &phi->dest);
458 list_add(&nsrc->src.use_link, &state->phi_srcs);
465 clone_jump(clone_state *state, const nir_jump_instr *jmp)
470 nir_jump_instr *njmp = nir_jump_instr_create(state->ns, jmp->type);
476 clone_call(clone_state *state, const nir_call_instr *call)
478 nir_function *ncallee = remap_global(state, call->callee);
479 nir_call_instr *ncall = nir_call_instr_create(state->ns, ncallee);
482 __clone_src(state, ncall, &ncall->params[i], &call->params[i]);
488 clone_instr(clone_state *state, const nir_instr *instr)
492 return &clone_alu(state, nir_instr_as_alu(instr))->instr;
494 return &clone_deref_instr(state, nir_instr_as_deref(instr))->instr;
496 return &clone_intrinsic(state, nir_instr_as_intrinsic(instr))->instr;
498 return &clone_load_const(state, nir_instr_as_load_const(instr))->instr;
500 return &clone_ssa_undef(state, nir_instr_as_ssa_undef(instr))->instr;
502 return &clone_tex(state, nir_instr_as_tex(instr))->instr;
506 return &clone_jump(state, nir_instr_as_jump(instr))->instr;
508 return &clone_call(state, nir_instr_as_call(instr))->instr;
520 clone_state state = {
524 return clone_instr(&state, orig);
531 clone_state state = {
536 return clone_instr(&state, orig);
540 clone_block(clone_state *state, struct exec_list *cf_list, const nir_block *blk)
552 add_remap(state, nblk, blk);
561 clone_phi(state, nir_instr_as_phi(instr), nblk);
563 nir_instr *ninstr = clone_instr(state, instr);
572 clone_cf_list(clone_state *state, struct exec_list *dst,
576 clone_if(clone_state *state, struct exec_list *cf_list, const nir_if *i)
578 nir_if *ni = nir_if_create(state->ns);
581 __clone_src(state, ni, &ni->condition, &i->condition);
585 clone_cf_list(state, &ni->then_list, &i->then_list);
586 clone_cf_list(state, &ni->else_list, &i->else_list);
592 clone_loop(clone_state *state, struct exec_list *cf_list, const nir_loop *loop)
594 nir_loop *nloop = nir_loop_create(state->ns);
600 clone_cf_list(state, &nloop->body, &loop->body);
607 clone_cf_list(clone_state *state, struct exec_list *dst,
613 clone_block(state, dst, nir_cf_node_as_block(cf));
616 clone_if(state, dst, nir_cf_node_as_if(cf));
619 clone_loop(state, dst, nir_cf_node_as_loop(cf));
633 fixup_phi_srcs(clone_state *state)
635 list_for_each_entry_safe(nir_phi_src, src, &state->phi_srcs, src.use_link) {
636 src->pred = remap_local(state, src->pred);
642 src->src.ssa = remap_local(state, src->src.ssa);
645 src->src.reg.reg = remap_reg(state, src->src.reg.reg);
649 assert(list_is_empty(&state->phi_srcs));
662 clone_state state;
663 init_clone_state(&state, remap_table, false, true);
666 state.ns = src->impl->function->shader;
671 nir_block *nblk = nir_block_create(state.ns);
675 clone_cf_list(&state, &dst->list, &src->list);
677 fixup_phi_srcs(&state);
680 free_clone_state(&state);
684 clone_function_impl(clone_state *state, const nir_function_impl *fi)
686 nir_function_impl *nfi = nir_function_impl_create_bare(state->ns);
689 nfi->preamble = remap_global(state, fi->preamble);
691 clone_var_list(state, &nfi->locals, &fi->locals);
692 clone_reg_list(state, &nfi->registers, &fi->registers);
695 assert(list_is_empty(&state->phi_srcs));
697 clone_cf_list(state, &nfi->body, &fi->body);
699 fixup_phi_srcs(state);
710 clone_state state;
711 init_clone_state(&state, NULL, false, false);
713 state.ns = shader;
715 nir_function_impl *nfi = clone_function_impl(&state, fi);
717 free_clone_state(&state);
723 clone_function(clone_state *state, const nir_function *fxn, nir_shader *ns)
725 assert(ns == state->ns);
729 add_remap(state, nfxn, fxn);
733 nfxn->params = ralloc_array(state->ns, nir_parameter, fxn->num_params);
751 clone_state state;
752 init_clone_state(&state, NULL, true, false);
755 state.ns = ns;
757 clone_var_list(&state, &ns->variables, &s->variables);
761 clone_function(&state, fxn, ns);
769 nir_function *nfxn = remap_global(&state, fxn);
770 nfxn->impl = clone_function_impl(&state, fxn->impl);
796 free_clone_state(&state);