nsz Git - libfirm/blob - include/libfirm/iredges.h

   1 /*
   2  * Copyright (C) 1995-2008 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   Public header for the automatically updating outs.
  23  * @author  Sebastian Hack
  24  * @date    3.2.2005
  25  * @version $Id$
  26  */
  27 #ifndef FIRM_IR_IREDGES_H
  28 #define FIRM_IR_IREDGES_H
  29
  30 #include "firm_types.h"
  31 #include "iredgekinds.h"
  32
  33 /**
  34  * Get the first edge pointing to some node.
  35  * @note There is no order on out edges. First in this context only
  36  * means, that you get some starting point into the list of edges.
  37  * @param irn The node.
  38  * @param kind The kind of the edge.
  39  * @return The first out edge that points to this node.
  40  */
  41 const ir_edge_t *get_irn_out_edge_first_kind(const ir_node *irn, ir_edge_kind_t kind);
  42
  43 /**
  44  * Get the next edge in the out list of some node.
  45  * @param irn The node.
  46  * @param last The last out edge you have seen.
  47  * @return The next out edge in @p irn 's out list after @p last.
  48  */
  49 const ir_edge_t *get_irn_out_edge_next(const ir_node *irn, const ir_edge_t *last);
  50
  51 /**
  52  * A convenience iteration macro over all out edges of a node.
  53  * @param irn  The node.
  54  * @param kind The edge's kind.
  55  * @param edge An ir_edge_t pointer which shall be set to the current
  56  * edge.
  57  */
  58 #define foreach_out_edge_kind(irn, edge, kind) \
  59         for(edge = get_irn_out_edge_first_kind(irn, kind); edge; edge = get_irn_out_edge_next(irn, edge))
  60
  61 /**
  62  * A convenience iteration macro over all out edges of a node, which is safe
  63  * against alteration of the current edge.
  64  *
  65  * @param irn  The node.
  66  * @param edge An ir_edge_t pointer which shall be set to the current edge.
  67  * @param ne   The next edge, enables alteration safe edge processing.
  68  */
  69 #define foreach_out_edge_kind_safe(irn, edge, ne, kind) \
  70         for((edge) = (get_irn_out_edge_first_kind(irn, kind)), (ne) = ((edge) ? (get_irn_out_edge_next(irn, edge)) : NULL); \
  71                 edge; (edge) = (ne), (ne) = ((edge) ? (get_irn_out_edge_next(irn, edge)) : NULL))
  72
  73 /**
  74  * Convenience macro for normal out edges.
  75  */
  76 #define foreach_out_edge(irn, edge)            foreach_out_edge_kind(irn, edge, EDGE_KIND_NORMAL)
  77
  78 /**
  79  * Convenience macro for normal out edges.
  80  */
  81 #define foreach_out_edge_safe(irn, edge, tmp)  foreach_out_edge_kind_safe(irn, edge, tmp, EDGE_KIND_NORMAL)
  82
  83 /**
  84  * A convenience iteration macro for all control flow edges.
  85  */
  86 #define foreach_block_succ(bl, edge)           foreach_out_edge_kind(bl, edge, EDGE_KIND_BLOCK)
  87
  88 /*
  89  * Get the source node of an edge.
  90  * @param edge The edge.
  91  * @return The source node of that edge.
  92  */
  93 ir_node *get_edge_src_irn(const ir_edge_t *edge);
  94
  95 /**
  96  * Get the position of an edge.
  97  * @param edge The edge.
  98  * @return The position in the in array of that edges source.
  99  */
 100 int get_edge_src_pos(const ir_edge_t *edge);
 101
 102 /**
 103  * Get the edge object of an outgoing edge at a node.
 104  * @param   irg The graph, the node is in.
 105  * @param   irn The node at which the edge originates.
 106  * @param   pos The position of the edge.
 107  * @return      The corresponding edge object or NULL,
 108  *              if no such edge exists.
 109  */
 110 const ir_edge_t *get_irn_edge_kind(ir_graph *irg, const ir_node *irn, int pos, ir_edge_kind_t kind);
 111
 112 /**
 113  * Get the number of registered out edges for a specific kind.
 114  * @param irn The node.
 115  * @param kind The kind.
 116  */
 117 int get_irn_n_edges_kind(const ir_node *irn, ir_edge_kind_t kind);
 118
 119 /**
 120  * Check, if the out edges are activated.
 121  *
 122  * @param irg   The graph.
 123  * @param kind  The edge kind.
 124  *
 125  * @return 1, if the edges are present for the given irg, 0 if not.
 126  */
 127 int edges_activated_kind(const ir_graph *irg, ir_edge_kind_t kind);
 128
 129 /**
 130  * Activate the edges for an irg.
 131  *
 132  * @param irg   The graph to activate the edges for.
 133  * @param kind  The edge kind.
 134  */
 135 void edges_activate_kind(ir_graph *irg, ir_edge_kind_t kind);
 136
 137 /**
 138  * Deactivate the edges for an irg.
 139  *
 140  * @param irg   The graph.
 141  * @param kind  The edge kind.
 142  */
 143 void edges_deactivate_kind(ir_graph *irg, ir_edge_kind_t kind);
 144
 145 /**
 146  * Reroute edges of a specified kind from an old node to
 147  * a new one.
 148  *
 149  * @param old   the old node
 150  * @param nw    the new node
 151  * @param kind  the edge kind
 152  * @param irg   the graph on which the rerouting occurs
 153  */
 154 void edges_reroute_kind(ir_node *old, ir_node *nw, ir_edge_kind_t kind, ir_graph *irg);
 155
 156 /**
 157  * Verifies the out edges of graph @p irg.
 158  * @return 1 if a problem was found, 0 otherwise
 159  */
 160 int edges_verify(ir_graph *irg);
 161
 162 /**
 163  * Set edge verification flag.
 164  */
 165 void edges_init_dbg(int do_dbg);
 166
 167 /************************************************************************/
 168 /* Begin Old Interface                                                  */
 169 /************************************************************************/
 170
 171 const ir_edge_t *get_irn_edge(ir_graph *irg, const ir_node *src, int pos);
 172
 173 #define edges_reroute(old, nw, irg)                     edges_reroute_kind(old, nw, EDGE_KIND_NORMAL, irg)
 174 #define edges_activated(irg)                            (edges_activated_kind(irg, EDGE_KIND_NORMAL) && edges_activated_kind(irg, EDGE_KIND_BLOCK))
 175
 176 #ifndef get_irn_n_edges
 177 #define get_irn_n_edges(irn)                            get_irn_n_edges_kind(irn, EDGE_KIND_NORMAL)
 178 #endif
 179
 180 #ifndef get_irn_out_edge_first
 181 #define get_irn_out_edge_first(irn)                     get_irn_out_edge_first_kind(irn, EDGE_KIND_NORMAL)
 182 #endif
 183
 184 #ifndef get_block_succ_first
 185 #define get_block_succ_first(irn)                       get_irn_out_edge_first_kind(irn, EDGE_KIND_BLOCK)
 186 #endif
 187
 188 #ifndef get_block_succ_next
 189 #define get_block_succ_next(irn, last)                  get_irn_out_edge_next(irn, last)
 190 #endif
 191
 192 /**
 193  * Activates data and block edges for an irg.
 194  * If the irg phase is phase_backend, Dependence edges are
 195  * additionally activated.
 196  *
 197  * @param irg  The graph to activate the edges for.
 198  */
 199 void edges_activate(ir_graph *irg);
 200
 201 /**
 202  * Deactivate data and block edges for an irg.
 203  * If the irg phase is phase_backend, Dependence edges are
 204  * additionally deactivated.
 205  * @param irg  The graph.
 206  */
 207 void edges_deactivate(ir_graph *irg);
 208
 209 /**
 210  * Ensure that edges are activated.
 211  *
 212  * @param irg  the IR graph
 213  *
 214  * @return 0 if edges was deactivated before the call, 1 else
 215  */
 216 int edges_assure(ir_graph *irg);
 217
 218 /**
 219  * Ensure that edges of a given kind are activated.
 220  *
 221  * @param irg   the IR graph
 222  * @param kind  the edge kind
 223  *
 224  * @return 0 if edges was deactivated before the call, 1 else
 225  */
 226 int edges_assure_kind(ir_graph *irg, ir_edge_kind_t kind);
 227
 228 void edges_node_deleted(ir_node *irn, ir_graph *irg);
 229
 230 /**
 231  * Notify normal and block edges.
 232  */
 233 void edges_notify_edge(ir_node *src, int pos, ir_node *tgt, ir_node *old_tgt, ir_graph *irg);
 234
 235 /**
 236  * Walks only over Block nodes in the graph. Uses the block visited
 237  * flag, so that it can be interleaved with another walker.
 238  *
 239  * @param block  the start block
 240  * @param pre    the pre visit function
 241  * @param post   the post visit function
 242  * @param env    the environment for the walker
 243  */
 244 void irg_block_edges_walk(ir_node *block, irg_walk_func *pre, irg_walk_func *post, void *env);
 245
 246 /**
 247  * Reset the user's private data at offset 'offset'
 248  * The user has to remember his offset and the size of his data!
 249  * Caution: Using wrong values here can destroy other users private data!
 250  *
 251  * @param irg     the IR graph to operate on
 252  * @param offset  offset of the private data inside the edge
 253  * @param size    length of the private data inside the edge
 254  */
 255 void edges_reset_private_data(ir_graph *irg, int offset, unsigned size);
 256
 257 /************************************************************************/
 258 /* End Old Interface                                                    */
 259 /************************************************************************/
 260
 261 #endif