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