src/compiler/nir/nir_clone.c

   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
  34 typedef 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
  55 static void
  56 init_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
  71 static void
  72 free_clone_state(clone_state *state)
  73 {
  74    _mesa_hash_table_destroy(state->remap_table, NULL);
  75 }
  76
  77 static 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
  97 static void
  98 add_remap(clone_state *state, void *nptr, const void *ptr)
  99 {
 100    _mesa_hash_table_insert(state->remap_table, ptr, nptr);
 101 }
 102
 103 static void *
 104 remap_local(clone_state *state, const void *ptr)
 105 {
 106    return _lookup_ptr(state, ptr, false);
 107 }
 108
 109 static void *
 110 remap_global(clone_state *state, const void *ptr)
 111 {
 112    return _lookup_ptr(state, ptr, true);
 113 }
 114
 115 static nir_register *
 116 remap_reg(clone_state *state, const nir_register *reg)
 117 {
 118    return _lookup_ptr(state, reg, false);
 119 }
 120
 121 static nir_variable *
 122 remap_var(clone_state *state, const nir_variable *var)
 123 {
 124    return _lookup_ptr(state, var, nir_variable_is_global(var));
 125 }
 126
 127 nir_constant *
 128 nir_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  */
 145 nir_variable *
 146 nir_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
 176 static nir_variable *
 177 clone_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: */
 186 static void
 187 clone_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  */
 200 static nir_register *
 201 clone_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: */
 221 static void
 222 clone_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
 232 static 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
 249 static 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
 268 nir_alu_instr *
 269 nir_alu_instr_clone(nir_shader *shader, const nir_alu_instr *orig)
 270 {
 271    nir_alu_instr *clone = nir_alu_instr_create(shader, orig->op);
 272
 273    clone->exact = orig->exact;
 274
 275    for (unsigned i = 0; i < nir_op_infos[orig->op].num_inputs; i++)
 276       nir_alu_src_copy(&clone->src[i], &orig->src[i], clone);
 277
 278    nir_ssa_dest_init(&clone->instr,
 279                      &clone->dest.dest,
 280                      orig->dest.dest.ssa.num_components,
 281                      orig->dest.dest.ssa.bit_size,
 282                      orig->dest.dest.ssa.name);
 283    clone->dest.write_mask = orig->dest.write_mask;
 284
 285    return clone;
 286 }
 287
 288 static nir_alu_instr *
 289 clone_alu(clone_state *state, const nir_alu_instr *alu)
 290 {
 291    nir_alu_instr *nalu = nir_alu_instr_create(state->ns, alu->op);
 292    nalu->exact = alu->exact;
 293    nalu->no_signed_wrap = alu->no_signed_wrap;
 294    nalu->no_unsigned_wrap = alu->no_unsigned_wrap;
 295
 296    __clone_dst(state, &nalu->instr, &nalu->dest.dest, &alu->dest.dest);
 297    nalu->dest.saturate = alu->dest.saturate;
 298    nalu->dest.write_mask = alu->dest.write_mask;
 299
 300    for (unsigned i = 0; i < nir_op_infos[alu->op].num_inputs; i++) {
 301       __clone_src(state, &nalu->instr, &nalu->src[i].src, &alu->src[i].src);
 302       nalu->src[i].negate = alu->src[i].negate;
 303       nalu->src[i].abs = alu->src[i].abs;
 304       memcpy(nalu->src[i].swizzle, alu->src[i].swizzle,
 305              sizeof(nalu->src[i].swizzle));
 306    }
 307
 308    return nalu;
 309 }
 310
 311 static nir_deref_instr *
 312 clone_deref_instr(clone_state *state, const nir_deref_instr *deref)
 313 {
 314    nir_deref_instr *nderef =
 315       nir_deref_instr_create(state->ns, deref->deref_type);
 316
 317    __clone_dst(state, &nderef->instr, &nderef->dest, &deref->dest);
 318
 319    nderef->mode = deref->mode;
 320    nderef->type = deref->type;
 321
 322    if (deref->deref_type == nir_deref_type_var) {
 323       nderef->var = remap_var(state, deref->var);
 324       return nderef;
 325    }
 326
 327    __clone_src(state, &nderef->instr, &nderef->parent, &deref->parent);
 328
 329    switch (deref->deref_type) {
 330    case nir_deref_type_struct:
 331       nderef->strct.index = deref->strct.index;
 332       break;
 333
 334    case nir_deref_type_array:
 335    case nir_deref_type_ptr_as_array:
 336       __clone_src(state, &nderef->instr,
 337                   &nderef->arr.index, &deref->arr.index);
 338       break;
 339
 340    case nir_deref_type_array_wildcard:
 341       /* Nothing to do */
 342       break;
 343
 344    case nir_deref_type_cast:
 345       nderef->cast.ptr_stride = deref->cast.ptr_stride;
 346       break;
 347
 348    default:
 349       unreachable("Invalid instruction deref type");
 350    }
 351
 352    return nderef;
 353 }
 354
 355 static nir_intrinsic_instr *
 356 clone_intrinsic(clone_state *state, const nir_intrinsic_instr *itr)
 357 {
 358    nir_intrinsic_instr *nitr =
 359       nir_intrinsic_instr_create(state->ns, itr->intrinsic);
 360
 361    unsigned num_srcs = nir_intrinsic_infos[itr->intrinsic].num_srcs;
 362
 363    if (nir_intrinsic_infos[itr->intrinsic].has_dest)
 364       __clone_dst(state, &nitr->instr, &nitr->dest, &itr->dest);
 365
 366    nitr->num_components = itr->num_components;
 367    memcpy(nitr->const_index, itr->const_index, sizeof(nitr->const_index));
 368
 369    for (unsigned i = 0; i < num_srcs; i++)
 370       __clone_src(state, &nitr->instr, &nitr->src[i], &itr->src[i]);
 371
 372    return nitr;
 373 }
 374
 375 static nir_load_const_instr *
 376 clone_load_const(clone_state *state, const nir_load_const_instr *lc)
 377 {
 378    nir_load_const_instr *nlc =
 379       nir_load_const_instr_create(state->ns, lc->def.num_components,
 380                                   lc->def.bit_size);
 381
 382    memcpy(&nlc->value, &lc->value, sizeof(*nlc->value) * lc->def.num_components);
 383
 384    add_remap(state, &nlc->def, &lc->def);
 385
 386    return nlc;
 387 }
 388
 389 static nir_ssa_undef_instr *
 390 clone_ssa_undef(clone_state *state, const nir_ssa_undef_instr *sa)
 391 {
 392    nir_ssa_undef_instr *nsa =
 393       nir_ssa_undef_instr_create(state->ns, sa->def.num_components,
 394                                  sa->def.bit_size);
 395
 396    add_remap(state, &nsa->def, &sa->def);
 397
 398    return nsa;
 399 }
 400
 401 static nir_tex_instr *
 402 clone_tex(clone_state *state, const nir_tex_instr *tex)
 403 {
 404    nir_tex_instr *ntex = nir_tex_instr_create(state->ns, tex->num_srcs);
 405
 406    ntex->sampler_dim = tex->sampler_dim;
 407    ntex->dest_type = tex->dest_type;
 408    ntex->op = tex->op;
 409    __clone_dst(state, &ntex->instr, &ntex->dest, &tex->dest);
 410    for (unsigned i = 0; i < ntex->num_srcs; i++) {
 411       ntex->src[i].src_type = tex->src[i].src_type;
 412       __clone_src(state, &ntex->instr, &ntex->src[i].src, &tex->src[i].src);
 413    }
 414    ntex->coord_components = tex->coord_components;
 415    ntex->is_array = tex->is_array;
 416    ntex->is_shadow = tex->is_shadow;
 417    ntex->is_new_style_shadow = tex->is_new_style_shadow;
 418    ntex->component = tex->component;
 419    memcpy(ntex->tg4_offsets, tex->tg4_offsets, sizeof(tex->tg4_offsets));
 420
 421    ntex->texture_index = tex->texture_index;
 422    ntex->sampler_index = tex->sampler_index;
 423
 424    ntex->texture_non_uniform = tex->texture_non_uniform;
 425    ntex->sampler_non_uniform = tex->sampler_non_uniform;
 426
 427    return ntex;
 428 }
 429
 430 static nir_phi_instr *
 431 clone_phi(clone_state *state, const nir_phi_instr *phi, nir_block *nblk)
 432 {
 433    nir_phi_instr *nphi = nir_phi_instr_create(state->ns);
 434
 435    __clone_dst(state, &nphi->instr, &nphi->dest, &phi->dest);
 436
 437    /* Cloning a phi node is a bit different from other instructions.  The
 438     * sources of phi instructions are the only time where we can use an SSA
 439     * def before it is defined.  In order to handle this, we just copy over
 440     * the sources from the old phi instruction directly and then fix them up
 441     * in a second pass once all the instrutions in the function have been
 442     * properly cloned.
 443     *
 444     * In order to ensure that the copied sources (which are the same as the
 445     * old phi instruction's sources for now) don't get inserted into the old
 446     * shader's use-def lists, we have to add the phi instruction *before* we
 447     * set up its sources.
 448     */
 449    nir_instr_insert_after_block(nblk, &nphi->instr);
 450
 451    foreach_list_typed(nir_phi_src, src, node, &phi->srcs) {
 452       nir_phi_src *nsrc = ralloc(nphi, nir_phi_src);
 453
 454       /* Just copy the old source for now. */
 455       memcpy(nsrc, src, sizeof(*src));
 456
 457       /* Since we're not letting nir_insert_instr handle use/def stuff for us,
 458        * we have to set the parent_instr manually.  It doesn't really matter
 459        * when we do it, so we might as well do it here.
 460        */
 461       nsrc->src.parent_instr = &nphi->instr;
 462
 463       /* Stash it in the list of phi sources.  We'll walk this list and fix up
 464        * sources at the very end of clone_function_impl.
 465        */
 466       list_add(&nsrc->src.use_link, &state->phi_srcs);
 467
 468       exec_list_push_tail(&nphi->srcs, &nsrc->node);
 469    }
 470
 471    return nphi;
 472 }
 473
 474 static nir_jump_instr *
 475 clone_jump(clone_state *state, const nir_jump_instr *jmp)
 476 {
 477    nir_jump_instr *njmp = nir_jump_instr_create(state->ns, jmp->type);
 478
 479    return njmp;
 480 }
 481
 482 static nir_call_instr *
 483 clone_call(clone_state *state, const nir_call_instr *call)
 484 {
 485    nir_function *ncallee = remap_global(state, call->callee);
 486    nir_call_instr *ncall = nir_call_instr_create(state->ns, ncallee);
 487
 488    for (unsigned i = 0; i < ncall->num_params; i++)
 489       __clone_src(state, ncall, &ncall->params[i], &call->params[i]);
 490
 491    return ncall;
 492 }
 493
 494 static nir_instr *
 495 clone_instr(clone_state *state, const nir_instr *instr)
 496 {
 497    switch (instr->type) {
 498    case nir_instr_type_alu:
 499       return &clone_alu(state, nir_instr_as_alu(instr))->instr;
 500    case nir_instr_type_deref:
 501       return &clone_deref_instr(state, nir_instr_as_deref(instr))->instr;
 502    case nir_instr_type_intrinsic:
 503       return &clone_intrinsic(state, nir_instr_as_intrinsic(instr))->instr;
 504    case nir_instr_type_load_const:
 505       return &clone_load_const(state, nir_instr_as_load_const(instr))->instr;
 506    case nir_instr_type_ssa_undef:
 507       return &clone_ssa_undef(state, nir_instr_as_ssa_undef(instr))->instr;
 508    case nir_instr_type_tex:
 509       return &clone_tex(state, nir_instr_as_tex(instr))->instr;
 510    case nir_instr_type_phi:
 511       unreachable("Cannot clone phis with clone_instr");
 512    case nir_instr_type_jump:
 513       return &clone_jump(state, nir_instr_as_jump(instr))->instr;
 514    case nir_instr_type_call:
 515       return &clone_call(state, nir_instr_as_call(instr))->instr;
 516    case nir_instr_type_parallel_copy:
 517       unreachable("Cannot clone parallel copies");
 518    default:
 519       unreachable("bad instr type");
 520       return NULL;
 521    }
 522 }
 523
 524 static nir_block *
 525 clone_block(clone_state *state, struct exec_list *cf_list, const nir_block *blk)
 526 {
 527    /* Don't actually create a new block.  Just use the one from the tail of
 528     * the list.  NIR guarantees that the tail of the list is a block and that
 529     * no two blocks are side-by-side in the IR;  It should be empty.
 530     */
 531    nir_block *nblk =
 532       exec_node_data(nir_block, exec_list_get_tail(cf_list), cf_node.node);
 533    assert(nblk->cf_node.type == nir_cf_node_block);
 534    assert(exec_list_is_empty(&nblk->instr_list));
 535
 536    /* We need this for phi sources */
 537    add_remap(state, nblk, blk);
 538
 539    nir_foreach_instr(instr, blk) {
 540       if (instr->type == nir_instr_type_phi) {
 541          /* Phi instructions are a bit of a special case when cloning because
 542           * we don't want inserting the instruction to automatically handle
 543           * use/defs for us.  Instead, we need to wait until all the
 544           * blocks/instructions are in so that we can set their sources up.
 545           */
 546          clone_phi(state, nir_instr_as_phi(instr), nblk);
 547       } else {
 548          nir_instr *ninstr = clone_instr(state, instr);
 549          nir_instr_insert_after_block(nblk, ninstr);
 550       }
 551    }
 552
 553    return nblk;
 554 }
 555
 556 static void
 557 clone_cf_list(clone_state *state, struct exec_list *dst,
 558               const struct exec_list *list);
 559
 560 static nir_if *
 561 clone_if(clone_state *state, struct exec_list *cf_list, const nir_if *i)
 562 {
 563    nir_if *ni = nir_if_create(state->ns);
 564    ni->control = i->control;
 565
 566    __clone_src(state, ni, &ni->condition, &i->condition);
 567
 568    nir_cf_node_insert_end(cf_list, &ni->cf_node);
 569
 570    clone_cf_list(state, &ni->then_list, &i->then_list);
 571    clone_cf_list(state, &ni->else_list, &i->else_list);
 572
 573    return ni;
 574 }
 575
 576 static nir_loop *
 577 clone_loop(clone_state *state, struct exec_list *cf_list, const nir_loop *loop)
 578 {
 579    nir_loop *nloop = nir_loop_create(state->ns);
 580    nloop->control = loop->control;
 581    nloop->partially_unrolled = loop->partially_unrolled;
 582
 583    nir_cf_node_insert_end(cf_list, &nloop->cf_node);
 584
 585    clone_cf_list(state, &nloop->body, &loop->body);
 586
 587    return nloop;
 588 }
 589
 590 /* clone list of nir_cf_node: */
 591 static void
 592 clone_cf_list(clone_state *state, struct exec_list *dst,
 593               const struct exec_list *list)
 594 {
 595    foreach_list_typed(nir_cf_node, cf, node, list) {
 596       switch (cf->type) {
 597       case nir_cf_node_block:
 598          clone_block(state, dst, nir_cf_node_as_block(cf));
 599          break;
 600       case nir_cf_node_if:
 601          clone_if(state, dst, nir_cf_node_as_if(cf));
 602          break;
 603       case nir_cf_node_loop:
 604          clone_loop(state, dst, nir_cf_node_as_loop(cf));
 605          break;
 606       default:
 607          unreachable("bad cf type");
 608       }
 609    }
 610 }
 611
 612 /* After we've cloned almost everything, we have to walk the list of phi
 613  * sources and fix them up.  Thanks to loops, the block and SSA value for a
 614  * phi source may not be defined when we first encounter it.  Instead, we
 615  * add it to the phi_srcs list and we fix it up here.
 616  */
 617 static void
 618 fixup_phi_srcs(clone_state *state)
 619 {
 620    list_for_each_entry_safe(nir_phi_src, src, &state->phi_srcs, src.use_link) {
 621       src->pred = remap_local(state, src->pred);
 622
 623       /* Remove from this list */
 624       list_del(&src->src.use_link);
 625
 626       if (src->src.is_ssa) {
 627          src->src.ssa = remap_local(state, src->src.ssa);
 628          list_addtail(&src->src.use_link, &src->src.ssa->uses);
 629       } else {
 630          src->src.reg.reg = remap_reg(state, src->src.reg.reg);
 631          list_addtail(&src->src.use_link, &src->src.reg.reg->uses);
 632       }
 633    }
 634    assert(list_is_empty(&state->phi_srcs));
 635 }
 636
 637 void
 638 nir_cf_list_clone(nir_cf_list *dst, nir_cf_list *src, nir_cf_node *parent,
 639                   struct hash_table *remap_table)
 640 {
 641    exec_list_make_empty(&dst->list);
 642    dst->impl = src->impl;
 643
 644    if (exec_list_is_empty(&src->list))
 645       return;
 646
 647    clone_state state;
 648    init_clone_state(&state, remap_table, false, true);
 649
 650    /* We use the same shader */
 651    state.ns = src->impl->function->shader;
 652
 653    /* The control-flow code assumes that the list of cf_nodes always starts
 654     * and ends with a block.  We start by adding an empty block.
 655     */
 656    nir_block *nblk = nir_block_create(state.ns);
 657    nblk->cf_node.parent = parent;
 658    exec_list_push_tail(&dst->list, &nblk->cf_node.node);
 659
 660    clone_cf_list(&state, &dst->list, &src->list);
 661
 662    fixup_phi_srcs(&state);
 663 }
 664
 665 static nir_function_impl *
 666 clone_function_impl(clone_state *state, const nir_function_impl *fi)
 667 {
 668    nir_function_impl *nfi = nir_function_impl_create_bare(state->ns);
 669
 670    clone_var_list(state, &nfi->locals, &fi->locals);
 671    clone_reg_list(state, &nfi->registers, &fi->registers);
 672    nfi->reg_alloc = fi->reg_alloc;
 673
 674    assert(list_is_empty(&state->phi_srcs));
 675
 676    clone_cf_list(state, &nfi->body, &fi->body);
 677
 678    fixup_phi_srcs(state);
 679
 680    /* All metadata is invalidated in the cloning process */
 681    nfi->valid_metadata = 0;
 682
 683    return nfi;
 684 }
 685
 686 nir_function_impl *
 687 nir_function_impl_clone(nir_shader *shader, const nir_function_impl *fi)
 688 {
 689    clone_state state;
 690    init_clone_state(&state, NULL, false, false);
 691
 692    state.ns = shader;
 693
 694    nir_function_impl *nfi = clone_function_impl(&state, fi);
 695
 696    free_clone_state(&state);
 697
 698    return nfi;
 699 }
 700
 701 static nir_function *
 702 clone_function(clone_state *state, const nir_function *fxn, nir_shader *ns)
 703 {
 704    assert(ns == state->ns);
 705    nir_function *nfxn = nir_function_create(ns, fxn->name);
 706
 707    /* Needed for call instructions */
 708    add_remap(state, nfxn, fxn);
 709
 710    nfxn->num_params = fxn->num_params;
 711    if (fxn->num_params) {
 712            nfxn->params = ralloc_array(state->ns, nir_parameter, fxn->num_params);
 713            memcpy(nfxn->params, fxn->params, sizeof(nir_parameter) * fxn->num_params);
 714    }
 715    nfxn->is_entrypoint = fxn->is_entrypoint;
 716
 717    /* At first glance, it looks like we should clone the function_impl here.
 718     * However, call instructions need to be able to reference at least the
 719     * function and those will get processed as we clone the function_impls.
 720     * We stop here and do function_impls as a second pass.
 721     */
 722
 723    return nfxn;
 724 }
 725
 726 nir_shader *
 727 nir_shader_clone(void *mem_ctx, const nir_shader *s)
 728 {
 729    clone_state state;
 730    init_clone_state(&state, NULL, true, false);
 731
 732    nir_shader *ns = nir_shader_create(mem_ctx, s->info.stage, s->options, NULL);
 733    state.ns = ns;
 734
 735    clone_var_list(&state, &ns->uniforms, &s->uniforms);
 736    clone_var_list(&state, &ns->inputs,   &s->inputs);
 737    clone_var_list(&state, &ns->outputs,  &s->outputs);
 738    clone_var_list(&state, &ns->shared,   &s->shared);
 739    clone_var_list(&state, &ns->globals,  &s->globals);
 740    clone_var_list(&state, &ns->system_values, &s->system_values);
 741
 742    /* Go through and clone functions */
 743    foreach_list_typed(nir_function, fxn, node, &s->functions)
 744       clone_function(&state, fxn, ns);
 745
 746    /* Only after all functions are cloned can we clone the actual function
 747     * implementations.  This is because nir_call_instrs need to reference the
 748     * functions of other functions and we don't know what order the functions
 749     * will have in the list.
 750     */
 751    nir_foreach_function(fxn, s) {
 752       nir_function *nfxn = remap_global(&state, fxn);
 753       nfxn->impl = clone_function_impl(&state, fxn->impl);
 754       nfxn->impl->function = nfxn;
 755    }
 756
 757    ns->info = s->info;
 758    ns->info.name = ralloc_strdup(ns, ns->info.name);
 759    if (ns->info.label)
 760       ns->info.label = ralloc_strdup(ns, ns->info.label);
 761
 762    ns->num_inputs = s->num_inputs;
 763    ns->num_uniforms = s->num_uniforms;
 764    ns->num_outputs = s->num_outputs;
 765    ns->num_shared = s->num_shared;
 766    ns->scratch_size = s->scratch_size;
 767
 768    ns->constant_data_size = s->constant_data_size;
 769    if (s->constant_data_size > 0) {
 770       ns->constant_data = ralloc_size(ns, s->constant_data_size);
 771       memcpy(ns->constant_data, s->constant_data, s->constant_data_size);
 772    }
 773
 774    free_clone_state(&state);
 775
 776    return ns;
 777 }
 778
 779 /** Overwrites dst and replaces its contents with src
 780  *
 781  * Everything ralloc parented to dst and src itself (but not its children)
 782  * will be freed.
 783  *
 784  * This should only be used by test code which needs to swap out shaders with
 785  * a cloned or deserialized version.
 786  */
 787 void
 788 nir_shader_replace(nir_shader *dst, nir_shader *src)
 789 {
 790    /* Delete all of dest's ralloc children */
 791    void *dead_ctx = ralloc_context(NULL);
 792    ralloc_adopt(dead_ctx, dst);
 793    ralloc_free(dead_ctx);
 794
 795    /* Re-parent all of src's ralloc children to dst */
 796    ralloc_adopt(dst, src);
 797
 798    memcpy(dst, src, sizeof(*dst));
 799
 800    /* We have to move all the linked lists over separately because we need the
 801     * pointers in the list elements to point to the lists in dst and not src.
 802     */
 803    exec_list_move_nodes_to(&src->uniforms,      &dst->uniforms);
 804    exec_list_move_nodes_to(&src->inputs,        &dst->inputs);
 805    exec_list_move_nodes_to(&src->outputs,       &dst->outputs);
 806    exec_list_move_nodes_to(&src->shared,        &dst->shared);
 807    exec_list_move_nodes_to(&src->globals,       &dst->globals);
 808    exec_list_move_nodes_to(&src->system_values, &dst->system_values);
 809
 810    /* Now move the functions over.  This takes a tiny bit more work */
 811    exec_list_move_nodes_to(&src->functions, &dst->functions);
 812    nir_foreach_function(function, dst)
 813       function->shader = dst;
 814
 815    ralloc_free(src);
 816 }