1/*
2 * Copyright © 2015 Red Hat
3 *
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:
10 *
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
13 * Software.
14 *
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
21 * IN THE SOFTWARE.
22 */
23
24#include "nir.h"
25#include "nir_control_flow.h"
26
27/* Secret Decoder Ring:
28 *   clone_foo():
29 *        Allocate and clone a foo.
30 *   __clone_foo():
31 *        Clone body of foo (ie. parent class, embedded struct, etc)
32 */
33
34typedef struct {
35   /* True if we are cloning an entire shader. */
36   bool global_clone;
37
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.
42    */
43   bool allow_remap_fallback;
44
45   /* maps orig ptr -> cloned ptr: */
46   struct hash_table *remap_table;
47
48   /* List of phi sources. */
49   struct list_head phi_srcs;
50
51   /* new shader object, used as memctx for just about everything else: */
52   nir_shader *ns;
53} clone_state;
54
55static void
56init_clone_state(clone_state *state, struct hash_table *remap_table,
57                 bool global, bool allow_remap_fallback)
58{
59   state->global_clone = global;
60   state->allow_remap_fallback = allow_remap_fallback;
61
62   if (remap_table) {
63      state->remap_table = remap_table;
64   } else {
65      state->remap_table = _mesa_pointer_hash_table_create(NULL);
66   }
67
68   list_inithead(&state->phi_srcs);
69}
70
71static void
72free_clone_state(clone_state *state)
73{
74   _mesa_hash_table_destroy(state->remap_table, NULL);
75}
76
77static inline void *
78_lookup_ptr(clone_state *state, const void *ptr, bool global)
79{
80   struct hash_entry *entry;
81
82   if (!ptr)
83      return NULL;
84
85   if (!state->global_clone && global)
86      return (void *)ptr;
87
88   entry = _mesa_hash_table_search(state->remap_table, ptr);
89   if (!entry) {
90      assert(state->allow_remap_fallback);
91      return (void *)ptr;
92   }
93
94   return entry->data;
95}
96
97static void
98add_remap(clone_state *state, void *nptr, const void *ptr)
99{
100   _mesa_hash_table_insert(state->remap_table, ptr, nptr);
101}
102
103static void *
104remap_local(clone_state *state, const void *ptr)
105{
106   return _lookup_ptr(state, ptr, false);
107}
108
109static void *
110remap_global(clone_state *state, const void *ptr)
111{
112   return _lookup_ptr(state, ptr, true);
113}
114
115static nir_register *
116remap_reg(clone_state *state, const nir_register *reg)
117{
118   return _lookup_ptr(state, reg, false);
119}
120
121static nir_variable *
122remap_var(clone_state *state, const nir_variable *var)
123{
124   return _lookup_ptr(state, var, nir_variable_is_global(var));
125}
126
127nir_constant *
128nir_constant_clone(const nir_constant *c, nir_variable *nvar)
129{
130   nir_constant *nc = ralloc(nvar, nir_constant);
131
132   memcpy(nc->values, c->values, sizeof(nc->values));
133   nc->num_elements = c->num_elements;
134   nc->elements = ralloc_array(nvar, nir_constant *, c->num_elements);
135   for (unsigned i = 0; i < c->num_elements; i++) {
136      nc->elements[i] = nir_constant_clone(c->elements[i], nvar);
137   }
138
139   return nc;
140}
141
142/* NOTE: for cloning nir_variables, bypass nir_variable_create to avoid
143 * having to deal with locals and globals separately:
144 */
145nir_variable *
146nir_variable_clone(const nir_variable *var, nir_shader *shader)
147{
148   nir_variable *nvar = rzalloc(shader, nir_variable);
149
150   nvar->type = var->type;
151   nvar->name = ralloc_strdup(nvar, var->name);
152   nvar->data = var->data;
153   nvar->num_state_slots = var->num_state_slots;
154   if (var->num_state_slots) {
155      nvar->state_slots = ralloc_array(nvar, nir_state_slot, var->num_state_slots);
156      memcpy(nvar->state_slots, var->state_slots,
157             var->num_state_slots * sizeof(nir_state_slot));
158   }
159   if (var->constant_initializer) {
160      nvar->constant_initializer =
161         nir_constant_clone(var->constant_initializer, nvar);
162   }
163   nvar->interface_type = var->interface_type;
164
165   nvar->num_members = var->num_members;
166   if (var->num_members) {
167      nvar->members = ralloc_array(nvar, struct nir_variable_data,
168                                   var->num_members);
169      memcpy(nvar->members, var->members,
170             var->num_members * sizeof(*var->members));
171   }
172
173   return nvar;
174}
175
176static nir_variable *
177clone_variable(clone_state *state, const nir_variable *var)
178{
179   nir_variable *nvar = nir_variable_clone(var, state->ns);
180   add_remap(state, nvar, var);
181
182   return nvar;
183}
184
185/* clone list of nir_variable: */
186static void
187clone_var_list(clone_state *state, struct exec_list *dst,
188               const struct exec_list *list)
189{
190   exec_list_make_empty(dst);
191   foreach_list_typed(nir_variable, var, node, list) {
192      nir_variable *nvar = clone_variable(state, var);
193      exec_list_push_tail(dst, &nvar->node);
194   }
195}
196
197/* NOTE: for cloning nir_registers, bypass nir_global/local_reg_create()
198 * to avoid having to deal with locals and globals separately:
199 */
200static nir_register *
201clone_register(clone_state *state, const nir_register *reg)
202{
203   nir_register *nreg = rzalloc(state->ns, nir_register);
204   add_remap(state, nreg, reg);
205
206   nreg->num_components = reg->num_components;
207   nreg->bit_size = reg->bit_size;
208   nreg->num_array_elems = reg->num_array_elems;
209   nreg->index = reg->index;
210   nreg->name = ralloc_strdup(nreg, reg->name);
211
212   /* reconstructing uses/defs/if_uses handled by nir_instr_insert() */
213   list_inithead(&nreg->uses);
214   list_inithead(&nreg->defs);
215   list_inithead(&nreg->if_uses);
216
217   return nreg;
218}
219
220/* clone list of nir_register: */
221static void
222clone_reg_list(clone_state *state, struct exec_list *dst,
223               const struct exec_list *list)
224{
225   exec_list_make_empty(dst);
226   foreach_list_typed(nir_register, reg, node, list) {
227      nir_register *nreg = clone_register(state, reg);
228      exec_list_push_tail(dst, &nreg->node);
229   }
230}
231
232static void
233__clone_src(clone_state *state, void *ninstr_or_if,
234            nir_src *nsrc, const nir_src *src)
235{
236   nsrc->is_ssa = src->is_ssa;
237   if (src->is_ssa) {
238      nsrc->ssa = remap_local(state, src->ssa);
239   } else {
240      nsrc->reg.reg = remap_reg(state, src->reg.reg);
241      if (src->reg.indirect) {
242         nsrc->reg.indirect = ralloc(ninstr_or_if, nir_src);
243         __clone_src(state, ninstr_or_if, nsrc->reg.indirect, src->reg.indirect);
244      }
245      nsrc->reg.base_offset = src->reg.base_offset;
246   }
247}
248
249static void
250__clone_dst(clone_state *state, nir_instr *ninstr,
251            nir_dest *ndst, const nir_dest *dst)
252{
253   ndst->is_ssa = dst->is_ssa;
254   if (dst->is_ssa) {
255      nir_ssa_dest_init(ninstr, ndst, dst->ssa.num_components,
256                        dst->ssa.bit_size, dst->ssa.name);
257      add_remap(state, &ndst->ssa, &dst->ssa);
258   } else {
259      ndst->reg.reg = remap_reg(state, dst->reg.reg);
260      if (dst->reg.indirect) {
261         ndst->reg.indirect = ralloc(ninstr, nir_src);
262         __clone_src(state, ninstr, ndst->reg.indirect, dst->reg.indirect);
263      }
264      ndst->reg.base_offset = dst->reg.base_offset;
265   }
266}
267
268static nir_alu_instr *
269clone_alu(clone_state *state, const nir_alu_instr *alu)
270{
271   nir_alu_instr *nalu = nir_alu_instr_create(state->ns, alu->op);
272   nalu->exact = alu->exact;
273
274   __clone_dst(state, &nalu->instr, &nalu->dest.dest, &alu->dest.dest);
275   nalu->dest.saturate = alu->dest.saturate;
276   nalu->dest.write_mask = alu->dest.write_mask;
277
278   for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
279      __clone_src(state, &nalu->instr, &nalu->src[i].src, &alu->src[i].src);
280      nalu->src[i].negate = alu->src[i].negate;
281      nalu->src[i].abs = alu->src[i].abs;
282      memcpy(nalu->src[i].swizzle, alu->src[i].swizzle,
283             sizeof(nalu->src[i].swizzle));
284   }
285
286   return nalu;
287}
288
289static nir_deref_instr *
290clone_deref_instr(clone_state *state, const nir_deref_instr *deref)
291{
292   nir_deref_instr *nderef =
293      nir_deref_instr_create(state->ns, deref->deref_type);
294
295   __clone_dst(state, &nderef->instr, &nderef->dest, &deref->dest);
296
297   nderef->mode = deref->mode;
298   nderef->type = deref->type;
299
300   if (deref->deref_type == nir_deref_type_var) {
301      nderef->var = remap_var(state, deref->var);
302      return nderef;
303   }
304
305   __clone_src(state, &nderef->instr, &nderef->parent, &deref->parent);
306
307   switch (deref->deref_type) {
308   case nir_deref_type_struct:
309      nderef->strct.index = deref->strct.index;
310      break;
311
312   case nir_deref_type_array:
313   case nir_deref_type_ptr_as_array:
314      __clone_src(state, &nderef->instr,
315                  &nderef->arr.index, &deref->arr.index);
316      break;
317
318   case nir_deref_type_array_wildcard:
319      /* Nothing to do */
320      break;
321
322   case nir_deref_type_cast:
323      nderef->cast.ptr_stride = deref->cast.ptr_stride;
324      break;
325
326   default:
327      unreachable("Invalid instruction deref type");
328   }
329
330   return nderef;
331}
332
333static nir_intrinsic_instr *
334clone_intrinsic(clone_state *state, const nir_intrinsic_instr *itr)
335{
336   nir_intrinsic_instr *nitr =
337      nir_intrinsic_instr_create(state->ns, itr->intrinsic);
338
339   unsigned num_srcs = nir_intrinsic_infos[itr->intrinsic].num_srcs;
340
341   if (nir_intrinsic_infos[itr->intrinsic].has_dest)
342      __clone_dst(state, &nitr->instr, &nitr->dest, &itr->dest);
343
344   nitr->num_components = itr->num_components;
345   memcpy(nitr->const_index, itr->const_index, sizeof(nitr->const_index));
346
347   for (unsigned i = 0; i < num_srcs; i++)
348      __clone_src(state, &nitr->instr, &nitr->src[i], &itr->src[i]);
349
350   return nitr;
351}
352
353static nir_load_const_instr *
354clone_load_const(clone_state *state, const nir_load_const_instr *lc)
355{
356   nir_load_const_instr *nlc =
357      nir_load_const_instr_create(state->ns, lc->def.num_components,
358                                  lc->def.bit_size);
359
360   memcpy(&nlc->value, &lc->value, sizeof(*nlc->value) * lc->def.num_components);
361
362   add_remap(state, &nlc->def, &lc->def);
363
364   return nlc;
365}
366
367static nir_ssa_undef_instr *
368clone_ssa_undef(clone_state *state, const nir_ssa_undef_instr *sa)
369{
370   nir_ssa_undef_instr *nsa =
371      nir_ssa_undef_instr_create(state->ns, sa->def.num_components,
372                                 sa->def.bit_size);
373
374   add_remap(state, &nsa->def, &sa->def);
375
376   return nsa;
377}
378
379static nir_tex_instr *
380clone_tex(clone_state *state, const nir_tex_instr *tex)
381{
382   nir_tex_instr *ntex = nir_tex_instr_create(state->ns, tex->num_srcs);
383
384   ntex->sampler_dim = tex->sampler_dim;
385   ntex->dest_type = tex->dest_type;
386   ntex->op = tex->op;
387   __clone_dst(state, &ntex->instr, &ntex->dest, &tex->dest);
388   for (unsigned i = 0; i < ntex->num_srcs; i++) {
389      ntex->src[i].src_type = tex->src[i].src_type;
390      __clone_src(state, &ntex->instr, &ntex->src[i].src, &tex->src[i].src);
391   }
392   ntex->coord_components = tex->coord_components;
393   ntex->is_array = tex->is_array;
394   ntex->is_shadow = tex->is_shadow;
395   ntex->is_new_style_shadow = tex->is_new_style_shadow;
396   ntex->component = tex->component;
397   memcpy(ntex->tg4_offsets, tex->tg4_offsets, sizeof(tex->tg4_offsets));
398
399   ntex->texture_index = tex->texture_index;
400   ntex->texture_array_size = tex->texture_array_size;
401   ntex->sampler_index = tex->sampler_index;
402
403   return ntex;
404}
405
406static nir_phi_instr *
407clone_phi(clone_state *state, const nir_phi_instr *phi, nir_block *nblk)
408{
409   nir_phi_instr *nphi = nir_phi_instr_create(state->ns);
410
411   __clone_dst(state, &nphi->instr, &nphi->dest, &phi->dest);
412
413   /* Cloning a phi node is a bit different from other instructions.  The
414    * sources of phi instructions are the only time where we can use an SSA
415    * def before it is defined.  In order to handle this, we just copy over
416    * the sources from the old phi instruction directly and then fix them up
417    * in a second pass once all the instrutions in the function have been
418    * properly cloned.
419    *
420    * In order to ensure that the copied sources (which are the same as the
421    * old phi instruction's sources for now) don't get inserted into the old
422    * shader's use-def lists, we have to add the phi instruction *before* we
423    * set up its sources.
424    */
425   nir_instr_insert_after_block(nblk, &nphi->instr);
426
427   foreach_list_typed(nir_phi_src, src, node, &phi->srcs) {
428      nir_phi_src *nsrc = ralloc(nphi, nir_phi_src);
429
430      /* Just copy the old source for now. */
431      memcpy(nsrc, src, sizeof(*src));
432
433      /* Since we're not letting nir_insert_instr handle use/def stuff for us,
434       * we have to set the parent_instr manually.  It doesn't really matter
435       * when we do it, so we might as well do it here.
436       */
437      nsrc->src.parent_instr = &nphi->instr;
438
439      /* Stash it in the list of phi sources.  We'll walk this list and fix up
440       * sources at the very end of clone_function_impl.
441       */
442      list_add(&nsrc->src.use_link, &state->phi_srcs);
443
444      exec_list_push_tail(&nphi->srcs, &nsrc->node);
445   }
446
447   return nphi;
448}
449
450static nir_jump_instr *
451clone_jump(clone_state *state, const nir_jump_instr *jmp)
452{
453   nir_jump_instr *njmp = nir_jump_instr_create(state->ns, jmp->type);
454
455   return njmp;
456}
457
458static nir_call_instr *
459clone_call(clone_state *state, const nir_call_instr *call)
460{
461   nir_function *ncallee = remap_global(state, call->callee);
462   nir_call_instr *ncall = nir_call_instr_create(state->ns, ncallee);
463
464   for (unsigned i = 0; i < ncall->num_params; i++)
465      __clone_src(state, ncall, &ncall->params[i], &call->params[i]);
466
467   return ncall;
468}
469
470static nir_instr *
471clone_instr(clone_state *state, const nir_instr *instr)
472{
473   switch (instr->type) {
474   case nir_instr_type_alu:
475      return &clone_alu(state, nir_instr_as_alu(instr))->instr;
476   case nir_instr_type_deref:
477      return &clone_deref_instr(state, nir_instr_as_deref(instr))->instr;
478   case nir_instr_type_intrinsic:
479      return &clone_intrinsic(state, nir_instr_as_intrinsic(instr))->instr;
480   case nir_instr_type_load_const:
481      return &clone_load_const(state, nir_instr_as_load_const(instr))->instr;
482   case nir_instr_type_ssa_undef:
483      return &clone_ssa_undef(state, nir_instr_as_ssa_undef(instr))->instr;
484   case nir_instr_type_tex:
485      return &clone_tex(state, nir_instr_as_tex(instr))->instr;
486   case nir_instr_type_phi:
487      unreachable("Cannot clone phis with clone_instr");
488   case nir_instr_type_jump:
489      return &clone_jump(state, nir_instr_as_jump(instr))->instr;
490   case nir_instr_type_call:
491      return &clone_call(state, nir_instr_as_call(instr))->instr;
492   case nir_instr_type_parallel_copy:
493      unreachable("Cannot clone parallel copies");
494   default:
495      unreachable("bad instr type");
496      return NULL;
497   }
498}
499
500static nir_block *
501clone_block(clone_state *state, struct exec_list *cf_list, const nir_block *blk)
502{
503   /* Don't actually create a new block.  Just use the one from the tail of
504    * the list.  NIR guarantees that the tail of the list is a block and that
505    * no two blocks are side-by-side in the IR;  It should be empty.
506    */
507   nir_block *nblk =
508      exec_node_data(nir_block, exec_list_get_tail(cf_list), cf_node.node);
509   assert(nblk->cf_node.type == nir_cf_node_block);
510   assert(exec_list_is_empty(&nblk->instr_list));
511
512   /* We need this for phi sources */
513   add_remap(state, nblk, blk);
514
515   nir_foreach_instr(instr, blk) {
516      if (instr->type == nir_instr_type_phi) {
517         /* Phi instructions are a bit of a special case when cloning because
518          * we don't want inserting the instruction to automatically handle
519          * use/defs for us.  Instead, we need to wait until all the
520          * blocks/instructions are in so that we can set their sources up.
521          */
522         clone_phi(state, nir_instr_as_phi(instr), nblk);
523      } else {
524         nir_instr *ninstr = clone_instr(state, instr);
525         nir_instr_insert_after_block(nblk, ninstr);
526      }
527   }
528
529   return nblk;
530}
531
532static void
533clone_cf_list(clone_state *state, struct exec_list *dst,
534              const struct exec_list *list);
535
536static nir_if *
537clone_if(clone_state *state, struct exec_list *cf_list, const nir_if *i)
538{
539   nir_if *ni = nir_if_create(state->ns);
540   ni->control = i->control;
541
542   __clone_src(state, ni, &ni->condition, &i->condition);
543
544   nir_cf_node_insert_end(cf_list, &ni->cf_node);
545
546   clone_cf_list(state, &ni->then_list, &i->then_list);
547   clone_cf_list(state, &ni->else_list, &i->else_list);
548
549   return ni;
550}
551
552static nir_loop *
553clone_loop(clone_state *state, struct exec_list *cf_list, const nir_loop *loop)
554{
555   nir_loop *nloop = nir_loop_create(state->ns);
556   nloop->control = loop->control;
557   nloop->partially_unrolled = loop->partially_unrolled;
558
559   nir_cf_node_insert_end(cf_list, &nloop->cf_node);
560
561   clone_cf_list(state, &nloop->body, &loop->body);
562
563   return nloop;
564}
565
566/* clone list of nir_cf_node: */
567static void
568clone_cf_list(clone_state *state, struct exec_list *dst,
569              const struct exec_list *list)
570{
571   foreach_list_typed(nir_cf_node, cf, node, list) {
572      switch (cf->type) {
573      case nir_cf_node_block:
574         clone_block(state, dst, nir_cf_node_as_block(cf));
575         break;
576      case nir_cf_node_if:
577         clone_if(state, dst, nir_cf_node_as_if(cf));
578         break;
579      case nir_cf_node_loop:
580         clone_loop(state, dst, nir_cf_node_as_loop(cf));
581         break;
582      default:
583         unreachable("bad cf type");
584      }
585   }
586}
587
588/* After we've cloned almost everything, we have to walk the list of phi
589 * sources and fix them up.  Thanks to loops, the block and SSA value for a
590 * phi source may not be defined when we first encounter it.  Instead, we
591 * add it to the phi_srcs list and we fix it up here.
592 */
593static void
594fixup_phi_srcs(clone_state *state)
595{
596   list_for_each_entry_safe(nir_phi_src, src, &state->phi_srcs, src.use_link) {
597      src->pred = remap_local(state, src->pred);
598
599      /* Remove from this list */
600      list_del(&src->src.use_link);
601
602      if (src->src.is_ssa) {
603         src->src.ssa = remap_local(state, src->src.ssa);
604         list_addtail(&src->src.use_link, &src->src.ssa->uses);
605      } else {
606         src->src.reg.reg = remap_reg(state, src->src.reg.reg);
607         list_addtail(&src->src.use_link, &src->src.reg.reg->uses);
608      }
609   }
610   assert(list_empty(&state->phi_srcs));
611}
612
613void
614nir_cf_list_clone(nir_cf_list *dst, nir_cf_list *src, nir_cf_node *parent,
615                  struct hash_table *remap_table)
616{
617   exec_list_make_empty(&dst->list);
618   dst->impl = src->impl;
619
620   if (exec_list_is_empty(&src->list))
621      return;
622
623   clone_state state;
624   init_clone_state(&state, remap_table, false, true);
625
626   /* We use the same shader */
627   state.ns = src->impl->function->shader;
628
629   /* The control-flow code assumes that the list of cf_nodes always starts
630    * and ends with a block.  We start by adding an empty block.
631    */
632   nir_block *nblk = nir_block_create(state.ns);
633   nblk->cf_node.parent = parent;
634   exec_list_push_tail(&dst->list, &nblk->cf_node.node);
635
636   clone_cf_list(&state, &dst->list, &src->list);
637
638   fixup_phi_srcs(&state);
639}
640
641static nir_function_impl *
642clone_function_impl(clone_state *state, const nir_function_impl *fi)
643{
644   nir_function_impl *nfi = nir_function_impl_create_bare(state->ns);
645
646   clone_var_list(state, &nfi->locals, &fi->locals);
647   clone_reg_list(state, &nfi->registers, &fi->registers);
648   nfi->reg_alloc = fi->reg_alloc;
649
650   assert(list_empty(&state->phi_srcs));
651
652   clone_cf_list(state, &nfi->body, &fi->body);
653
654   fixup_phi_srcs(state);
655
656   /* All metadata is invalidated in the cloning process */
657   nfi->valid_metadata = 0;
658
659   return nfi;
660}
661
662nir_function_impl *
663nir_function_impl_clone(nir_shader *shader, const nir_function_impl *fi)
664{
665   clone_state state;
666   init_clone_state(&state, NULL, false, false);
667
668   state.ns = shader;
669
670   nir_function_impl *nfi = clone_function_impl(&state, fi);
671
672   free_clone_state(&state);
673
674   return nfi;
675}
676
677static nir_function *
678clone_function(clone_state *state, const nir_function *fxn, nir_shader *ns)
679{
680   assert(ns == state->ns);
681   nir_function *nfxn = nir_function_create(ns, fxn->name);
682
683   /* Needed for call instructions */
684   add_remap(state, nfxn, fxn);
685
686   nfxn->num_params = fxn->num_params;
687   nfxn->params = ralloc_array(state->ns, nir_parameter, fxn->num_params);
688   memcpy(nfxn->params, fxn->params, sizeof(nir_parameter) * fxn->num_params);
689   nfxn->is_entrypoint = fxn->is_entrypoint;
690
691   /* At first glance, it looks like we should clone the function_impl here.
692    * However, call instructions need to be able to reference at least the
693    * function and those will get processed as we clone the function_impls.
694    * We stop here and do function_impls as a second pass.
695    */
696
697   return nfxn;
698}
699
700nir_shader *
701nir_shader_clone(void *mem_ctx, const nir_shader *s)
702{
703   clone_state state;
704   init_clone_state(&state, NULL, true, false);
705
706   nir_shader *ns = nir_shader_create(mem_ctx, s->info.stage, s->options, NULL);
707   state.ns = ns;
708
709   clone_var_list(&state, &ns->uniforms, &s->uniforms);
710   clone_var_list(&state, &ns->inputs,   &s->inputs);
711   clone_var_list(&state, &ns->outputs,  &s->outputs);
712   clone_var_list(&state, &ns->shared,   &s->shared);
713   clone_var_list(&state, &ns->globals,  &s->globals);
714   clone_var_list(&state, &ns->system_values, &s->system_values);
715
716   /* Go through and clone functions */
717   foreach_list_typed(nir_function, fxn, node, &s->functions)
718      clone_function(&state, fxn, ns);
719
720   /* Only after all functions are cloned can we clone the actual function
721    * implementations.  This is because nir_call_instrs need to reference the
722    * functions of other functions and we don't know what order the functions
723    * will have in the list.
724    */
725   nir_foreach_function(fxn, s) {
726      nir_function *nfxn = remap_global(&state, fxn);
727      nfxn->impl = clone_function_impl(&state, fxn->impl);
728      nfxn->impl->function = nfxn;
729   }
730
731   ns->info = s->info;
732   ns->info.name = ralloc_strdup(ns, ns->info.name);
733   if (ns->info.label)
734      ns->info.label = ralloc_strdup(ns, ns->info.label);
735
736   ns->num_inputs = s->num_inputs;
737   ns->num_uniforms = s->num_uniforms;
738   ns->num_outputs = s->num_outputs;
739   ns->num_shared = s->num_shared;
740   ns->scratch_size = s->scratch_size;
741
742   ns->constant_data_size = s->constant_data_size;
743   if (s->constant_data_size > 0) {
744      ns->constant_data = ralloc_size(ns, s->constant_data_size);
745      memcpy(ns->constant_data, s->constant_data, s->constant_data_size);
746   }
747
748   free_clone_state(&state);
749
750   return ns;
751}
752