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