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