src/compiler/glsl/ir_clone.cpp

   1 /*
   2  * Copyright © 2010 Intel Corporation
   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
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include <string.h>
  25 #include "util/compiler.h"
  26 #include "ir.h"
  27 #include "compiler/glsl_types.h"
  28 #include "util/hash_table.h"
  29
  30 ir_rvalue *
  31 ir_rvalue::clone(void *mem_ctx, struct hash_table *) const
  32 {
  33    /* The only possible instantiation is the generic error value. */
  34    return error_value(mem_ctx);
  35 }
  36
  37 /**
  38  * Duplicate an IR variable
  39  */
  40 ir_variable *
  41 ir_variable::clone(void *mem_ctx, struct hash_table *ht) const
  42 {
  43    ir_variable *var = new(mem_ctx) ir_variable(this->type, this->name,
  44                                                (ir_variable_mode) this->data.mode);
  45
  46    var->data.max_array_access = this->data.max_array_access;
  47    if (this->is_interface_instance()) {
  48       var->u.max_ifc_array_access =
  49          rzalloc_array(var, int, this->interface_type->length);
  50       memcpy(var->u.max_ifc_array_access, this->u.max_ifc_array_access,
  51              this->interface_type->length * sizeof(unsigned));
  52    }
  53
  54    memcpy(&var->data, &this->data, sizeof(var->data));
  55
  56    if (this->get_state_slots()) {
  57       ir_state_slot *s = var->allocate_state_slots(this->get_num_state_slots());
  58       memcpy(s, this->get_state_slots(),
  59              sizeof(s[0]) * var->get_num_state_slots());
  60    }
  61
  62    if (this->constant_value)
  63       var->constant_value = this->constant_value->clone(mem_ctx, ht);
  64
  65    if (this->constant_initializer)
  66       var->constant_initializer =
  67          this->constant_initializer->clone(mem_ctx, ht);
  68
  69    var->interface_type = this->interface_type;
  70
  71    if (ht)
  72       _mesa_hash_table_insert(ht, (void *)const_cast<ir_variable *>(this), var);
  73
  74    return var;
  75 }
  76
  77 ir_swizzle *
  78 ir_swizzle::clone(void *mem_ctx, struct hash_table *ht) const
  79 {
  80    return new(mem_ctx) ir_swizzle(this->val->clone(mem_ctx, ht), this->mask);
  81 }
  82
  83 ir_return *
  84 ir_return::clone(void *mem_ctx, struct hash_table *ht) const
  85 {
  86    ir_rvalue *new_value = NULL;
  87
  88    if (this->value)
  89       new_value = this->value->clone(mem_ctx, ht);
  90
  91    return new(mem_ctx) ir_return(new_value);
  92 }
  93
  94 ir_discard *
  95 ir_discard::clone(void *mem_ctx, struct hash_table *ht) const
  96 {
  97    ir_rvalue *new_condition = NULL;
  98
  99    if (this->condition != NULL)
 100       new_condition = this->condition->clone(mem_ctx, ht);
 101
 102    return new(mem_ctx) ir_discard(new_condition);
 103 }
 104
 105 ir_demote *
 106 ir_demote::clone(void *mem_ctx, struct hash_table *ht) const
 107 {
 108    return new(mem_ctx) ir_demote();
 109 }
 110
 111 ir_loop_jump *
 112 ir_loop_jump::clone(void *mem_ctx, struct hash_table *ht) const
 113 {
 114    (void)ht;
 115
 116    return new(mem_ctx) ir_loop_jump(this->mode);
 117 }
 118
 119 ir_if *
 120 ir_if::clone(void *mem_ctx, struct hash_table *ht) const
 121 {
 122    ir_if *new_if = new(mem_ctx) ir_if(this->condition->clone(mem_ctx, ht));
 123
 124    foreach_in_list(ir_instruction, ir, &this->then_instructions) {
 125       new_if->then_instructions.push_tail(ir->clone(mem_ctx, ht));
 126    }
 127
 128    foreach_in_list(ir_instruction, ir, &this->else_instructions) {
 129       new_if->else_instructions.push_tail(ir->clone(mem_ctx, ht));
 130    }
 131
 132    return new_if;
 133 }
 134
 135 ir_loop *
 136 ir_loop::clone(void *mem_ctx, struct hash_table *ht) const
 137 {
 138    ir_loop *new_loop = new(mem_ctx) ir_loop();
 139
 140    foreach_in_list(ir_instruction, ir, &this->body_instructions) {
 141       new_loop->body_instructions.push_tail(ir->clone(mem_ctx, ht));
 142    }
 143
 144    return new_loop;
 145 }
 146
 147 ir_call *
 148 ir_call::clone(void *mem_ctx, struct hash_table *ht) const
 149 {
 150    ir_dereference_variable *new_return_ref = NULL;
 151    if (this->return_deref != NULL)
 152       new_return_ref = this->return_deref->clone(mem_ctx, ht);
 153
 154    exec_list new_parameters;
 155
 156    foreach_in_list(ir_instruction, ir, &this->actual_parameters) {
 157       new_parameters.push_tail(ir->clone(mem_ctx, ht));
 158    }
 159
 160    return new(mem_ctx) ir_call(this->callee, new_return_ref, &new_parameters);
 161 }
 162
 163 ir_expression *
 164 ir_expression::clone(void *mem_ctx, struct hash_table *ht) const
 165 {
 166    ir_rvalue *op[ARRAY_SIZE(this->operands)] = { NULL, };
 167    unsigned int i;
 168
 169    for (i = 0; i < num_operands; i++) {
 170       op[i] = this->operands[i]->clone(mem_ctx, ht);
 171    }
 172
 173    return new(mem_ctx) ir_expression(this->operation, this->type,
 174                                      op[0], op[1], op[2], op[3]);
 175 }
 176
 177 ir_dereference_variable *
 178 ir_dereference_variable::clone(void *mem_ctx, struct hash_table *ht) const
 179 {
 180    ir_variable *new_var;
 181
 182    if (ht) {
 183       hash_entry *entry = _mesa_hash_table_search(ht, this->var);
 184       new_var = entry ? (ir_variable *) entry->data : this->var;
 185    } else {
 186       new_var = this->var;
 187    }
 188
 189    return new(mem_ctx) ir_dereference_variable(new_var);
 190 }
 191
 192 ir_dereference_array *
 193 ir_dereference_array::clone(void *mem_ctx, struct hash_table *ht) const
 194 {
 195    return new(mem_ctx) ir_dereference_array(this->array->clone(mem_ctx, ht),
 196                                             this->array_index->clone(mem_ctx,
 197                                                                      ht));
 198 }
 199
 200 ir_dereference_record *
 201 ir_dereference_record::clone(void *mem_ctx, struct hash_table *ht) const
 202 {
 203    assert(this->field_idx >= 0);
 204    const char *field_name =
 205       this->record->type->fields.structure[this->field_idx].name;
 206    return new(mem_ctx) ir_dereference_record(this->record->clone(mem_ctx, ht),
 207                                              field_name);
 208 }
 209
 210 ir_texture *
 211 ir_texture::clone(void *mem_ctx, struct hash_table *ht) const
 212 {
 213    ir_texture *new_tex = new(mem_ctx) ir_texture(this->op);
 214    new_tex->type = this->type;
 215
 216    new_tex->sampler = this->sampler->clone(mem_ctx, ht);
 217    if (this->coordinate)
 218       new_tex->coordinate = this->coordinate->clone(mem_ctx, ht);
 219    if (this->projector)
 220       new_tex->projector = this->projector->clone(mem_ctx, ht);
 221    if (this->shadow_comparator) {
 222       new_tex->shadow_comparator = this->shadow_comparator->clone(mem_ctx, ht);
 223    }
 224
 225    if (this->offset != NULL)
 226       new_tex->offset = this->offset->clone(mem_ctx, ht);
 227
 228    switch (this->op) {
 229    case ir_tex:
 230    case ir_lod:
 231    case ir_query_levels:
 232    case ir_texture_samples:
 233    case ir_samples_identical:
 234       break;
 235    case ir_txb:
 236       new_tex->lod_info.bias = this->lod_info.bias->clone(mem_ctx, ht);
 237       break;
 238    case ir_txl:
 239    case ir_txf:
 240    case ir_txs:
 241       new_tex->lod_info.lod = this->lod_info.lod->clone(mem_ctx, ht);
 242       break;
 243    case ir_txf_ms:
 244       new_tex->lod_info.sample_index = this->lod_info.sample_index->clone(mem_ctx, ht);
 245       break;
 246    case ir_txd:
 247       new_tex->lod_info.grad.dPdx = this->lod_info.grad.dPdx->clone(mem_ctx, ht);
 248       new_tex->lod_info.grad.dPdy = this->lod_info.grad.dPdy->clone(mem_ctx, ht);
 249       break;
 250    case ir_tg4:
 251       new_tex->lod_info.component = this->lod_info.component->clone(mem_ctx, ht);
 252       break;
 253    }
 254
 255    return new_tex;
 256 }
 257
 258 ir_assignment *
 259 ir_assignment::clone(void *mem_ctx, struct hash_table *ht) const
 260 {
 261    ir_rvalue *new_condition = NULL;
 262
 263    if (this->condition)
 264       new_condition = this->condition->clone(mem_ctx, ht);
 265
 266    ir_assignment *cloned =
 267       new(mem_ctx) ir_assignment(this->lhs->clone(mem_ctx, ht),
 268                                  this->rhs->clone(mem_ctx, ht),
 269                                  new_condition);
 270    cloned->write_mask = this->write_mask;
 271    return cloned;
 272 }
 273
 274 ir_function *
 275 ir_function::clone(void *mem_ctx, struct hash_table *ht) const
 276 {
 277    ir_function *copy = new(mem_ctx) ir_function(this->name);
 278
 279    copy->is_subroutine = this->is_subroutine;
 280    copy->subroutine_index = this->subroutine_index;
 281    copy->num_subroutine_types = this->num_subroutine_types;
 282    copy->subroutine_types = ralloc_array(mem_ctx, const struct glsl_type *, copy->num_subroutine_types);
 283    for (int i = 0; i < copy->num_subroutine_types; i++)
 284      copy->subroutine_types[i] = this->subroutine_types[i];
 285
 286    foreach_in_list(const ir_function_signature, sig, &this->signatures) {
 287       ir_function_signature *sig_copy = sig->clone(mem_ctx, ht);
 288       copy->add_signature(sig_copy);
 289
 290       if (ht != NULL) {
 291          _mesa_hash_table_insert(ht,
 292                (void *)const_cast<ir_function_signature *>(sig), sig_copy);
 293       }
 294    }
 295
 296    return copy;
 297 }
 298
 299 ir_function_signature *
 300 ir_function_signature::clone(void *mem_ctx, struct hash_table *ht) const
 301 {
 302    ir_function_signature *copy = this->clone_prototype(mem_ctx, ht);
 303
 304    copy->is_defined = this->is_defined;
 305
 306    /* Clone the instruction list.
 307     */
 308    foreach_in_list(const ir_instruction, inst, &this->body) {
 309       ir_instruction *const inst_copy = inst->clone(mem_ctx, ht);
 310       copy->body.push_tail(inst_copy);
 311    }
 312
 313    return copy;
 314 }
 315
 316 ir_function_signature *
 317 ir_function_signature::clone_prototype(void *mem_ctx, struct hash_table *ht) const
 318 {
 319    ir_function_signature *copy =
 320       new(mem_ctx) ir_function_signature(this->return_type);
 321
 322    copy->is_defined = false;
 323    copy->builtin_avail = this->builtin_avail;
 324    copy->origin = this;
 325
 326    /* Clone the parameter list, but NOT the body.
 327     */
 328    foreach_in_list(const ir_variable, param, &this->parameters) {
 329       assert(const_cast<ir_variable *>(param)->as_variable() != NULL);
 330
 331       ir_variable *const param_copy = param->clone(mem_ctx, ht);
 332       copy->parameters.push_tail(param_copy);
 333    }
 334
 335    return copy;
 336 }
 337
 338 ir_constant *
 339 ir_constant::clone(void *mem_ctx, struct hash_table *ht) const
 340 {
 341    (void)ht;
 342
 343    switch (this->type->base_type) {
 344    case GLSL_TYPE_UINT:
 345    case GLSL_TYPE_INT:
 346    case GLSL_TYPE_FLOAT:
 347    case GLSL_TYPE_FLOAT16:
 348    case GLSL_TYPE_DOUBLE:
 349    case GLSL_TYPE_BOOL:
 350    case GLSL_TYPE_UINT64:
 351    case GLSL_TYPE_INT64:
 352    case GLSL_TYPE_UINT16:
 353    case GLSL_TYPE_INT16:
 354    case GLSL_TYPE_UINT8:
 355    case GLSL_TYPE_INT8:
 356    case GLSL_TYPE_SAMPLER:
 357    case GLSL_TYPE_IMAGE:
 358       return new(mem_ctx) ir_constant(this->type, &this->value);
 359
 360    case GLSL_TYPE_STRUCT:
 361    case GLSL_TYPE_ARRAY: {
 362       ir_constant *c = new(mem_ctx) ir_constant;
 363
 364       c->type = this->type;
 365       c->const_elements = ralloc_array(c, ir_constant *, this->type->length);
 366       for (unsigned i = 0; i < this->type->length; i++) {
 367          c->const_elements[i] = this->const_elements[i]->clone(mem_ctx, NULL);
 368       }
 369       return c;
 370    }
 371
 372    case GLSL_TYPE_ATOMIC_UINT:
 373    case GLSL_TYPE_VOID:
 374    case GLSL_TYPE_ERROR:
 375    case GLSL_TYPE_SUBROUTINE:
 376    case GLSL_TYPE_INTERFACE:
 377    case GLSL_TYPE_FUNCTION:
 378       assert(!"Should not get here.");
 379       break;
 380    }
 381
 382    return NULL;
 383 }
 384
 385
 386 class fixup_ir_call_visitor : public ir_hierarchical_visitor {
 387 public:
 388    fixup_ir_call_visitor(struct hash_table *ht)
 389    {
 390       this->ht = ht;
 391    }
 392
 393    virtual ir_visitor_status visit_enter(ir_call *ir)
 394    {
 395       /* Try to find the function signature referenced by the ir_call in the
 396        * table.  If it is found, replace it with the value from the table.
 397        */
 398       ir_function_signature *sig;
 399       hash_entry *entry = _mesa_hash_table_search(this->ht, ir->callee);
 400
 401       if (entry != NULL) {
 402          sig = (ir_function_signature *) entry->data;
 403          ir->callee = sig;
 404       }
 405
 406       /* Since this may be used before function call parameters are flattened,
 407        * the children also need to be processed.
 408        */
 409       return visit_continue;
 410    }
 411
 412 private:
 413    struct hash_table *ht;
 414 };
 415
 416
 417 static void
 418 fixup_function_calls(struct hash_table *ht, exec_list *instructions)
 419 {
 420    fixup_ir_call_visitor v(ht);
 421    v.run(instructions);
 422 }
 423
 424
 425 void
 426 clone_ir_list(void *mem_ctx, exec_list *out, const exec_list *in)
 427 {
 428    struct hash_table *ht = _mesa_pointer_hash_table_create(NULL);
 429
 430    foreach_in_list(const ir_instruction, original, in) {
 431       ir_instruction *copy = original->clone(mem_ctx, ht);
 432
 433       out->push_tail(copy);
 434    }
 435
 436    /* Make a pass over the cloned tree to fix up ir_call nodes to point to the
 437     * cloned ir_function_signature nodes.  This cannot be done automatically
 438     * during cloning because the ir_call might be a forward reference (i.e.,
 439     * the function signature that it references may not have been cloned yet).
 440     */
 441    fixup_function_calls(ht, out);
 442
 443    _mesa_hash_table_destroy(ht, NULL);
 444 }