"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/compiler/glsl/ir_clone.cpp" (16 Sep 2020, 12811 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "ir_clone.cpp" see the Fossies "Dox" file reference documentation.

    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 }