"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/compiler/glsl/opt_function_inlining.cpp" (16 Sep 2020, 13628 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 "opt_function_inlining.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 /**
   25  * \file opt_function_inlining.cpp
   26  *
   27  * Replaces calls to functions with the body of the function.
   28  */
   29 
   30 #include "ir.h"
   31 #include "ir_visitor.h"
   32 #include "ir_function_inlining.h"
   33 #include "ir_expression_flattening.h"
   34 #include "compiler/glsl_types.h"
   35 #include "util/hash_table.h"
   36 
   37 static void
   38 do_variable_replacement(exec_list *instructions,
   39                         ir_variable *orig,
   40                         ir_dereference *repl);
   41 
   42 namespace {
   43 
   44 class ir_function_inlining_visitor : public ir_hierarchical_visitor {
   45 public:
   46    ir_function_inlining_visitor()
   47    {
   48       progress = false;
   49    }
   50 
   51    virtual ~ir_function_inlining_visitor()
   52    {
   53       /* empty */
   54    }
   55 
   56    virtual ir_visitor_status visit_enter(ir_expression *);
   57    virtual ir_visitor_status visit_enter(ir_call *);
   58    virtual ir_visitor_status visit_enter(ir_return *);
   59    virtual ir_visitor_status visit_enter(ir_texture *);
   60    virtual ir_visitor_status visit_enter(ir_swizzle *);
   61 
   62    bool progress;
   63 };
   64 
   65 class ir_save_lvalue_visitor : public ir_hierarchical_visitor {
   66 public:
   67    virtual ir_visitor_status visit_enter(ir_dereference_array *);
   68 };
   69 
   70 } /* unnamed namespace */
   71 
   72 bool
   73 do_function_inlining(exec_list *instructions)
   74 {
   75    ir_function_inlining_visitor v;
   76 
   77    v.run(instructions);
   78 
   79    return v.progress;
   80 }
   81 
   82 static void
   83 replace_return_with_assignment(ir_instruction *ir, void *data)
   84 {
   85    void *ctx = ralloc_parent(ir);
   86    ir_dereference *orig_deref = (ir_dereference *) data;
   87    ir_return *ret = ir->as_return();
   88 
   89    if (ret) {
   90       if (ret->value) {
   91      ir_rvalue *lhs = orig_deref->clone(ctx, NULL);
   92          ret->replace_with(new(ctx) ir_assignment(lhs, ret->value));
   93       } else {
   94      /* un-valued return has to be the last return, or we shouldn't
   95       * have reached here. (see can_inline()).
   96       */
   97      assert(ret->next->is_tail_sentinel());
   98      ret->remove();
   99       }
  100    }
  101 }
  102 
  103 /* Save the given lvalue before the given instruction.
  104  *
  105  * This is done by adding temporary variables into which the current value
  106  * of any array indices are saved, and then modifying the dereference chain
  107  * in-place to point to those temporary variables.
  108  *
  109  * The hierarchical visitor is only used to traverse the left-hand-side chain
  110  * of derefs.
  111  */
  112 ir_visitor_status
  113 ir_save_lvalue_visitor::visit_enter(ir_dereference_array *deref)
  114 {
  115    if (deref->array_index->ir_type != ir_type_constant) {
  116       void *ctx = ralloc_parent(deref);
  117       ir_variable *index;
  118       ir_assignment *assignment;
  119 
  120       index = new(ctx) ir_variable(deref->array_index->type, "saved_idx", ir_var_temporary);
  121       base_ir->insert_before(index);
  122 
  123       assignment = new(ctx) ir_assignment(new(ctx) ir_dereference_variable(index),
  124                                           deref->array_index);
  125       base_ir->insert_before(assignment);
  126 
  127       deref->array_index = new(ctx) ir_dereference_variable(index);
  128    }
  129 
  130    deref->array->accept(this);
  131    return visit_stop;
  132 }
  133 
  134 static bool
  135 should_replace_variable(ir_variable *sig_param, ir_rvalue *param) {
  136    /* For opaque types, we want the inlined variable references
  137     * referencing the passed in variable, since that will have
  138     * the location information, which an assignment of an opaque
  139     * variable wouldn't.
  140     */
  141    return sig_param->type->contains_opaque() &&
  142           param->is_dereference() &&
  143           sig_param->data.mode == ir_var_function_in;
  144 }
  145 
  146 void
  147 ir_call::generate_inline(ir_instruction *next_ir)
  148 {
  149    void *ctx = ralloc_parent(this);
  150    ir_variable **parameters;
  151    unsigned num_parameters;
  152    int i;
  153    struct hash_table *ht;
  154 
  155    ht = _mesa_pointer_hash_table_create(NULL);
  156 
  157    num_parameters = this->callee->parameters.length();
  158    parameters = new ir_variable *[num_parameters];
  159 
  160    /* Generate the declarations for the parameters to our inlined code,
  161     * and set up the mapping of real function body variables to ours.
  162     */
  163    i = 0;
  164    foreach_two_lists(formal_node, &this->callee->parameters,
  165                      actual_node, &this->actual_parameters) {
  166       ir_variable *sig_param = (ir_variable *) formal_node;
  167       ir_rvalue *param = (ir_rvalue *) actual_node;
  168 
  169       /* Generate a new variable for the parameter. */
  170       if (should_replace_variable(sig_param, param)) {
  171          /* Actual replacement happens below */
  172      parameters[i] = NULL;
  173       } else {
  174      parameters[i] = sig_param->clone(ctx, ht);
  175      parameters[i]->data.mode = ir_var_temporary;
  176 
  177      /* Remove the read-only decoration because we're going to write
  178       * directly to this variable.  If the cloned variable is left
  179       * read-only and the inlined function is inside a loop, the loop
  180       * analysis code will get confused.
  181       */
  182      parameters[i]->data.read_only = false;
  183      next_ir->insert_before(parameters[i]);
  184       }
  185 
  186       /* Section 6.1.1 (Function Calling Conventions) of the OpenGL Shading
  187        * Language 4.5 spec says:
  188        *
  189        *    "All arguments are evaluated at call time, exactly once, in order,
  190        *     from left to right. [...] Evaluation of an out parameter results
  191        *     in an l-value that is used to copy out a value when the function
  192        *     returns."
  193        *
  194        * I.e., we have to take temporary copies of any relevant array indices
  195        * before the function body is executed.
  196        *
  197        * This ensures that
  198        * (a) if an array index expressions refers to a variable that is
  199        *     modified by the execution of the function body, we use the
  200        *     original value as intended, and
  201        * (b) if an array index expression has side effects, those side effects
  202        *     are only executed once and at the right time.
  203        */
  204       if (parameters[i]) {
  205          if (sig_param->data.mode == ir_var_function_in ||
  206              sig_param->data.mode == ir_var_const_in) {
  207             ir_assignment *assign;
  208 
  209             assign = new(ctx) ir_assignment(new(ctx) ir_dereference_variable(parameters[i]),
  210                                             param);
  211             next_ir->insert_before(assign);
  212          } else {
  213             assert(sig_param->data.mode == ir_var_function_out ||
  214                    sig_param->data.mode == ir_var_function_inout);
  215             assert(param->is_lvalue());
  216 
  217             ir_save_lvalue_visitor v;
  218             v.base_ir = next_ir;
  219 
  220             param->accept(&v);
  221 
  222             if (sig_param->data.mode == ir_var_function_inout) {
  223                ir_assignment *assign;
  224 
  225                assign = new(ctx) ir_assignment(new(ctx) ir_dereference_variable(parameters[i]),
  226                                                param->clone(ctx, NULL)->as_rvalue());
  227                next_ir->insert_before(assign);
  228             }
  229          }
  230       }
  231 
  232       ++i;
  233    }
  234 
  235    exec_list new_instructions;
  236 
  237    /* Generate the inlined body of the function to a new list */
  238    foreach_in_list(ir_instruction, ir, &callee->body) {
  239       ir_instruction *new_ir = ir->clone(ctx, ht);
  240 
  241       new_instructions.push_tail(new_ir);
  242       visit_tree(new_ir, replace_return_with_assignment, this->return_deref);
  243    }
  244 
  245    /* If any opaque types were passed in, replace any deref of the
  246     * opaque variable with a deref of the argument.
  247     */
  248    foreach_two_lists(formal_node, &this->callee->parameters,
  249                      actual_node, &this->actual_parameters) {
  250       ir_rvalue *const param = (ir_rvalue *) actual_node;
  251       ir_variable *sig_param = (ir_variable *) formal_node;
  252 
  253       if (should_replace_variable(sig_param, param)) {
  254      ir_dereference *deref = param->as_dereference();
  255 
  256      do_variable_replacement(&new_instructions, sig_param, deref);
  257       }
  258    }
  259 
  260    /* Now push those new instructions in. */
  261    next_ir->insert_before(&new_instructions);
  262 
  263    /* Copy back the value of any 'out' parameters from the function body
  264     * variables to our own.
  265     */
  266    i = 0;
  267    foreach_two_lists(formal_node, &this->callee->parameters,
  268                      actual_node, &this->actual_parameters) {
  269       ir_rvalue *const param = (ir_rvalue *) actual_node;
  270       const ir_variable *const sig_param = (ir_variable *) formal_node;
  271 
  272       /* Move our param variable into the actual param if it's an 'out' type. */
  273       if (parameters[i] && (sig_param->data.mode == ir_var_function_out ||
  274                 sig_param->data.mode == ir_var_function_inout)) {
  275      ir_assignment *assign;
  276 
  277          assign = new(ctx) ir_assignment(param,
  278                                          new(ctx) ir_dereference_variable(parameters[i]));
  279      next_ir->insert_before(assign);
  280       }
  281 
  282       ++i;
  283    }
  284 
  285    delete [] parameters;
  286 
  287    _mesa_hash_table_destroy(ht, NULL);
  288 }
  289 
  290 
  291 ir_visitor_status
  292 ir_function_inlining_visitor::visit_enter(ir_expression *ir)
  293 {
  294    (void) ir;
  295    return visit_continue_with_parent;
  296 }
  297 
  298 
  299 ir_visitor_status
  300 ir_function_inlining_visitor::visit_enter(ir_return *ir)
  301 {
  302    (void) ir;
  303    return visit_continue_with_parent;
  304 }
  305 
  306 
  307 ir_visitor_status
  308 ir_function_inlining_visitor::visit_enter(ir_texture *ir)
  309 {
  310    (void) ir;
  311    return visit_continue_with_parent;
  312 }
  313 
  314 
  315 ir_visitor_status
  316 ir_function_inlining_visitor::visit_enter(ir_swizzle *ir)
  317 {
  318    (void) ir;
  319    return visit_continue_with_parent;
  320 }
  321 
  322 
  323 ir_visitor_status
  324 ir_function_inlining_visitor::visit_enter(ir_call *ir)
  325 {
  326    if (can_inline(ir)) {
  327       ir->generate_inline(ir);
  328       ir->remove();
  329       this->progress = true;
  330    }
  331 
  332    return visit_continue;
  333 }
  334 
  335 
  336 /**
  337  * Replaces references to the "orig" variable with a clone of "repl."
  338  *
  339  * From the spec, opaque types can appear in the tree as function
  340  * (non-out) parameters and as the result of array indexing and
  341  * structure field selection.  In our builtin implementation, they
  342  * also appear in the sampler field of an ir_tex instruction.
  343  */
  344 
  345 class ir_variable_replacement_visitor : public ir_hierarchical_visitor {
  346 public:
  347    ir_variable_replacement_visitor(ir_variable *orig, ir_dereference *repl)
  348    {
  349       this->orig = orig;
  350       this->repl = repl;
  351    }
  352 
  353    virtual ~ir_variable_replacement_visitor()
  354    {
  355    }
  356 
  357    virtual ir_visitor_status visit_leave(ir_call *);
  358    virtual ir_visitor_status visit_leave(ir_dereference_array *);
  359    virtual ir_visitor_status visit_leave(ir_dereference_record *);
  360    virtual ir_visitor_status visit_leave(ir_texture *);
  361    virtual ir_visitor_status visit_leave(ir_assignment *);
  362    virtual ir_visitor_status visit_leave(ir_expression *);
  363    virtual ir_visitor_status visit_leave(ir_return *);
  364 
  365    void replace_deref(ir_dereference **deref);
  366    void replace_rvalue(ir_rvalue **rvalue);
  367 
  368    ir_variable *orig;
  369    ir_dereference *repl;
  370 };
  371 
  372 void
  373 ir_variable_replacement_visitor::replace_deref(ir_dereference **deref)
  374 {
  375    ir_dereference_variable *deref_var = (*deref)->as_dereference_variable();
  376    if (deref_var && deref_var->var == this->orig) {
  377       *deref = this->repl->clone(ralloc_parent(*deref), NULL);
  378    }
  379 }
  380 
  381 void
  382 ir_variable_replacement_visitor::replace_rvalue(ir_rvalue **rvalue)
  383 {
  384    if (!*rvalue)
  385       return;
  386 
  387    ir_dereference *deref = (*rvalue)->as_dereference();
  388 
  389    if (!deref)
  390       return;
  391 
  392    replace_deref(&deref);
  393    *rvalue = deref;
  394 }
  395 
  396 ir_visitor_status
  397 ir_variable_replacement_visitor::visit_leave(ir_texture *ir)
  398 {
  399    replace_deref(&ir->sampler);
  400 
  401    return visit_continue;
  402 }
  403 
  404 ir_visitor_status
  405 ir_variable_replacement_visitor::visit_leave(ir_assignment *ir)
  406 {
  407    replace_deref(&ir->lhs);
  408    replace_rvalue(&ir->rhs);
  409 
  410    return visit_continue;
  411 }
  412 
  413 ir_visitor_status
  414 ir_variable_replacement_visitor::visit_leave(ir_expression *ir)
  415 {
  416    for (uint8_t i = 0; i < ir->num_operands; i++)
  417       replace_rvalue(&ir->operands[i]);
  418 
  419    return visit_continue;
  420 }
  421 
  422 ir_visitor_status
  423 ir_variable_replacement_visitor::visit_leave(ir_return *ir)
  424 {
  425    replace_rvalue(&ir->value);
  426 
  427    return visit_continue;
  428 }
  429 
  430 ir_visitor_status
  431 ir_variable_replacement_visitor::visit_leave(ir_dereference_array *ir)
  432 {
  433    replace_rvalue(&ir->array);
  434    return visit_continue;
  435 }
  436 
  437 ir_visitor_status
  438 ir_variable_replacement_visitor::visit_leave(ir_dereference_record *ir)
  439 {
  440    replace_rvalue(&ir->record);
  441    return visit_continue;
  442 }
  443 
  444 ir_visitor_status
  445 ir_variable_replacement_visitor::visit_leave(ir_call *ir)
  446 {
  447    foreach_in_list_safe(ir_rvalue, param, &ir->actual_parameters) {
  448       ir_rvalue *new_param = param;
  449       replace_rvalue(&new_param);
  450 
  451       if (new_param != param) {
  452      param->replace_with(new_param);
  453       }
  454    }
  455    return visit_continue;
  456 }
  457 
  458 static void
  459 do_variable_replacement(exec_list *instructions,
  460                         ir_variable *orig,
  461                         ir_dereference *repl)
  462 {
  463    ir_variable_replacement_visitor v(orig, repl);
  464 
  465    visit_list_elements(&v, instructions);
  466 }