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  */
  26 #ifndef FIRM_IR_IREDGES_H
  27 #define FIRM_IR_IREDGES_H
  28
  29 #include "firm_types.h"
  30 #include "iredgekinds.h"
  31 #include "begin.h"
  32
  33 /**
  34  * @ingroup irana
  35  * @defgroup iredges Dynamic Reverse Edges
  36  * @{
  37  */
  38
  39 /**
  40  * Returns the first edge pointing to some node.
  41  * @note There is no order on out edges. First in this context only
  42  * means, that you get some starting point into the list of edges.
  43  * @param irn The node.
  44  * @param kind The kind of the edge.
  45  * @return The first out edge that points to this node.
  46  */
  47 FIRM_API const ir_edge_t *get_irn_out_edge_first_kind(const ir_node *irn,
  48                                                       ir_edge_kind_t kind);
  49
  50 /**
  51  * Returns the next edge in the out list of some node.
  52  * @param irn The node.
  53  * @param last The last out edge you have seen.
  54  * @return The next out edge in @p irn 's out list after @p last.
  55  */
  56 FIRM_API const ir_edge_t *get_irn_out_edge_next(const ir_node *irn,
  57                                                 const ir_edge_t *last);
  58
  59 /**
  60  * A convenience iteration macro over all out edges of a node.
  61  * @param irn  The node.
  62  * @param kind The edge's kind.
  63  * @param edge An ir_edge_t pointer which shall be set to the current
  64  * edge.
  65  */
  66 #define foreach_out_edge_kind(irn, edge, kind) \
  67         for(edge = get_irn_out_edge_first_kind(irn, kind); edge; edge = get_irn_out_edge_next(irn, edge))
  68
  69 /**
  70  * A convenience iteration macro over all out edges of a node, which is safe
  71  * against alteration of the current edge.
  72  *
  73  * @param irn  The node.
  74  * @param edge An ir_edge_t pointer which shall be set to the current edge.
  75  * @param ne   The next edge, enables alteration safe edge processing.
  76  * @param kind The kind of the edge.
  77  */
  78 #define foreach_out_edge_kind_safe(irn, edge, ne, kind) \
  79         for((edge) = (get_irn_out_edge_first_kind(irn, kind)), (ne) = ((edge) ? (get_irn_out_edge_next(irn, edge)) : NULL); \
  80                 edge; (edge) = (ne), (ne) = ((edge) ? (get_irn_out_edge_next(irn, edge)) : NULL))
  81
  82 /**
  83  * Convenience macro for normal out edges.
  84  */
  85 #define foreach_out_edge(irn, edge)            foreach_out_edge_kind(irn, edge, EDGE_KIND_NORMAL)
  86
  87 /**
  88  * Convenience macro for normal out edges.
  89  */
  90 #define foreach_out_edge_safe(irn, edge, tmp)  foreach_out_edge_kind_safe(irn, edge, tmp, EDGE_KIND_NORMAL)
  91
  92 /**
  93  * A convenience iteration macro for all control flow edges.
  94  */
  95 #define foreach_block_succ(bl, edge)           foreach_out_edge_kind(bl, edge, EDGE_KIND_BLOCK)
  96
  97 /**
  98  * Returns the source node of an edge.
  99  * @param edge The edge.
 100  * @return The source node of that edge.
 101  */
 102 FIRM_API ir_node *get_edge_src_irn(const ir_edge_t *edge);
 103
 104 /**
 105  * Returns the position of an edge.
 106  * @param edge The edge.
 107  * @return The position in the in array of that edges source.
 108  */
 109 FIRM_API int get_edge_src_pos(const ir_edge_t *edge);
 110
 111 /**
 112  * Returns the edge object of an outgoing edge at a node.
 113  * @param  irn  The node at which the edge originates.
 114  * @param  pos  The position of the edge.
 115  * @param  kind The kind of the edge.
 116  * @return      The corresponding edge object or NULL,
 117  *              if no such edge exists.
 118  */
 119 FIRM_API const ir_edge_t *get_irn_edge_kind(const ir_node *irn,
 120                                             int pos, ir_edge_kind_t kind);
 121
 122 /**
 123  * Returns the number of registered out edges for a specific kind.
 124  * @param irn The node.
 125  * @param kind The kind.
 126  */
 127 FIRM_API int get_irn_n_edges_kind(const ir_node *irn, ir_edge_kind_t kind);
 128
 129 /**
 130  * Checks if the out edges are activated.
 131  *
 132  * @param irg   The graph.
 133  * @param kind  The edge kind.
 134  *
 135  * @return 1, if the edges are present for the given irg, 0 if not.
 136  */
 137 FIRM_API int edges_activated_kind(const ir_graph *irg, ir_edge_kind_t kind);
 138
 139 /**
 140  * Activates the edges for an irg.
 141  *
 142  * @param irg   The graph to activate the edges for.
 143  * @param kind  The edge kind.
 144  */
 145 FIRM_API void edges_activate_kind(ir_graph *irg, ir_edge_kind_t kind);
 146
 147 /**
 148  * Deactivates the edges for an irg.
 149  *
 150  * @param irg   The graph.
 151  * @param kind  The edge kind.
 152  */
 153 FIRM_API void edges_deactivate_kind(ir_graph *irg, ir_edge_kind_t kind);
 154
 155 /**
 156  * Reroutes edges of a specified kind from an old node to a new one.
 157  *
 158  * @param old   the old node
 159  * @param nw    the new node
 160  * @param kind  the edge kind
 161  */
 162 FIRM_API void edges_reroute_kind(ir_node *old, ir_node *nw, ir_edge_kind_t kind);
 163
 164 /**
 165  * reroutes (normal) edges from an old node to a new node, except for the
 166  * @p exception which keeps its input even if it is old.
 167  */
 168 FIRM_API void edges_reroute_except(ir_node *old, ir_node *nw,
 169                                    ir_node *exception);
 170
 171 /**
 172  * Verifies the out edges of graph @p irg.
 173  * @return 1 if a problem was found, 0 otherwise
 174  */
 175 FIRM_API int edges_verify(ir_graph *irg);
 176
 177 /**
 178  * Verifies a certrain kind of out edges of graph @p irg.
 179  * @returns 1 if a problem was found, 0 otherwise
 180  */
 181 FIRM_API int edges_verify_kind(ir_graph *irg, ir_edge_kind_t kind);
 182
 183 /**
 184  * Sets edge verification flag.
 185  */
 186 FIRM_API void edges_init_dbg(int do_dbg);
 187
 188 /**
 189  * Creates an ir_graph pass for edges_verify().
 190  *
 191  * @param name                the name of this pass or NULL
 192  * @param assert_on_problem   assert if problems were found
 193  *
 194  * @return  the newly created ir_graph pass
 195  */
 196 FIRM_API ir_graph_pass_t *irg_verify_edges_pass(const char *name,
 197                                                 unsigned assert_on_problem);
 198
 199 /** Convenience version of edges_reroute_kind() with #EDGE_KIND_NORMAL */
 200 #define edges_reroute(old, nw)                      edges_reroute_kind(old, nw, EDGE_KIND_NORMAL)
 201 /** Conventience version of edges_activated_kind() for #EDGE_KIND_NORMAL and #EDGE_KIND_BLOCK */
 202 #define edges_activated(irg)                            (edges_activated_kind(irg, EDGE_KIND_NORMAL) && edges_activated_kind(irg, EDGE_KIND_BLOCK))
 203
 204 #ifndef get_irn_n_edges
 205 /** Conventience version of get_irn_n_edges_kind() with #EDGE_KIND_NORMAL. */
 206 #define get_irn_n_edges(irn)                            get_irn_n_edges_kind(irn, EDGE_KIND_NORMAL)
 207 #endif
 208
 209 #ifndef get_irn_out_edge_first
 210 /** Convenience version of get_irn_out_edge_first_kind() with #EDGE_KIND_NORMAL */
 211 #define get_irn_out_edge_first(irn)                     get_irn_out_edge_first_kind(irn, EDGE_KIND_NORMAL)
 212 #endif
 213
 214 #ifndef get_block_succ_first
 215 /** Convenience version of get_irn_out_edge_first_kind() with #EDGE_KIND_BLOCK */
 216 #define get_block_succ_first(irn)                       get_irn_out_edge_first_kind(irn, EDGE_KIND_BLOCK)
 217 #endif
 218
 219 #ifndef get_block_succ_next
 220 /** Convenience version of get_irn_out_edge_next() with #EDGE_KIND_BLOCK */
 221 #define get_block_succ_next(irn, last)                  get_irn_out_edge_next(irn, last)
 222 #endif
 223
 224 /**
 225  * Activates data and block edges for an irg.
 226  * If the irg phase is phase_backend, Dependence edges are
 227  * additionally activated.
 228  *
 229  * @param irg  The graph to activate the edges for.
 230  */
 231 FIRM_API void edges_activate(ir_graph *irg);
 232
 233 /**
 234  * Deactivates data and block edges for an irg.
 235  * If the irg phase is phase_backend, Dependence edges are
 236  * additionally deactivated.
 237  * @param irg  The graph.
 238  */
 239 FIRM_API void edges_deactivate(ir_graph *irg);
 240
 241 /**
 242  * Ensures that edges are activated.
 243  *
 244  * @param irg  the IR graph
 245  */
 246 FIRM_API void assure_edges(ir_graph *irg);
 247
 248 /**
 249  * Ensures that edges of a given kind are activated.
 250  *
 251  * @param irg   the IR graph
 252  * @param kind  the edge kind
 253  */
 254 FIRM_API void assure_edges_kind(ir_graph *irg, ir_edge_kind_t kind);
 255
 256 /**
 257  * Walks only over Block nodes in the graph. Uses the block visited
 258  * flag, so that it can be interleaved with another walker.
 259  *
 260  * @param block  the start block
 261  * @param pre    the pre visit function
 262  * @param post   the post visit function
 263  * @param env    the environment for the walker
 264  */
 265 FIRM_API void irg_block_edges_walk(ir_node *block, irg_walk_func *pre,
 266                                    irg_walk_func *post, void *env);
 267
 268 /** Graph walker following #EDGE_KIND_NORMAL edges. */
 269 FIRM_API void irg_walk_edges(ir_node *start, irg_walk_func *pre,
 270                              irg_walk_func *post, void *env);
 271
 272 /**
 273  * Reset the user's private data at offset 'offset'
 274  * The user has to remember his offset and the size of his data!
 275  * Caution: Using wrong values here can destroy other users private data!
 276  *
 277  * @param irg     the IR graph to operate on
 278  * @param offset  offset of the private data inside the edge
 279  * @param size    length of the private data inside the edge
 280  */
 281 FIRM_API void edges_reset_private_data(ir_graph *irg, int offset,
 282                                        unsigned size);
 283
 284 /** @} */
 285
 286 #include "end.h"
 287
 288 #endif