nsz Git - libfirm/blob - ir/common/irtools.c

   1 /*
   2  * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief     Some often needed tool-functions
  23  * @author    Michael Beck
  24  */
  25 #include "config.h"
  26
  27 #include "pset.h"
  28
  29 #include <stdlib.h>
  30 #include "irnode_t.h"
  31 #include "irbackedge_t.h"
  32 #include "irtools.h"
  33 #include "irprintf.h"
  34 #include "irpass_t.h"
  35 #include "iropt_t.h"
  36
  37 void firm_clear_link(ir_node *n, void *env)
  38 {
  39         (void) env;
  40         set_irn_link(n, NULL);
  41 }
  42
  43 void firm_clear_node_and_phi_links(ir_node *n, void *env)
  44 {
  45         (void) env;
  46         set_irn_link(n, NULL);
  47         if (is_Block(n))
  48                 set_Block_phis(n, NULL);
  49         else if (is_Phi(n))
  50                 set_Phi_next(n, NULL);
  51 }
  52
  53 void firm_clear_block_phis(ir_node *node, void *env)
  54 {
  55         (void) env;
  56         if (is_Block(node)) {
  57                 set_Block_phis(node, NULL);
  58         } else if (is_Phi(node)) {
  59                 set_Phi_next(node, NULL);
  60         }
  61 }
  62
  63 void firm_collect_block_phis(ir_node *node, void *env)
  64 {
  65         (void) env;
  66         if (is_Phi(node))
  67                 add_Block_phi(get_nodes_block(node), node);
  68 }
  69
  70 void copy_irn_to_irg(ir_node *n, ir_graph *irg)
  71 {
  72         ir_op *op = get_irn_op(n);
  73         ir_graph *old_irg;
  74         ir_node *nn = NULL;
  75
  76         /* do not copy standard nodes */
  77         if (op == op_NoMem)
  78                 n = get_irg_no_mem(irg);
  79         else if (op == op_Block) {
  80                 old_irg = get_irn_irg(n);
  81
  82                 if (n == get_irg_start_block(old_irg))
  83                         nn = get_irg_start_block(irg);
  84                 else if (n == get_irg_end_block(old_irg))
  85                         nn = get_irg_end_block(irg);
  86         }
  87         else if (op == op_Start)
  88                 nn = get_irg_start(irg);
  89         else if (op == op_End)
  90                 nn = get_irg_end(irg);
  91         else if (op == op_Proj) {
  92                 old_irg = get_irn_irg(n);
  93
  94                 if (n == get_irg_initial_exec(old_irg))
  95                         nn = get_irg_initial_exec(irg);
  96                 else if (n == get_irg_frame(old_irg))
  97                         nn = get_irg_frame(irg);
  98                 else if (n == get_irg_initial_mem(old_irg))
  99                         nn = get_irg_initial_mem(irg);
 100                 else if (n == get_irg_args(old_irg))
 101                         nn = get_irg_args(irg);
 102         }
 103
 104         if (nn) {
 105                 set_irn_link(n, nn);
 106                 return;
 107         }
 108
 109         nn = new_ir_node(get_irn_dbg_info(n),
 110                          irg,
 111                          NULL,            /* no block yet, will be set later */
 112                          op,
 113                          get_irn_mode(n),
 114                          get_irn_arity(n),
 115                          get_irn_in(n) + 1);
 116
 117
 118         /* Copy the attributes.  These might point to additional data.  If this
 119            was allocated on the old obstack the pointers now are dangling.  This
 120            frees e.g. the memory of the graph_arr allocated in new_immBlock. */
 121         copy_node_attr(irg, n, nn);
 122         set_irn_link(n, nn);
 123
 124         /* fix the irg for nodes containing a reference to it */
 125         if (ir_has_irg_ref(nn)) {
 126                 nn->attr.block.irg.irg = irg;
 127         }
 128 }
 129
 130 ir_node *irn_copy_into_irg(const ir_node *node, ir_graph *irg)
 131 {
 132         ir_node  *block = NULL;
 133         ir_op    *op    = get_irn_op(node);
 134         int       arity = get_irn_arity(node);
 135         dbg_info *dbgi  = get_irn_dbg_info(node);
 136         ir_mode  *mode  = get_irn_mode(node);
 137         ir_node  *res;
 138         int       n_deps;
 139         int       i;
 140
 141         if (op != op_Block)
 142                 block = get_nodes_block(node);
 143
 144         if (op->opar == oparity_dynamic) {
 145                 int i;
 146                 res = new_ir_node(dbgi, irg, block, op, mode, -1, NULL);
 147                 for (i = 0; i < arity; ++i) {
 148                         ir_node *in = get_irn_n(node, i);
 149                         add_irn_n(res, in);
 150                 }
 151         } else {
 152                 ir_node **ins = get_irn_in(node)+1;
 153                 res = new_ir_node(dbgi, irg, block, op, mode, arity, ins);
 154         }
 155
 156         /* copy the attributes */
 157         copy_node_attr(irg, node, res);
 158
 159         /* duplicate dependency edges */
 160         n_deps = get_irn_deps(node);
 161         for (i = 0; i < n_deps; ++i) {
 162                 ir_node *dep = get_irn_dep(node, i);
 163                 add_irn_dep(res, dep);
 164         }
 165
 166         return res;
 167 }
 168
 169 ir_node *exact_copy(const ir_node *node)
 170 {
 171         return irn_copy_into_irg(node, get_irn_irg(node));
 172 }
 173
 174 static ir_node *get_new_node(const ir_node *old_node)
 175 {
 176         return (ir_node*) get_irn_link(old_node);
 177 }
 178
 179 void irn_rewire_inputs(ir_node *node)
 180 {
 181         ir_node *new_node;
 182         int      arity;
 183         int      i;
 184
 185         new_node = get_new_node(node);
 186
 187         if (!is_Block(node)) {
 188                 ir_node *block     = get_nodes_block(node);
 189                 ir_node *new_block = get_new_node(block);
 190                 set_nodes_block(new_node, new_block);
 191         }
 192
 193         arity = get_irn_arity(new_node);
 194         for (i = 0; i < arity; ++i) {
 195                 ir_node *in     = get_irn_n(node, i);
 196                 ir_node *new_in = get_new_node(in);
 197                 set_irn_n(new_node, i, new_in);
 198         }
 199
 200         /* Now the new node is complete. We can add it to the hash table for CSE. */
 201         add_identities(new_node);
 202 }
 203
 204 void firm_pset_dump(pset *set)
 205 {
 206         void *obj;
 207
 208         foreach_pset(set, void*, obj) {
 209                 ir_fprintf(stderr, "%+F\n", obj);
 210         }
 211 }