nsz Git - libfirm/blob - include/libfirm/irgraph.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    Entry point to the representation of procedure code.
  23  * @author   Martin Trapp, Christian Schaefer, Goetz Lindenmaier
  24  * @version  $Id$
  25  */
  26 #ifndef FIRM_IR_IRGRAPH_H
  27 #define FIRM_IR_IRGRAPH_H
  28
  29 #include <stddef.h>
  30
  31 #include "firm_types.h"
  32
  33 /**
  34  * @page ir_graph   The struct ir_graph
  35  *
  36  * This struct contains all information about a procedure.
  37  * It's allocated directly to memory.
  38  *
  39  * The fields of ir_graph:
  40  *
  41  * - ent             The entity describing this procedure.
  42  *
  43  * The beginning and end of a graph:
  44  *
  45  * - start_block     This ir_node is the block that contains the unique
  46  *                   start node of the procedure.  With it it contains
  47  *                   the Proj's on starts results.
  48  *                   Further all Const nodes are placed in the start block.
  49  * - start           This ir_node is the unique start node of the procedure.
  50  *
  51  * - end_block       This ir_node is the block that contains the unique
  52  *                   end node of the procedure.  This block contains no
  53  *                   further nodes.
  54  * - end             This ir_node is the unique end node of the procedure.
  55  *
  56  * The following nodes are Projs from the Start node, held in ir_graph for
  57  * simple access:
  58  *
  59  * - frame           The ir_node producing the pointer to the stack frame of
  60  *                   the procedure as output.  This is the Proj node on the
  61  *                   third output of the start node.  This output of the start
  62  *                   node is tagged as pns_frame_base.  In FIRM most local
  63  *                   variables are modeled as data flow edges.  Static
  64  *                   allocated arrays can not be represented as data flow
  65  *                   edges. Therefore FIRM has to represent them in the stack
  66  *                   frame.
  67  *
  68  * - globals         This models a pointer to a space in the memory where
  69  *                   _all_ global things are held.  Select from this pointer
  70  *                   with a Sel node the pointer to a global variable /
  71  *                   procedure / compiler known function... .
  72  *
  73  * - tls             This models a pointer to a space in the memory where
  74  *                   thread local things are held.  Select from this pointer
  75  *                   with a Sel node the pointer to a thread local variable.
  76  *
  77  * - args            The ir_node that produces the arguments of the method as
  78  *                   it's result.  This is a Proj node on the fourth output of
  79  *                   the start node.  This output is tagged as pn_Start_T_args.
  80  *
  81  * - proj_args       The proj nodes of the args node.
  82  *
  83  * - bad             The Bad node is an auxiliary node. It is needed only once,
  84  *                   so there is this globally reachable node.
  85  *
  86  * - no_mem          The NoMem node is an auxiliary node. It is needed only once,
  87  *                   so there is this globally reachable node.
  88  *
  89  * Data structures that are private to a graph:
  90  *
  91  * - obst            An obstack that contains all nodes.
  92  *
  93  * - current_block   A pointer to the current block.  Any node created with
  94  *                   one of the node constructors (new_<opcode>) are assigned
  95  *                   to this block.  It can be set with set_cur_block(block).
  96  *                   Only needed for ir construction.
  97  *
  98  * - params/n_loc    An int giving the number of local variables in this
  99  *                  procedure.  This is needed for ir construction. Name will
 100  *                   be changed.
 101  *
 102  * - value_table     This hash table (pset) is used for global value numbering
 103  *                   for optimizing use in iropt.c.
 104  *
 105  * - Phi_in_stack;   a stack needed for automatic Phi construction, needed only
 106  *                   during ir construction.
 107  *
 108  * - visited         A int used as flag to traverse the ir_graph.
 109  *
 110  * - block_visited    A int used as a flag to traverse block nodes in the graph.
 111  */
 112
 113 /** Global variable holding the current ir graph.
 114  *
 115  *  This global variable is used by the ir construction
 116  *  interface in ircons and by the optimizations.
 117  *  Further it is set by all walker functions.
 118  */
 119 extern ir_graph *current_ir_graph;
 120
 121 ir_graph *get_current_ir_graph(void);
 122 void      set_current_ir_graph(ir_graph *graph);
 123
 124 #ifdef INTERPROCEDURAL_VIEW
 125 /** This flag indicate the current view. The behavior of some methods
 126  * (get_irn_*, set_irn_*) is influenced by this flag. */
 127 int get_interprocedural_view(void);
 128 void set_interprocedural_view(int state);
 129 #endif
 130
 131 /**
 132  * Create a new ir graph to build ir for a procedure.
 133  *
 134  * @param ent    A pointer to an entity representing the procedure,
 135  *               i.e., the type of the entity must be of a method type.
 136  *
 137  * @param n_loc  The number of local variables in this procedure including
 138  *               the procedure parameters.
 139  *
 140  * This constructor generates the basic infrastructure needed to
 141  * represent a procedure in FIRM.
 142  *
 143  * It allocates an ir_graph and sets the field irg of the entity ent
 144  * as well as current_ir_graph to point to this graph.
 145  * Further it allocates the following nodes needed for every
 146  * procedure:
 147  *
 148  * - The start block containing a start node and Proj nodes for it's
 149  *   seven results (X, M, P, P, P, T, P).
 150  * - The end block containing an end node. This block is not matured
 151  *   after executing new_ir_graph() as predecessors need to be added to it.
 152  *   (Maturing a block means fixing it's number of predecessors.)
 153  * - The current block, which is empty and also not matured.
 154  *
 155  * Further it enters the global store into the data structure of the start
 156  * block that contains all valid values in this block (set_store()).  This
 157  * data structure is used to build the Phi nodes and removed after
 158  * completion of the graph.  There is no path from end to start in the
 159  * graph after calling ir_graph.
 160  *
 161  * The op_pin_state of the graph is set to "op_pin_state_pinned"
 162  * if no global cse was performed on the graph.
 163  * It is set to "op_pin_state_floats" if global cse was performed
 164  * (and during construction: did actually change something).
 165  * Code placement is necessary.
 166  *
 167  * @see new_pseudo_ir_graph()
 168  */
 169 ir_graph *new_ir_graph(ir_entity *ent, int n_loc);
 170
 171 /** Frees the passed irgraph.
 172  * Deallocates all nodes in this graph and the ir_graph structure.
 173  * Sets the field irgraph in the corresponding entity to NULL.
 174  * Does not remove the irgraph from the list in irprog (requires
 175  * inefficient search, call remove_irp_irg by hand).
 176  * Does not free types, entities or modes that are used only by this
 177  * graph, nor the entity standing for this graph.
 178  */
 179 void free_ir_graph(ir_graph *irg);
 180
 181 /* --- access routines for all ir_graph attributes --- */
 182
 183 /**
 184  *   Checks whether a pointer points to a ir graph.
 185  *
 186  *   @param thing     an arbitrary pointer
 187  *
 188  *   @return
 189  *       true if the thing is a IR graph, else false
 190  */
 191 int      is_ir_graph(const void *thing);
 192
 193 /** Returns the entity of an IR graph. */
 194 ir_entity *get_irg_entity(const ir_graph *irg);
 195 /** Sets the entity of an IR graph. */
 196 void       set_irg_entity(ir_graph *irg, ir_entity *ent);
 197
 198 /** Returns the frame type of an IR graph. */
 199 ir_type *get_irg_frame_type(ir_graph *irg);
 200 /** Sets the frame type of an IR graph. */
 201 void     set_irg_frame_type(ir_graph *irg, ir_type *ftp);
 202
 203 /** Returns the value parameter type of an IR graph. */
 204 ir_type *get_irg_value_param_type(ir_graph *irg);
 205
 206 /** Returns the start block of an IR graph. */
 207 ir_node *get_irg_start_block(const ir_graph *irg);
 208 /** Sets the start block of an IR graph. */
 209 void     set_irg_start_block(ir_graph *irg, ir_node *node);
 210
 211 /** Returns the Start node of an IR graph. */
 212 ir_node *get_irg_start(const ir_graph *irg);
 213 /** Sets the Start node of an IR graph. */
 214 void     set_irg_start(ir_graph *irg, ir_node *node);
 215
 216 /** Returns the end block of an IR graph. */
 217 ir_node *get_irg_end_block(const ir_graph *irg);
 218 /** Sets the end block of an IR graph. */
 219 void     set_irg_end_block(ir_graph *irg, ir_node *node);
 220
 221 /** Returns the End node of an IR graph. */
 222 ir_node *get_irg_end(const ir_graph *irg);
 223 /** Sets the End node of an IR graph. */
 224 void     set_irg_end(ir_graph *irg, ir_node *node);
 225
 226 /* The fields end_reg and end_except contain the end nodes of the
 227    interprocedural view.  If the view is not constructed they contain
 228    the normal end node. */
 229 ir_node *get_irg_end_reg(const ir_graph *irg);
 230 void     set_irg_end_reg(ir_graph *irg, ir_node *node);
 231
 232 ir_node *get_irg_end_except(const ir_graph *irg);
 233 void     set_irg_end_except(ir_graph *irg, ir_node *node);
 234
 235 /** Returns the node that represents the initial control flow of the given IR graph. */
 236 ir_node *get_irg_initial_exec(const ir_graph *irg);
 237 /** Sets the node that represents the initial control of the given IR graph. */
 238 void     set_irg_initial_exec(ir_graph *irg, ir_node *node);
 239
 240 /** Returns the node that represents the frame pointer of the given IR graph. */
 241 ir_node *get_irg_frame(const ir_graph *irg);
 242 /** Sets the node that represents the frame pointer of the given IR graph. */
 243 void     set_irg_frame(ir_graph *irg, ir_node *node);
 244
 245 /** Returns the node that represents the tls pointer of the given IR graph. */
 246 ir_node *get_irg_tls(const ir_graph *irg);
 247 /** Sets the node that represents the tls pointer of the given IR graph. */
 248 void     set_irg_tls(ir_graph *irg, ir_node *node);
 249
 250 /** Returns the node that represents the initial memory of the given IR graph. */
 251 ir_node *get_irg_initial_mem(const ir_graph *irg);
 252 /** Sets the node that represents the initial memory of the given IR graph. */
 253 void     set_irg_initial_mem(ir_graph *irg, ir_node *node);
 254
 255 /** Returns the node that represents the argument pointer of the given IR graph. */
 256 ir_node *get_irg_args(const ir_graph *irg);
 257 /** Sets the node that represents the argument pointer of the given IR graph. */
 258 void     set_irg_args(ir_graph *irg, ir_node *node);
 259
 260 /** Returns the current block of an IR graph. */
 261 ir_node *get_irg_current_block(const ir_graph *irg);
 262 /** Sets the current block of an IR graph. */
 263 void     set_irg_current_block(ir_graph *irg, ir_node *node);
 264
 265 /** Returns the Bad node of the given IR graph.  Use new_Bad() instead!! */
 266 ir_node *get_irg_bad(const ir_graph *irg);
 267 void     set_irg_bad(ir_graph *irg, ir_node *node);
 268
 269 /** Returns the NoMem node of the given IR graph.  Use new_NoMem() instead!! */
 270 ir_node *get_irg_no_mem(const ir_graph *irg);
 271 void     set_irg_no_mem(ir_graph *irg, ir_node *node);
 272
 273 /** Returns the number of value numbers of an IR graph. */
 274 int      get_irg_n_locs(ir_graph *irg);
 275
 276 /** Returns the graph number. */
 277 long     get_irg_graph_nr(const ir_graph *irg);
 278
 279 /**
 280  * Returns the graph number. This is a unique number for the graph and is
 281  * smaller than get_irp_last_idx()
 282  * Note: you cannot use this number for get_irp_irg()
 283  */
 284 int get_irg_idx(const ir_graph *irg);
 285
 286 /**
 287  * Get the node for an index.
 288  * @param irg The graph.
 289  * @param idx The index you want the node for.
 290  * @return    The node with that index or NULL, if there is no node with that index.
 291  * @note      The node you got might be dead.
 292  */
 293 ir_node *get_idx_irn(ir_graph *irg, unsigned idx);
 294
 295
 296 /********************************************************************************/
 297 /* States of an ir_graph.                                                       */
 298 /********************************************************************************/
 299
 300 /*
 301    information associated with the graph.  Optimizations invalidate these
 302    states.  */
 303
 304 /** The states of an ir graph.
 305  *
 306  * state phase values: phase_building, phase_high, phase_low, phase_backend.
 307  *
 308  * The graph is in phase_building during construction of the irgraph.
 309  * The construction is finished by a call to finalize_cons().
 310  *
 311  * Finalize_cons() sets the state to phase_high.  All standard Firm nodes are
 312  * allowed.
 313  *
 314  * To get the irgraph into phase_low all Sel nodes must be removed and
 315  * replaced by explicit address computations.  SymConst size and
 316  * type tag nodes must be removed (@@@ really?).  Initialization of
 317  * memory allocated by Alloc must be explicit.  @@@ More conditions?
 318  *
 319  * phase_backend is set if architecture specific machine nodes are inserted
 320  * (and probably most standard Firm are removed).
 321  */
 322 typedef enum {
 323         phase_building,  /**< The graph is still being constructed. */
 324         phase_high,      /**< The construction of the graph is finish, high level nodes may be present. */
 325         phase_low,       /**< High level nodes are removed. */
 326         phase_backend    /**< The graph is taken by the backend.  Machine specific nodes may be present. */
 327 } irg_phase_state;
 328
 329 /** Returns the phase_state of an IR graph. */
 330 irg_phase_state get_irg_phase_state(const ir_graph *irg);
 331
 332 /** Sets the phase state of an IR graph. */
 333 void set_irg_phase_state(ir_graph *irg, irg_phase_state state);
 334
 335 /** Sets the phase of the given IR graph to low. */
 336 #define set_irg_phase_low(irg)  set_irg_phase_state(irg, phase_low)
 337
 338 /** state: op_pin_state_pinned
 339    The graph is "op_pin_state_pinned" if all nodes are associated with a basic block.
 340    It is in state "op_pin_state_floats" if nodes are in arbitrary blocks.  In state
 341    "op_pin_state_floats" the block predecessor is set in all nodes, but this can be an
 342    invalid block, i.e., the block is not a dominator of all the uses of
 343    the node.
 344    The enum op_pin_state is defined in irop.h. */
 345 op_pin_state get_irg_pinned(const ir_graph *irg);
 346
 347 /** state: outs_state
 348  *  Outs are the back edges or def-use edges of ir nodes.
 349  *  Values:  outs_none, outs_consistent, outs_inconsistent */
 350 typedef enum {
 351         outs_none,         /**< Outs are not computed, no memory is allocated. */
 352         outs_consistent,   /**< Outs are computed and correct. */
 353         outs_inconsistent  /**< Outs have been computed, memory is still allocated,
 354                                 but the graph has been changed since. */
 355 } irg_outs_state;
 356 irg_outs_state get_irg_outs_state(const ir_graph *irg);
 357 void           set_irg_outs_inconsistent(ir_graph *irg);
 358
 359 /** state:  extended basic block state. */
 360 typedef enum {
 361         extblk_none    = 0,  /**< No extended basic block information is constructed. Default. */
 362         extblk_valid   = 1,  /**< Extended basic block information is valid. */
 363         extblk_invalid = 2   /**< Extended basic block information is constructed but invalid. */
 364 } irg_extblk_state;
 365 irg_extblk_state get_irg_extblk_state(const ir_graph *irg);
 366 void             set_irg_extblk_inconsistent(ir_graph *irg);
 367
 368 /** state: dom_state
 369  * Signals the state of the dominator / post dominator information.
 370  */
 371 typedef enum {
 372         dom_none,             /**< dominator are not computed, no memory is allocated */
 373         dom_consistent,       /**< dominator information is computed and correct */
 374         dom_inconsistent      /**< dominator information is computed but the graph has been changed since */
 375 } irg_dom_state;
 376
 377 /** returns the dominator state of an IR graph. */
 378 irg_dom_state get_irg_dom_state(const ir_graph *irg);
 379
 380 /** returns the post dominator state of an IR graph. */
 381 irg_dom_state get_irg_postdom_state(const ir_graph *irg);
 382
 383 /** sets the dominator and post dominator state of an IR graph to inconsistent. */
 384 void set_irg_doms_inconsistent(ir_graph *irg);
 385
 386 /** state: loopinfo_state
 387  *  Loop information describes the loops within the control and
 388  *  data flow of the procedure.
 389  */
 390 typedef enum {
 391         loopinfo_none             = 0,       /**< No loop information is constructed. Default. */
 392         loopinfo_constructed      = 1,       /**< Some kind of loop information is constructed. */
 393         loopinfo_valid            = 2,       /**< Loop information is valid. */
 394         loopinfo_cf               = 4,       /**< Loop information constructed for control flow only. */
 395         loopinfo_inter            = 8,       /**< Loop information for interprocedural view. */
 396
 397         /** IntRAprocedural loop information constructed and valid. */
 398         loopinfo_consistent         = loopinfo_constructed | loopinfo_valid,
 399         /** IntRAprocedural loop information constructed and invalid. */
 400         loopinfo_inconsistent       = loopinfo_constructed,
 401
 402         /** IntERprocedural loop information constructed and valid. */
 403         loopinfo_ip_consistent      = loopinfo_constructed | loopinfo_inter | loopinfo_valid,
 404         /** IntERprocedural loop information constructed and invalid. */
 405         loopinfo_ip_inconsistent    = loopinfo_constructed | loopinfo_inter,
 406
 407         /** IntRAprocedural control loop information constructed and valid. */
 408         loopinfo_cf_consistent      = loopinfo_constructed | loopinfo_cf | loopinfo_valid,
 409         /** IntRAprocedural control loop information constructed and invalid. */
 410         loopinfo_cf_inconsistent    = loopinfo_constructed | loopinfo_cf,
 411
 412         /** IntERprocedural control loop information constructed and valid. */
 413         loopinfo_cf_ip_consistent   = loopinfo_constructed | loopinfo_cf | loopinfo_inter | loopinfo_valid,
 414         /** IntERprocedural control loop information constructed and invalid. */
 415         loopinfo_cf_ip_inconsistent = loopinfo_constructed | loopinfo_cf | loopinfo_inter
 416 } irg_loopinfo_state;
 417
 418 /** Return the current loop information state. */
 419 irg_loopinfo_state get_irg_loopinfo_state(const ir_graph *irg);
 420
 421 /** Sets the current loop information state. */
 422 void set_irg_loopinfo_state(ir_graph *irg, irg_loopinfo_state s);
 423
 424 /** Sets the loop information state to the appropriate inconsistent state.
 425  *  If state is 'none' does not change. */
 426 void set_irg_loopinfo_inconsistent(ir_graph *irg);
 427 /** Sets the loop information state to the appropriate inconsistent state.
 428  *  If state is 'none' does not change.
 429  *  Does this for all irgs. */
 430 void set_irp_loopinfo_inconsistent(void);
 431
 432 /** state: callee_information_state
 433  *  Call nodes contain a list of possible callees.  This list must be
 434  *  computed by an analysis.
 435  *
 436  *  It's strange that this state is administered on irg basis, as the
 437  *  information must be computed for the whole program, or not?
 438  */
 439 typedef enum {
 440         irg_callee_info_none,
 441         irg_callee_info_consistent,
 442         irg_callee_info_inconsistent
 443 } irg_callee_info_state;
 444
 445 /** Returns the callee_info_state of an IR graph. */
 446 irg_callee_info_state get_irg_callee_info_state(const ir_graph *irg);
 447
 448 /** Sets the callee_info_state of an IR graph. */
 449 void                  set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s);
 450
 451 /** property:
 452  *  Tells how to handle an ir graph in inlining.
 453  */
 454 typedef enum {
 455         irg_inline_any,            /**< No restriction on inlining. Default. */
 456         irg_inline_forbidden,      /**< The graph must not be inlined. */
 457         irg_inline_recomended,     /**< The graph should be inlined. */
 458         irg_inline_forced,         /**< The graph must be inlined. */
 459         irg_inline_forced_no_body  /**< The graph must be inlined. No body is allowed
 460                                         to be emitted. */
 461 } irg_inline_property;
 462
 463 /** Returns the inline property of a graph. */
 464 irg_inline_property get_irg_inline_property(const ir_graph *irg);
 465 /** Sets the inline property of a graph. */
 466 void set_irg_inline_property(ir_graph *irg, irg_inline_property s);
 467
 468 /**
 469  * Returns the mask of the additional graph properties.
 470  * The properties are automatically inherited from the method type
 471  * if they were not set using set_irg_additional_properties() or
 472  * set_irg_additional_property().
 473  *
 474  * @return a bitset of mtp_additional_property values
 475  */
 476 unsigned get_irg_additional_properties(const ir_graph *irg);
 477
 478 /** Sets the mask of the additional graph properties. */
 479 void set_irg_additional_properties(ir_graph *irg, unsigned property_mask);
 480
 481 /** Sets one additional graph property. */
 482 void set_irg_additional_property(ir_graph *irg, mtp_additional_property flag);
 483
 484 /** A void * field to link arbitrary information to the node. */
 485 void  set_irg_link (ir_graph *irg, void *thing);
 486 void *get_irg_link (const ir_graph *irg);
 487
 488 /** Increments visited flag by one.
 489  *  @see also: get_irn_visited() get_irg_block_visited(). */
 490 void         inc_irg_visited(ir_graph *irg);
 491 ir_visited_t get_irg_visited(const ir_graph *irg);
 492 void         set_irg_visited(ir_graph *irg, ir_visited_t i);
 493 /** An interprocedural flag valid for all irgs.
 494  *  @see also: get_irn_visited() get_irg_block_visited(). */
 495 ir_visited_t get_max_irg_visited(void);
 496 void         set_max_irg_visited(int val);
 497 ir_visited_t inc_max_irg_visited(void);
 498
 499 /** Increments block_visited by one.
 500  *  @see also: get_irn_visited() get_irg_block_visited(). */
 501 void         inc_irg_block_visited(ir_graph *irg);
 502 ir_visited_t get_irg_block_visited(const ir_graph *irg);
 503 void         set_irg_block_visited(ir_graph *irg, ir_visited_t i);
 504
 505 /**
 506  * Debug helpers: You can indicate whether you are currently using visited or
 507  * block_visited flags. If NDEBUG is not defined, then the compiler will abort
 508  * if 2 parties try to use the flags.
 509  */
 510 enum ir_resources_enum_t {
 511         /* local (irg) resources */
 512         IR_RESOURCE_BLOCK_VISITED = 1 << 0,  /**< Block visited flags are used. */
 513         IR_RESOURCE_BLOCK_MARK    = 1 << 1,  /**< Block mark bits are used. */
 514         IR_RESOURCE_IRN_VISITED   = 1 << 2,  /**< IR-node visited flags are used. */
 515         IR_RESOURCE_IRN_LINK      = 1 << 3,  /**< IR-node link fields are used. */
 516         IR_RESOURCE_LOOP_LINK     = 1 << 4,  /**< IR-loop link fields are used. */
 517         IR_RESOURCE_PHI_LIST      = 1 << 5,  /**< Block Phi lists are used. */
 518         IR_RESOURCE_IRG_LINK      = 1 << 6,  /**< IR-graph link fields used. */
 519
 520         /* global (irp) resources */
 521         IR_RESOURCE_ENTITY_LINK   = 1 << 8,  /**< IR-entity link fields are used. */
 522         IR_RESOURCE_TYPE_VISITED  = 1 << 9,  /**< type visited flags */
 523
 524         /* masks */
 525         IR_RESOURCE_LOCAL_MASK    = 0x00FF,  /**< Mask for all local resources. */
 526         IR_RESOURCE_GLOBAL_MASK   = 0xFF00   /**< Mask for all global resources. */
 527 };
 528 typedef unsigned ir_resources_t;
 529
 530 #ifndef NDEBUG
 531 void ir_reserve_resources(ir_graph *irg, ir_resources_t resources);
 532 void ir_free_resources(ir_graph *irg, ir_resources_t resources);
 533 ir_resources_t ir_resources_reserved(const ir_graph *irg);
 534 #else
 535 #define ir_reserve_resources(irg,resources)  (void)0
 536 #define ir_free_resources(irg,resources)     (void)0
 537 #define ir_resources_reserved(irg)           0
 538 #endif
 539
 540 /**
 541  * Graph State
 542  */
 543 typedef enum {
 544         IR_GRAPH_STATE_KEEP_MUX = 1 << 0,  /**< should perform no further optimisations on Mux nodes */
 545         IR_GRAPH_STATE_ARCH_DEP = 1 << 1,  /**< should not construct more nodes which irarch potentially breaks down */
 546 } ir_graph_state_t;
 547
 548 /** set some state flags on the graph (this does not clear the other flags) */
 549 void set_irg_state(ir_graph *irg, ir_graph_state_t state);
 550 /** clear some state flags of the graph */
 551 void clear_irg_state(ir_graph *irg, ir_graph_state_t state);
 552 /** query wether a set of graph state flags are activated */
 553 int is_irg_state(const ir_graph *irg, ir_graph_state_t state);
 554
 555 /** Normalization: Move Proj nodes into the same block as its predecessors */
 556 void normalize_proj_nodes(ir_graph *irg);
 557
 558 /** Set a description for local value n. */
 559 void set_irg_loc_description(ir_graph *irg, int n, void *description);
 560
 561 /** Get the description for local value n. */
 562 void *get_irg_loc_description(ir_graph *irg, int n);
 563
 564 /** Returns a estimated node count of the irg. This count is updated
 565  * after every irg_walk_graph().
 566  */
 567 unsigned get_irg_estimated_node_cnt(const ir_graph *irg);
 568
 569 /** Returns the last irn index for this graph. */
 570 unsigned get_irg_last_idx(const ir_graph *irg);
 571
 572 /** Returns the floating point model of this graph. */
 573 unsigned get_irg_fp_model(const ir_graph *irg);
 574
 575 /** Sets a floating point model for this graph. */
 576 void set_irg_fp_model(ir_graph *irg, unsigned model);
 577
 578 /**
 579  * Access custom graph data.
 580  * The data must have been registered with
 581  * register_additional_graph_data() before.
 582  * @param graph The graph to get the data from.
 583  * @param type The type of the data you registered.
 584  * @param off The value returned by register_additional_graph_data().
 585  * @return A pointer of type @p type.
 586  */
 587 #define get_irg_data(graph,type,off) \
 588         (assert(off > 0 && "Invalid graph data offset"), (type *) ((char *) (graph) - (off)))
 589
 590 /**
 591  * Get the pointer to the node some custom data belongs to.
 592  * @param data The pointer to the custom data.
 593  * @param off The number as returned by register_additional_graph_data().
 594  * @return A pointer to the ir node the custom data belongs to.
 595  */
 596 #define get_irg_data_base(data,off) \
 597         (assert(off > 0 && "Invalid graph data offset"), (ir_graph *) ((char *) (data) + (off)))
 598
 599 /**
 600  * Request additional data to be allocated with an ir graph.
 601  * @param size The size of the additional data required.
 602  * @return A positive number, if the operation was successful, which
 603  * must be passed to the access macro get_irg_data(), 0 if the
 604  * registration failed.
 605  */
 606 size_t register_additional_graph_data(size_t size);
 607
 608 #endif