src/compiler/glsl/opt_dead_functions.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 /**
  25  * \file opt_dead_functions.cpp
  26  *
  27  * Eliminates unused functions from the linked program.
  28  */
  29
  30 #include "ir.h"
  31 #include "ir_visitor.h"
  32 #include "ir_expression_flattening.h"
  33 #include "compiler/glsl_types.h"
  34
  35 namespace {
  36
  37 class signature_entry : public exec_node
  38 {
  39 public:
  40    signature_entry(ir_function_signature *sig)
  41    {
  42       this->signature = sig;
  43       this->used = false;
  44    }
  45
  46    ir_function_signature *signature;
  47    bool used;
  48 };
  49
  50 class ir_dead_functions_visitor : public ir_hierarchical_visitor {
  51 public:
  52    ir_dead_functions_visitor()
  53    {
  54       this->mem_ctx = ralloc_context(NULL);
  55    }
  56
  57    ~ir_dead_functions_visitor()
  58    {
  59       ralloc_free(this->mem_ctx);
  60    }
  61
  62    virtual ir_visitor_status visit_enter(ir_function_signature *);
  63    virtual ir_visitor_status visit_enter(ir_call *);
  64
  65    signature_entry *get_signature_entry(ir_function_signature *var);
  66
  67    /* List of signature_entry */
  68    exec_list signature_list;
  69    void *mem_ctx;
  70 };
  71
  72 } /* unnamed namespace */
  73
  74 signature_entry *
  75 ir_dead_functions_visitor::get_signature_entry(ir_function_signature *sig)
  76 {
  77    foreach_in_list(signature_entry, entry, &this->signature_list) {
  78       if (entry->signature == sig)
  79          return entry;
  80    }
  81
  82    signature_entry *entry = new(mem_ctx) signature_entry(sig);
  83    this->signature_list.push_tail(entry);
  84    return entry;
  85 }
  86
  87
  88 ir_visitor_status
  89 ir_dead_functions_visitor::visit_enter(ir_function_signature *ir)
  90 {
  91    signature_entry *entry = this->get_signature_entry(ir);
  92
  93    if (strcmp(ir->function_name(), "main") == 0) {
  94       entry->used = true;
  95    }
  96
  97
  98
  99    return visit_continue;
 100 }
 101
 102
 103 ir_visitor_status
 104 ir_dead_functions_visitor::visit_enter(ir_call *ir)
 105 {
 106    signature_entry *entry = this->get_signature_entry(ir->callee);
 107
 108    entry->used = true;
 109
 110    return visit_continue;
 111 }
 112
 113 bool
 114 do_dead_functions(exec_list *instructions)
 115 {
 116    ir_dead_functions_visitor v;
 117    bool progress = false;
 118
 119    visit_list_elements(&v, instructions);
 120
 121    /* Now that we've figured out which function signatures are used, remove
 122     * the unused ones, and remove function definitions that have no more
 123     * signatures.
 124     */
 125     foreach_in_list_safe(signature_entry, entry, &v.signature_list) {
 126       if (!entry->used) {
 127          entry->signature->remove();
 128          delete entry->signature;
 129          progress = true;
 130       }
 131       delete(entry);
 132    }
 133
 134    /* We don't just do this above when we nuked a signature because of
 135     * const pointers.
 136     */
 137    foreach_in_list_safe(ir_instruction, ir, instructions) {
 138       ir_function *func = ir->as_function();
 139
 140       if (func && func->signatures.is_empty()) {
 141          /* At this point (post-linking), the symbol table is no
 142           * longer in use, so not removing the function from the
 143           * symbol table should be OK.
 144           */
 145          func->remove();
 146          delete func;
 147          progress = true;
 148       }
 149    }
 150
 151    return progress;
 152 }