2 * Copyright © 2015 Red Hat
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
25 #include "nir_control_flow.h"
27 /* Secret Decoder Ring:
29 * Allocate and clone a foo.
31 * Clone body of foo (ie. parent class, embedded struct, etc)
35 /* True if we are cloning an entire shader. */
38 /* If true allows the clone operation to fall back to the original pointer
39 * if no clone pointer is found in the remap table. This allows us to
40 * clone a loop body without having to add srcs from outside the loop to
41 * the remap table. This is useful for loop unrolling.
43 bool allow_remap_fallback
;
45 /* maps orig ptr -> cloned ptr: */
46 struct hash_table
*remap_table
;
48 /* List of phi sources. */
49 struct list_head phi_srcs
;
51 /* new shader object, used as memctx for just about everything else: */
56 init_clone_state(clone_state
*state
, struct hash_table
*remap_table
,
57 bool global
, bool allow_remap_fallback
)
59 state
->global_clone
= global
;
60 state
->allow_remap_fallback
= allow_remap_fallback
;
63 state
->remap_table
= remap_table
;
65 state
->remap_table
= _mesa_pointer_hash_table_create(NULL
);
68 list_inithead(&state
->phi_srcs
);
72 free_clone_state(clone_state
*state
)
74 _mesa_hash_table_destroy(state
->remap_table
, NULL
);
78 _lookup_ptr(clone_state
*state
, const void *ptr
, bool global
)
80 struct hash_entry
*entry
;
85 if (!state
->global_clone
&& global
)
88 if (unlikely(!state
->remap_table
)) {
89 assert(state
->allow_remap_fallback
);
93 entry
= _mesa_hash_table_search(state
->remap_table
, ptr
);
95 assert(state
->allow_remap_fallback
);
103 add_remap(clone_state
*state
, void *nptr
, const void *ptr
)
105 _mesa_hash_table_insert(state
->remap_table
, ptr
, nptr
);
109 remap_local(clone_state
*state
, const void *ptr
)
111 return _lookup_ptr(state
, ptr
, false);
115 remap_global(clone_state
*state
, const void *ptr
)
117 return _lookup_ptr(state
, ptr
, true);
120 static nir_register
*
121 remap_reg(clone_state
*state
, const nir_register
*reg
)
123 return _lookup_ptr(state
, reg
, false);
126 static nir_variable
*
127 remap_var(clone_state
*state
, const nir_variable
*var
)
129 return _lookup_ptr(state
, var
, nir_variable_is_global(var
));
133 nir_constant_clone(const nir_constant
*c
, nir_variable
*nvar
)
135 nir_constant
*nc
= ralloc(nvar
, nir_constant
);
137 memcpy(nc
->values
, c
->values
, sizeof(nc
->values
));
138 nc
->num_elements
= c
->num_elements
;
139 nc
->elements
= ralloc_array(nvar
, nir_constant
*, c
->num_elements
);
140 for (unsigned i
= 0; i
< c
->num_elements
; i
++) {
141 nc
->elements
[i
] = nir_constant_clone(c
->elements
[i
], nvar
);
147 /* NOTE: for cloning nir_variables, bypass nir_variable_create to avoid
148 * having to deal with locals and globals separately:
151 nir_variable_clone(const nir_variable
*var
, nir_shader
*shader
)
153 nir_variable
*nvar
= rzalloc(shader
, nir_variable
);
155 nvar
->type
= var
->type
;
156 nvar
->name
= ralloc_strdup(nvar
, var
->name
);
157 nvar
->data
= var
->data
;
158 nvar
->num_state_slots
= var
->num_state_slots
;
159 if (var
->num_state_slots
) {
160 nvar
->state_slots
= ralloc_array(nvar
, nir_state_slot
, var
->num_state_slots
);
161 memcpy(nvar
->state_slots
, var
->state_slots
,
162 var
->num_state_slots
* sizeof(nir_state_slot
));
164 if (var
->constant_initializer
) {
165 nvar
->constant_initializer
=
166 nir_constant_clone(var
->constant_initializer
, nvar
);
168 nvar
->interface_type
= var
->interface_type
;
170 nvar
->num_members
= var
->num_members
;
171 if (var
->num_members
) {
172 nvar
->members
= ralloc_array(nvar
, struct nir_variable_data
,
174 memcpy(nvar
->members
, var
->members
,
175 var
->num_members
* sizeof(*var
->members
));
181 static nir_variable
*
182 clone_variable(clone_state
*state
, const nir_variable
*var
)
184 nir_variable
*nvar
= nir_variable_clone(var
, state
->ns
);
185 add_remap(state
, nvar
, var
);
190 /* clone list of nir_variable: */
192 clone_var_list(clone_state
*state
, struct exec_list
*dst
,
193 const struct exec_list
*list
)
195 exec_list_make_empty(dst
);
196 foreach_list_typed(nir_variable
, var
, node
, list
) {
197 nir_variable
*nvar
= clone_variable(state
, var
);
198 exec_list_push_tail(dst
, &nvar
->node
);
202 /* NOTE: for cloning nir_registers, bypass nir_global/local_reg_create()
203 * to avoid having to deal with locals and globals separately:
205 static nir_register
*
206 clone_register(clone_state
*state
, const nir_register
*reg
)
208 nir_register
*nreg
= rzalloc(state
->ns
, nir_register
);
209 add_remap(state
, nreg
, reg
);
211 nreg
->num_components
= reg
->num_components
;
212 nreg
->bit_size
= reg
->bit_size
;
213 nreg
->num_array_elems
= reg
->num_array_elems
;
214 nreg
->index
= reg
->index
;
215 nreg
->name
= ralloc_strdup(nreg
, reg
->name
);
217 /* reconstructing uses/defs/if_uses handled by nir_instr_insert() */
218 list_inithead(&nreg
->uses
);
219 list_inithead(&nreg
->defs
);
220 list_inithead(&nreg
->if_uses
);
225 /* clone list of nir_register: */
227 clone_reg_list(clone_state
*state
, struct exec_list
*dst
,
228 const struct exec_list
*list
)
230 exec_list_make_empty(dst
);
231 foreach_list_typed(nir_register
, reg
, node
, list
) {
232 nir_register
*nreg
= clone_register(state
, reg
);
233 exec_list_push_tail(dst
, &nreg
->node
);
238 __clone_src(clone_state
*state
, void *ninstr_or_if
,
239 nir_src
*nsrc
, const nir_src
*src
)
241 nsrc
->is_ssa
= src
->is_ssa
;
243 nsrc
->ssa
= remap_local(state
, src
->ssa
);
245 nsrc
->reg
.reg
= remap_reg(state
, src
->reg
.reg
);
246 if (src
->reg
.indirect
) {
247 nsrc
->reg
.indirect
= ralloc(ninstr_or_if
, nir_src
);
248 __clone_src(state
, ninstr_or_if
, nsrc
->reg
.indirect
, src
->reg
.indirect
);
250 nsrc
->reg
.base_offset
= src
->reg
.base_offset
;
255 __clone_dst(clone_state
*state
, nir_instr
*ninstr
,
256 nir_dest
*ndst
, const nir_dest
*dst
)
258 ndst
->is_ssa
= dst
->is_ssa
;
260 nir_ssa_dest_init(ninstr
, ndst
, dst
->ssa
.num_components
,
261 dst
->ssa
.bit_size
, dst
->ssa
.name
);
262 if (likely(state
->remap_table
))
263 add_remap(state
, &ndst
->ssa
, &dst
->ssa
);
265 ndst
->reg
.reg
= remap_reg(state
, dst
->reg
.reg
);
266 if (dst
->reg
.indirect
) {
267 ndst
->reg
.indirect
= ralloc(ninstr
, nir_src
);
268 __clone_src(state
, ninstr
, ndst
->reg
.indirect
, dst
->reg
.indirect
);
270 ndst
->reg
.base_offset
= dst
->reg
.base_offset
;
274 static nir_alu_instr
*
275 clone_alu(clone_state
*state
, const nir_alu_instr
*alu
)
277 nir_alu_instr
*nalu
= nir_alu_instr_create(state
->ns
, alu
->op
);
278 nalu
->exact
= alu
->exact
;
279 nalu
->no_signed_wrap
= alu
->no_signed_wrap
;
280 nalu
->no_unsigned_wrap
= alu
->no_unsigned_wrap
;
282 __clone_dst(state
, &nalu
->instr
, &nalu
->dest
.dest
, &alu
->dest
.dest
);
283 nalu
->dest
.saturate
= alu
->dest
.saturate
;
284 nalu
->dest
.write_mask
= alu
->dest
.write_mask
;
286 for (unsigned i
= 0; i
< nir_op_infos
[alu
->op
].num_inputs
; i
++) {
287 __clone_src(state
, &nalu
->instr
, &nalu
->src
[i
].src
, &alu
->src
[i
].src
);
288 nalu
->src
[i
].negate
= alu
->src
[i
].negate
;
289 nalu
->src
[i
].abs
= alu
->src
[i
].abs
;
290 memcpy(nalu
->src
[i
].swizzle
, alu
->src
[i
].swizzle
,
291 sizeof(nalu
->src
[i
].swizzle
));
298 nir_alu_instr_clone(nir_shader
*shader
, const nir_alu_instr
*orig
)
300 clone_state state
= {
301 .allow_remap_fallback
= true,
304 return clone_alu(&state
, orig
);
307 static nir_deref_instr
*
308 clone_deref_instr(clone_state
*state
, const nir_deref_instr
*deref
)
310 nir_deref_instr
*nderef
=
311 nir_deref_instr_create(state
->ns
, deref
->deref_type
);
313 __clone_dst(state
, &nderef
->instr
, &nderef
->dest
, &deref
->dest
);
315 nderef
->mode
= deref
->mode
;
316 nderef
->type
= deref
->type
;
318 if (deref
->deref_type
== nir_deref_type_var
) {
319 nderef
->var
= remap_var(state
, deref
->var
);
323 __clone_src(state
, &nderef
->instr
, &nderef
->parent
, &deref
->parent
);
325 switch (deref
->deref_type
) {
326 case nir_deref_type_struct
:
327 nderef
->strct
.index
= deref
->strct
.index
;
330 case nir_deref_type_array
:
331 case nir_deref_type_ptr_as_array
:
332 __clone_src(state
, &nderef
->instr
,
333 &nderef
->arr
.index
, &deref
->arr
.index
);
336 case nir_deref_type_array_wildcard
:
340 case nir_deref_type_cast
:
341 nderef
->cast
.ptr_stride
= deref
->cast
.ptr_stride
;
345 unreachable("Invalid instruction deref type");
351 static nir_intrinsic_instr
*
352 clone_intrinsic(clone_state
*state
, const nir_intrinsic_instr
*itr
)
354 nir_intrinsic_instr
*nitr
=
355 nir_intrinsic_instr_create(state
->ns
, itr
->intrinsic
);
357 unsigned num_srcs
= nir_intrinsic_infos
[itr
->intrinsic
].num_srcs
;
359 if (nir_intrinsic_infos
[itr
->intrinsic
].has_dest
)
360 __clone_dst(state
, &nitr
->instr
, &nitr
->dest
, &itr
->dest
);
362 nitr
->num_components
= itr
->num_components
;
363 memcpy(nitr
->const_index
, itr
->const_index
, sizeof(nitr
->const_index
));
365 for (unsigned i
= 0; i
< num_srcs
; i
++)
366 __clone_src(state
, &nitr
->instr
, &nitr
->src
[i
], &itr
->src
[i
]);
371 static nir_load_const_instr
*
372 clone_load_const(clone_state
*state
, const nir_load_const_instr
*lc
)
374 nir_load_const_instr
*nlc
=
375 nir_load_const_instr_create(state
->ns
, lc
->def
.num_components
,
378 memcpy(&nlc
->value
, &lc
->value
, sizeof(*nlc
->value
) * lc
->def
.num_components
);
380 add_remap(state
, &nlc
->def
, &lc
->def
);
385 static nir_ssa_undef_instr
*
386 clone_ssa_undef(clone_state
*state
, const nir_ssa_undef_instr
*sa
)
388 nir_ssa_undef_instr
*nsa
=
389 nir_ssa_undef_instr_create(state
->ns
, sa
->def
.num_components
,
392 add_remap(state
, &nsa
->def
, &sa
->def
);
397 static nir_tex_instr
*
398 clone_tex(clone_state
*state
, const nir_tex_instr
*tex
)
400 nir_tex_instr
*ntex
= nir_tex_instr_create(state
->ns
, tex
->num_srcs
);
402 ntex
->sampler_dim
= tex
->sampler_dim
;
403 ntex
->dest_type
= tex
->dest_type
;
405 __clone_dst(state
, &ntex
->instr
, &ntex
->dest
, &tex
->dest
);
406 for (unsigned i
= 0; i
< ntex
->num_srcs
; i
++) {
407 ntex
->src
[i
].src_type
= tex
->src
[i
].src_type
;
408 __clone_src(state
, &ntex
->instr
, &ntex
->src
[i
].src
, &tex
->src
[i
].src
);
410 ntex
->coord_components
= tex
->coord_components
;
411 ntex
->is_array
= tex
->is_array
;
412 ntex
->is_shadow
= tex
->is_shadow
;
413 ntex
->is_new_style_shadow
= tex
->is_new_style_shadow
;
414 ntex
->component
= tex
->component
;
415 memcpy(ntex
->tg4_offsets
, tex
->tg4_offsets
, sizeof(tex
->tg4_offsets
));
417 ntex
->texture_index
= tex
->texture_index
;
418 ntex
->sampler_index
= tex
->sampler_index
;
420 ntex
->texture_non_uniform
= tex
->texture_non_uniform
;
421 ntex
->sampler_non_uniform
= tex
->sampler_non_uniform
;
426 static nir_phi_instr
*
427 clone_phi(clone_state
*state
, const nir_phi_instr
*phi
, nir_block
*nblk
)
429 nir_phi_instr
*nphi
= nir_phi_instr_create(state
->ns
);
431 __clone_dst(state
, &nphi
->instr
, &nphi
->dest
, &phi
->dest
);
433 /* Cloning a phi node is a bit different from other instructions. The
434 * sources of phi instructions are the only time where we can use an SSA
435 * def before it is defined. In order to handle this, we just copy over
436 * the sources from the old phi instruction directly and then fix them up
437 * in a second pass once all the instrutions in the function have been
440 * In order to ensure that the copied sources (which are the same as the
441 * old phi instruction's sources for now) don't get inserted into the old
442 * shader's use-def lists, we have to add the phi instruction *before* we
443 * set up its sources.
445 nir_instr_insert_after_block(nblk
, &nphi
->instr
);
447 foreach_list_typed(nir_phi_src
, src
, node
, &phi
->srcs
) {
448 nir_phi_src
*nsrc
= ralloc(nphi
, nir_phi_src
);
450 /* Just copy the old source for now. */
451 memcpy(nsrc
, src
, sizeof(*src
));
453 /* Since we're not letting nir_insert_instr handle use/def stuff for us,
454 * we have to set the parent_instr manually. It doesn't really matter
455 * when we do it, so we might as well do it here.
457 nsrc
->src
.parent_instr
= &nphi
->instr
;
459 /* Stash it in the list of phi sources. We'll walk this list and fix up
460 * sources at the very end of clone_function_impl.
462 list_add(&nsrc
->src
.use_link
, &state
->phi_srcs
);
464 exec_list_push_tail(&nphi
->srcs
, &nsrc
->node
);
470 static nir_jump_instr
*
471 clone_jump(clone_state
*state
, const nir_jump_instr
*jmp
)
473 nir_jump_instr
*njmp
= nir_jump_instr_create(state
->ns
, jmp
->type
);
478 static nir_call_instr
*
479 clone_call(clone_state
*state
, const nir_call_instr
*call
)
481 nir_function
*ncallee
= remap_global(state
, call
->callee
);
482 nir_call_instr
*ncall
= nir_call_instr_create(state
->ns
, ncallee
);
484 for (unsigned i
= 0; i
< ncall
->num_params
; i
++)
485 __clone_src(state
, ncall
, &ncall
->params
[i
], &call
->params
[i
]);
491 clone_instr(clone_state
*state
, const nir_instr
*instr
)
493 switch (instr
->type
) {
494 case nir_instr_type_alu
:
495 return &clone_alu(state
, nir_instr_as_alu(instr
))->instr
;
496 case nir_instr_type_deref
:
497 return &clone_deref_instr(state
, nir_instr_as_deref(instr
))->instr
;
498 case nir_instr_type_intrinsic
:
499 return &clone_intrinsic(state
, nir_instr_as_intrinsic(instr
))->instr
;
500 case nir_instr_type_load_const
:
501 return &clone_load_const(state
, nir_instr_as_load_const(instr
))->instr
;
502 case nir_instr_type_ssa_undef
:
503 return &clone_ssa_undef(state
, nir_instr_as_ssa_undef(instr
))->instr
;
504 case nir_instr_type_tex
:
505 return &clone_tex(state
, nir_instr_as_tex(instr
))->instr
;
506 case nir_instr_type_phi
:
507 unreachable("Cannot clone phis with clone_instr");
508 case nir_instr_type_jump
:
509 return &clone_jump(state
, nir_instr_as_jump(instr
))->instr
;
510 case nir_instr_type_call
:
511 return &clone_call(state
, nir_instr_as_call(instr
))->instr
;
512 case nir_instr_type_parallel_copy
:
513 unreachable("Cannot clone parallel copies");
515 unreachable("bad instr type");
521 clone_block(clone_state
*state
, struct exec_list
*cf_list
, const nir_block
*blk
)
523 /* Don't actually create a new block. Just use the one from the tail of
524 * the list. NIR guarantees that the tail of the list is a block and that
525 * no two blocks are side-by-side in the IR; It should be empty.
528 exec_node_data(nir_block
, exec_list_get_tail(cf_list
), cf_node
.node
);
529 assert(nblk
->cf_node
.type
== nir_cf_node_block
);
530 assert(exec_list_is_empty(&nblk
->instr_list
));
532 /* We need this for phi sources */
533 add_remap(state
, nblk
, blk
);
535 nir_foreach_instr(instr
, blk
) {
536 if (instr
->type
== nir_instr_type_phi
) {
537 /* Phi instructions are a bit of a special case when cloning because
538 * we don't want inserting the instruction to automatically handle
539 * use/defs for us. Instead, we need to wait until all the
540 * blocks/instructions are in so that we can set their sources up.
542 clone_phi(state
, nir_instr_as_phi(instr
), nblk
);
544 nir_instr
*ninstr
= clone_instr(state
, instr
);
545 nir_instr_insert_after_block(nblk
, ninstr
);
553 clone_cf_list(clone_state
*state
, struct exec_list
*dst
,
554 const struct exec_list
*list
);
557 clone_if(clone_state
*state
, struct exec_list
*cf_list
, const nir_if
*i
)
559 nir_if
*ni
= nir_if_create(state
->ns
);
560 ni
->control
= i
->control
;
562 __clone_src(state
, ni
, &ni
->condition
, &i
->condition
);
564 nir_cf_node_insert_end(cf_list
, &ni
->cf_node
);
566 clone_cf_list(state
, &ni
->then_list
, &i
->then_list
);
567 clone_cf_list(state
, &ni
->else_list
, &i
->else_list
);
573 clone_loop(clone_state
*state
, struct exec_list
*cf_list
, const nir_loop
*loop
)
575 nir_loop
*nloop
= nir_loop_create(state
->ns
);
576 nloop
->control
= loop
->control
;
577 nloop
->partially_unrolled
= loop
->partially_unrolled
;
579 nir_cf_node_insert_end(cf_list
, &nloop
->cf_node
);
581 clone_cf_list(state
, &nloop
->body
, &loop
->body
);
586 /* clone list of nir_cf_node: */
588 clone_cf_list(clone_state
*state
, struct exec_list
*dst
,
589 const struct exec_list
*list
)
591 foreach_list_typed(nir_cf_node
, cf
, node
, list
) {
593 case nir_cf_node_block
:
594 clone_block(state
, dst
, nir_cf_node_as_block(cf
));
597 clone_if(state
, dst
, nir_cf_node_as_if(cf
));
599 case nir_cf_node_loop
:
600 clone_loop(state
, dst
, nir_cf_node_as_loop(cf
));
603 unreachable("bad cf type");
608 /* After we've cloned almost everything, we have to walk the list of phi
609 * sources and fix them up. Thanks to loops, the block and SSA value for a
610 * phi source may not be defined when we first encounter it. Instead, we
611 * add it to the phi_srcs list and we fix it up here.
614 fixup_phi_srcs(clone_state
*state
)
616 list_for_each_entry_safe(nir_phi_src
, src
, &state
->phi_srcs
, src
.use_link
) {
617 src
->pred
= remap_local(state
, src
->pred
);
619 /* Remove from this list */
620 list_del(&src
->src
.use_link
);
622 if (src
->src
.is_ssa
) {
623 src
->src
.ssa
= remap_local(state
, src
->src
.ssa
);
624 list_addtail(&src
->src
.use_link
, &src
->src
.ssa
->uses
);
626 src
->src
.reg
.reg
= remap_reg(state
, src
->src
.reg
.reg
);
627 list_addtail(&src
->src
.use_link
, &src
->src
.reg
.reg
->uses
);
630 assert(list_is_empty(&state
->phi_srcs
));
634 nir_cf_list_clone(nir_cf_list
*dst
, nir_cf_list
*src
, nir_cf_node
*parent
,
635 struct hash_table
*remap_table
)
637 exec_list_make_empty(&dst
->list
);
638 dst
->impl
= src
->impl
;
640 if (exec_list_is_empty(&src
->list
))
644 init_clone_state(&state
, remap_table
, false, true);
646 /* We use the same shader */
647 state
.ns
= src
->impl
->function
->shader
;
649 /* The control-flow code assumes that the list of cf_nodes always starts
650 * and ends with a block. We start by adding an empty block.
652 nir_block
*nblk
= nir_block_create(state
.ns
);
653 nblk
->cf_node
.parent
= parent
;
654 exec_list_push_tail(&dst
->list
, &nblk
->cf_node
.node
);
656 clone_cf_list(&state
, &dst
->list
, &src
->list
);
658 fixup_phi_srcs(&state
);
661 free_clone_state(&state
);
664 static nir_function_impl
*
665 clone_function_impl(clone_state
*state
, const nir_function_impl
*fi
)
667 nir_function_impl
*nfi
= nir_function_impl_create_bare(state
->ns
);
669 clone_var_list(state
, &nfi
->locals
, &fi
->locals
);
670 clone_reg_list(state
, &nfi
->registers
, &fi
->registers
);
671 nfi
->reg_alloc
= fi
->reg_alloc
;
673 assert(list_is_empty(&state
->phi_srcs
));
675 clone_cf_list(state
, &nfi
->body
, &fi
->body
);
677 fixup_phi_srcs(state
);
679 /* All metadata is invalidated in the cloning process */
680 nfi
->valid_metadata
= 0;
686 nir_function_impl_clone(nir_shader
*shader
, const nir_function_impl
*fi
)
689 init_clone_state(&state
, NULL
, false, false);
693 nir_function_impl
*nfi
= clone_function_impl(&state
, fi
);
695 free_clone_state(&state
);
700 static nir_function
*
701 clone_function(clone_state
*state
, const nir_function
*fxn
, nir_shader
*ns
)
703 assert(ns
== state
->ns
);
704 nir_function
*nfxn
= nir_function_create(ns
, fxn
->name
);
706 /* Needed for call instructions */
707 add_remap(state
, nfxn
, fxn
);
709 nfxn
->num_params
= fxn
->num_params
;
710 if (fxn
->num_params
) {
711 nfxn
->params
= ralloc_array(state
->ns
, nir_parameter
, fxn
->num_params
);
712 memcpy(nfxn
->params
, fxn
->params
, sizeof(nir_parameter
) * fxn
->num_params
);
714 nfxn
->is_entrypoint
= fxn
->is_entrypoint
;
716 /* At first glance, it looks like we should clone the function_impl here.
717 * However, call instructions need to be able to reference at least the
718 * function and those will get processed as we clone the function_impls.
719 * We stop here and do function_impls as a second pass.
726 nir_shader_clone(void *mem_ctx
, const nir_shader
*s
)
729 init_clone_state(&state
, NULL
, true, false);
731 nir_shader
*ns
= nir_shader_create(mem_ctx
, s
->info
.stage
, s
->options
, NULL
);
734 clone_var_list(&state
, &ns
->variables
, &s
->variables
);
736 /* Go through and clone functions */
737 foreach_list_typed(nir_function
, fxn
, node
, &s
->functions
)
738 clone_function(&state
, fxn
, ns
);
740 /* Only after all functions are cloned can we clone the actual function
741 * implementations. This is because nir_call_instrs need to reference the
742 * functions of other functions and we don't know what order the functions
743 * will have in the list.
745 nir_foreach_function(fxn
, s
) {
746 nir_function
*nfxn
= remap_global(&state
, fxn
);
747 nfxn
->impl
= clone_function_impl(&state
, fxn
->impl
);
748 nfxn
->impl
->function
= nfxn
;
752 ns
->info
.name
= ralloc_strdup(ns
, ns
->info
.name
);
754 ns
->info
.label
= ralloc_strdup(ns
, ns
->info
.label
);
756 ns
->num_inputs
= s
->num_inputs
;
757 ns
->num_uniforms
= s
->num_uniforms
;
758 ns
->num_outputs
= s
->num_outputs
;
759 ns
->num_shared
= s
->num_shared
;
760 ns
->scratch_size
= s
->scratch_size
;
762 ns
->constant_data_size
= s
->constant_data_size
;
763 if (s
->constant_data_size
> 0) {
764 ns
->constant_data
= ralloc_size(ns
, s
->constant_data_size
);
765 memcpy(ns
->constant_data
, s
->constant_data
, s
->constant_data_size
);
768 free_clone_state(&state
);
773 /** Overwrites dst and replaces its contents with src
775 * Everything ralloc parented to dst and src itself (but not its children)
778 * This should only be used by test code which needs to swap out shaders with
779 * a cloned or deserialized version.
782 nir_shader_replace(nir_shader
*dst
, nir_shader
*src
)
784 /* Delete all of dest's ralloc children */
785 void *dead_ctx
= ralloc_context(NULL
);
786 ralloc_adopt(dead_ctx
, dst
);
787 ralloc_free(dead_ctx
);
789 /* Re-parent all of src's ralloc children to dst */
790 ralloc_adopt(dst
, src
);
792 memcpy(dst
, src
, sizeof(*dst
));
794 /* We have to move all the linked lists over separately because we need the
795 * pointers in the list elements to point to the lists in dst and not src.
797 exec_list_move_nodes_to(&src
->variables
, &dst
->variables
);
799 /* Now move the functions over. This takes a tiny bit more work */
800 exec_list_move_nodes_to(&src
->functions
, &dst
->functions
);
801 nir_foreach_function(function
, dst
)
802 function
->shader
= dst
;