"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/compiler/glsl/ir_array_refcount.cpp" (16 Sep 2020, 6103 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_array_refcount.cpp" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * Copyright © 2016 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 ir_array_refcount.cpp
   26  *
   27  * Provides a visitor which produces a list of variables referenced.
   28  */
   29 
   30 #include "ir.h"
   31 #include "ir_visitor.h"
   32 #include "ir_array_refcount.h"
   33 #include "compiler/glsl_types.h"
   34 #include "util/hash_table.h"
   35 
   36 ir_array_refcount_visitor::ir_array_refcount_visitor()
   37    : last_array_deref(0), derefs(0), num_derefs(0), derefs_size(0)
   38 {
   39    this->mem_ctx = ralloc_context(NULL);
   40    this->ht = _mesa_pointer_hash_table_create(NULL);
   41 }
   42 
   43 static void
   44 free_entry(struct hash_entry *entry)
   45 {
   46    ir_array_refcount_entry *ivre = (ir_array_refcount_entry *) entry->data;
   47    delete ivre;
   48 }
   49 
   50 ir_array_refcount_visitor::~ir_array_refcount_visitor()
   51 {
   52    ralloc_free(this->mem_ctx);
   53    _mesa_hash_table_destroy(this->ht, free_entry);
   54 }
   55 
   56 ir_array_refcount_entry::ir_array_refcount_entry(ir_variable *var)
   57    : var(var), is_referenced(false)
   58 {
   59    num_bits = MAX2(1, var->type->arrays_of_arrays_size());
   60    bits = new BITSET_WORD[BITSET_WORDS(num_bits)];
   61    memset(bits, 0, BITSET_WORDS(num_bits) * sizeof(bits[0]));
   62 
   63    /* Count the "depth" of the arrays-of-arrays. */
   64    array_depth = 0;
   65    for (const glsl_type *type = var->type;
   66         type->is_array();
   67         type = type->fields.array) {
   68       array_depth++;
   69    }
   70 }
   71 
   72 
   73 ir_array_refcount_entry::~ir_array_refcount_entry()
   74 {
   75    delete [] bits;
   76 }
   77 
   78 ir_array_refcount_entry *
   79 ir_array_refcount_visitor::get_variable_entry(ir_variable *var)
   80 {
   81    assert(var);
   82 
   83    struct hash_entry *e = _mesa_hash_table_search(this->ht, var);
   84    if (e)
   85       return (ir_array_refcount_entry *)e->data;
   86 
   87    ir_array_refcount_entry *entry = new ir_array_refcount_entry(var);
   88    _mesa_hash_table_insert(this->ht, var, entry);
   89 
   90    return entry;
   91 }
   92 
   93 
   94 array_deref_range *
   95 ir_array_refcount_visitor::get_array_deref()
   96 {
   97    if ((num_derefs + 1) * sizeof(array_deref_range) > derefs_size) {
   98       void *ptr = reralloc_size(mem_ctx, derefs, derefs_size + 4096);
   99 
  100       if (ptr == NULL)
  101          return NULL;
  102 
  103       derefs_size += 4096;
  104       derefs = (array_deref_range *)ptr;
  105    }
  106 
  107    array_deref_range *d = &derefs[num_derefs];
  108    num_derefs++;
  109 
  110    return d;
  111 }
  112 
  113 ir_visitor_status
  114 ir_array_refcount_visitor::visit_enter(ir_dereference_array *ir)
  115 {
  116    /* It could also be a vector or a matrix.  Individual elements of vectors
  117     * are natrices are not tracked, so bail.
  118     */
  119    if (!ir->array->type->is_array())
  120       return visit_continue;
  121 
  122    /* If this array dereference is a child of an array dereference that was
  123     * already visited, just continue on.  Otherwise, for an arrays-of-arrays
  124     * dereference like x[1][2][3][4], we'd process the [1][2][3][4] sequence,
  125     * the [1][2][3] sequence, the [1][2] sequence, and the [1] sequence.  This
  126     * ensures that we only process the full sequence.
  127     */
  128    if (last_array_deref && last_array_deref->array == ir) {
  129       last_array_deref = ir;
  130       return visit_continue;
  131    }
  132 
  133    last_array_deref = ir;
  134 
  135    num_derefs = 0;
  136 
  137    ir_rvalue *rv = ir;
  138    while (rv->ir_type == ir_type_dereference_array) {
  139       ir_dereference_array *const deref = rv->as_dereference_array();
  140 
  141       assert(deref != NULL);
  142       assert(deref->array->type->is_array());
  143 
  144       ir_rvalue *const array = deref->array;
  145       const ir_constant *const idx = deref->array_index->as_constant();
  146       array_deref_range *const dr = get_array_deref();
  147 
  148       dr->size = array->type->array_size();
  149 
  150       if (idx != NULL) {
  151          dr->index = idx->get_int_component(0);
  152       } else {
  153          /* An unsized array can occur at the end of an SSBO.  We can't track
  154           * accesses to such an array, so bail.
  155           */
  156          if (array->type->array_size() == 0)
  157             return visit_continue;
  158 
  159          dr->index = dr->size;
  160       }
  161 
  162       rv = array;
  163    }
  164 
  165    ir_dereference_variable *const var_deref = rv->as_dereference_variable();
  166 
  167    /* If the array being dereferenced is not a variable, bail.  At the very
  168     * least, ir_constant and ir_dereference_record are possible.
  169     */
  170    if (var_deref == NULL)
  171       return visit_continue;
  172 
  173    ir_array_refcount_entry *const entry =
  174       this->get_variable_entry(var_deref->var);
  175 
  176    if (entry == NULL)
  177       return visit_stop;
  178 
  179    link_util_mark_array_elements_referenced(derefs, num_derefs,
  180                                             entry->array_depth,
  181                                             entry->bits);
  182 
  183    return visit_continue;
  184 }
  185 
  186 
  187 ir_visitor_status
  188 ir_array_refcount_visitor::visit(ir_dereference_variable *ir)
  189 {
  190    ir_variable *const var = ir->variable_referenced();
  191    ir_array_refcount_entry *entry = this->get_variable_entry(var);
  192 
  193    entry->is_referenced = true;
  194 
  195    return visit_continue;
  196 }
  197 
  198 
  199 ir_visitor_status
  200 ir_array_refcount_visitor::visit_enter(ir_function_signature *ir)
  201 {
  202    /* We don't want to descend into the function parameters and
  203     * dead-code eliminate them, so just accept the body here.
  204     */
  205    visit_list_elements(this, &ir->body);
  206    return visit_continue_with_parent;
  207 }