nsz Git - libfirm/blob - ir/ir/irtypes.h

   1 /*
   2  * Copyright (C) 1995-2011 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   Definition of the Firm IR base types, concentrated here
  23  * @author  Michael Beck
  24  * @version $Id$
  25  */
  26 #ifndef FIRM_IR_IRDEFS_H
  27 #define FIRM_IR_IRDEFS_H
  28
  29 #include "firm_types.h"
  30 #include "irdom_t.h"
  31 #include "irmode.h"
  32 #include "irnode.h"
  33 #include "irgraph.h"
  34 #include "iredgekinds.h"
  35 #include "irtypeinfo.h"
  36 #include "irextbb.h"
  37 #include "execution_frequency.h"
  38 #include "irmemory.h"
  39 #include "callgraph.h"
  40 #include "irprog.h"
  41 #include "field_temperature.h"
  42 #include "irphase.h"
  43 #include "bitset.h"
  44
  45 #include "pset.h"
  46 #include "set.h"
  47 #include "list.h"
  48 #include "obst.h"
  49 #include "vrp.h"
  50
  51 /**
  52  * List of phases. (We will add a register/unregister interface if managing
  53  * this gets too tedious)
  54  */
  55 typedef enum ir_phase_id {
  56         PHASE_FIRST,
  57         PHASE_VRP = PHASE_FIRST,
  58         PHASE_LAST = PHASE_VRP
  59 } ir_phase_id;
  60 ENUM_COUNTABLE(ir_phase_id)
  61
  62 /** The type of an ir_op. */
  63 struct ir_op {
  64         unsigned code;            /**< The unique opcode of the op. */
  65         ident *name;              /**< The name of the op. */
  66         size_t attr_size;         /**< Space needed in memory for private attributes
  67                                        */
  68         op_pin_state pin_state;   /**< How to deal with the node in CSE, PRE. */
  69         op_arity opar;            /**< The arity of operator. */
  70         int op_index;             /**< The index of the first data operand, 0 for
  71                                        most cases, 1 for Div etc. */
  72         int fragile_mem_index;    /**< index of memory input for fragile nodes */
  73         int pn_x_regular;         /**< for fragile ops the position of the
  74                                        X_regular output */
  75         int pn_x_except;          /**< for fragile ops the position of the
  76                                        X_except output */
  77         unsigned flags;           /**< Flags describing the behavior of the ir_op,
  78                                        a bitmasks of irop_flags. */
  79         unsigned tag;             /**< Some custom TAG value the op's creator set */
  80         void *attr;               /**< custom pointer where op's creator can attach
  81                                        attribute stuff to. */
  82         ir_op_ops ops;            /**< The operations of the this op. */
  83 };
  84
  85 /**
  86  * Contains relevant information about a mode.
  87  *
  88  * Necessary information about a mode is stored in this struct
  89  * which is used by the tarval module to perform calculations
  90  * and comparisons of values of a such described mode.
  91  *
  92  * ATTRIBUTES:
  93  *  -  ident *name:             Name of this mode. Two modes are different if the name is different.
  94  *  -  ir_mode_sort sort:       sort of mode specifying possible usage categories
  95  *  -  int    size:             size of the mode in Bits.
  96  *  -  unsigned sign:1:         signedness of this mode
  97  *  -  ... more to come
  98  *  -  modulo_shift             specifies for modes of kind irms_int_number
  99  *                              whether shift applies modulo to value of bits to shift
 100  *
 101  * SEE ALSO:
 102  *    The tech report 1999-44 describing FIRM and predefined modes
 103  *    tarval.h
 104  */
 105 struct ir_mode {
 106         firm_kind         kind;       /**< distinguishes this node from others */
 107         ident             *name;      /**< Name ident of this mode */
 108         ir_type           *type;      /**< corresponding primitive type */
 109
 110         /* ----------------------------------------------------------------------- */
 111         /* On changing this struct you have to evaluate the mode_are_equal function!*/
 112         ir_mode_sort      sort;          /**< coarse classification of this mode:
 113                                           int, float, reference ...
 114                                           (see irmode.h) */
 115         ir_mode_arithmetic
 116                           arithmetic;    /**< different arithmetic operations possible with a mode */
 117         unsigned          size;          /**< size of the mode in Bits. */
 118         unsigned          sign:1;        /**< signedness of this mode */
 119         unsigned int      modulo_shift;  /**< number of bits a values of this mode will be shifted */
 120         unsigned          vector_elem;   /**< if this is not equal 1, this is a vector mode with
 121                                           vector_elem number of elements, size contains the size
 122                                           of all bits and must be dividable by vector_elem */
 123
 124         /* ----------------------------------------------------------------------- */
 125         ir_tarval         *min;         /**< the minimum value that can be expressed */
 126         ir_tarval         *max;         /**< the maximum value that can be expressed */
 127         ir_tarval         *null;        /**< the value 0 */
 128         ir_tarval         *one;         /**< the value 1 */
 129         ir_tarval         *minus_one;   /**< the value -1 */
 130         ir_tarval         *all_one;     /**< the value ~0 */
 131         ir_mode           *eq_signed;   /**< For pointer modes, the equivalent signed integer one. */
 132         ir_mode           *eq_unsigned; /**< For pointer modes, the equivalent unsigned integer one. */
 133         void              *link;        /**< To store some intermediate information */
 134         const void        *tv_priv;     /**< tarval module will save private data here */
 135 };
 136
 137 /* ir node attributes */
 138
 139 /** first attribute of Bad, Block, Anchor nodes */
 140 typedef struct irg_attr {
 141         ir_graph *irg;              /**< The graph this block like node belongs to. */
 142 } irg_attr;
 143
 144 typedef struct bad_attr {
 145         irg_attr    irg;
 146 } bad_attr;
 147
 148 typedef struct anchor_attr {
 149         irg_attr  irg;
 150 } anchor_attr;
 151
 152 /** Block attributes */
 153 typedef struct block_attr {
 154         /* General attributes */
 155         irg_attr     irg;           /**< The graph this block belongs to. */
 156         ir_visited_t block_visited; /**< For the walker that walks over all blocks. */
 157         /* Attributes private to construction: */
 158         unsigned is_matured:1;      /**< If set, all in-nodes of the block are fixed. */
 159         unsigned marked:1;          /**< Can be set/unset to temporary mark a block. */
 160         ir_node **graph_arr;        /**< An array to store all parameters. */
 161         /* Attributes holding analyses information */
 162         ir_dom_info dom;            /**< Datastructure that holds information about dominators.
 163                                          @@@ @todo
 164                                          Eventually overlay with graph_arr as only valid
 165                                          in different phases.  Eventually inline the whole
 166                                          datastructure. */
 167         ir_dom_info pdom;           /**< Datastructure that holds information about post-dominators. */
 168         ir_node ** in_cg;           /**< array with predecessors in
 169                                      * interprocedural_view, if they differ
 170                                      * from intraprocedural predecessors */
 171         bitset_t *backedge;         /**< Bitfield n set to true if pred n is backedge.*/
 172         bitset_t *cg_backedge;      /**< Bitfield n set to true if pred n is interprocedural backedge. */
 173         ir_extblk *extblk;          /**< The extended basic block this block belongs to. */
 174         ir_region *region;          /**< The immediate structural region this block belongs to. */
 175         ir_entity *entity;          /**< entitiy representing this block */
 176         ir_node  *phis;             /**< The list of Phi nodes in this block. */
 177
 178         struct list_head succ_head; /**< A list head for all successor edges of a block. */
 179 } block_attr;
 180
 181 /** Cond attributes. */
 182 typedef struct cond_attr {
 183         long default_proj;           /**< only for non-binary Conds: biggest Proj number, i.e. the one used for default. */
 184         cond_jmp_predicate jmp_pred; /**< only for binary Conds: The jump predication. */
 185 } cond_attr;
 186
 187 /** Const attributes. */
 188 typedef struct const_attr {
 189         ir_tarval *tarval;  /**< the target value */
 190 } const_attr;
 191
 192 /** SymConst attributes. */
 193 typedef struct symconst_attr {
 194         symconst_symbol sym;  // old tori
 195         symconst_kind   kind;
 196 } symconst_attr;
 197
 198 /** Sel attributes. */
 199 typedef struct sel_attr {
 200         ir_entity *entity;    /**< entity to select */
 201 } sel_attr;
 202
 203 /** Exception attributes. */
 204 typedef struct except_attr {
 205         op_pin_state   pin_state;     /**< the pin state for operations that might generate a exception:
 206                                                                          If it's know that no exception will be generated, could be set to
 207                                                                          op_pin_state_floats. */
 208 } except_attr;
 209
 210 /** Call attributes. */
 211 typedef struct call_attr {
 212         except_attr exc;               /**< the exception attribute. MUST be the first one. */
 213         ir_type     *type;             /**< type of called procedure */
 214         ir_entity   **callee_arr;      /**< result of callee analysis */
 215         unsigned    tail_call:1;       /**< if set, can be a tail call */
 216 } call_attr;
 217
 218 /** Builtin attributes. */
 219 typedef struct builtin_attr {
 220         except_attr     exc;           /**< the exception attribute. MUST be the first one. */
 221         ir_builtin_kind kind;          /**< kind of the called builtin procedure */
 222         ir_type         *type;         /**< type of called builtin procedure */
 223 } builtin_attr;
 224
 225 /** Alloc attributes. */
 226 typedef struct alloc_attr {
 227         except_attr    exc;           /**< the exception attribute. MUST be the first one. */
 228     ir_where_alloc where;         /**< stack, heap or other managed part of memory */
 229         ir_type        *type;         /**< Type of the allocated object.  */
 230 } alloc_attr;
 231
 232 /** Free attributes. */
 233 typedef struct free_attr {
 234         ir_type *type;                /**< Type of the allocated object.  */
 235         ir_where_alloc where;         /**< stack, heap or other managed part of memory */
 236 } free_attr;
 237
 238 /** InstOf attributes. */
 239 typedef struct io_attr {
 240         except_attr    exc;           /**< the exception attribute. MUST be the first one. */
 241         ir_type *type;                /**< the type of which the object pointer must be */
 242 } io_attr;
 243
 244 /** Cast attributes. */
 245 typedef struct cast_attr {
 246         ir_type *type;                /**< Type of the casted node. */
 247 } cast_attr;
 248
 249 /** Load attributes. */
 250 typedef struct load_attr {
 251         except_attr   exc;            /**< The exception attribute. MUST be the first one. */
 252     unsigned      volatility:1;   /**< The volatility of this Load operation. */
 253     unsigned      unaligned:1;    /**< The align attribute of this Load operation. */
 254         ir_mode       *mode;          /**< The mode of this Load operation. */
 255 } load_attr;
 256
 257 /** Store attributes. */
 258 typedef struct store_attr {
 259         except_attr   exc;            /**< the exception attribute. MUST be the first one. */
 260         unsigned      volatility:1;   /**< The volatility of this Store operation. */
 261         unsigned      unaligned:1;    /**< The align attribute of this Store operation. */
 262 } store_attr;
 263
 264 typedef struct phi_attr {
 265         ir_node        *next;         /**< Points to the next Phi in the Phi list of a block. */
 266         union {
 267                 bitset_t      *backedge;     /**< Raw Bitfield: bit n is set to true if pred n is backedge. */
 268                 int            pos;           /**< For Phi0. Used to remember the value defined by
 269                                                this Phi node.  Needed when the Phi is completed
 270                                                to call get_r_internal_value() to find the
 271                                                predecessors. If this attribute is set, the Phi
 272                                                node takes the role of the obsolete Phi0 node,
 273                                                therefore the name. */
 274         } u;
 275 } phi_attr;
 276
 277 /**< Cmp attribute. */
 278 typedef struct cmp_attr {
 279         ir_relation relation;         /**< comparison condition. */
 280 } cmp_attr;
 281
 282 /**< Confirm attribute. */
 283 typedef struct confirm_attr {
 284         ir_relation relation;         /**< relation between value and bound */
 285 } confirm_attr;
 286
 287 /** CopyB attribute. */
 288 typedef struct copyb_attr {
 289         except_attr    exc;           /**< The exception attribute. MUST be the first one. */
 290         ir_type        *type;         /**< Type of the copied entity. */
 291 } copyb_attr;
 292
 293 /** Bound attribute. */
 294 typedef struct bound_attr {
 295         except_attr exc;              /**< The exception attribute. MUST be the first one. */
 296 } bound_attr;
 297
 298 /** Conv attribute. */
 299 typedef struct conv_attr {
 300         char           strict;        /**< If set, this is a strict Conv that cannot be removed. */
 301 } conv_attr;
 302
 303 /** Div attribute. */
 304 typedef struct div_attr {
 305         except_attr    exc;           /**< The exception attribute. MUST be the first one. */
 306         ir_mode        *resmode;      /**< Result mode for the division. */
 307         char           no_remainder;  /**< Set, if known that a division can be done without a remainder. */
 308 } div_attr;
 309
 310 /** Mod attribute. */
 311 typedef struct mod_attr {
 312         except_attr    exc;           /**< The exception attribute. MUST be the first one. */
 313         ir_mode        *resmode;      /**< Result mode for the division. */
 314 } mod_attr;
 315
 316 /** Inline Assembler support attribute. */
 317 typedef struct asm_attr {
 318         /* BEWARE: pin state MUST be the first attribute */
 319         op_pin_state      pin_state;            /**< the pin state for operations that might generate a exception */
 320         ident             *text;                /**< The inline assembler text. */
 321         ir_asm_constraint *input_constraints;   /**< Input constraints. */
 322         ir_asm_constraint *output_constraints;  /**< Output constraints. */
 323         ident             **clobbers;           /**< List of clobbered registers. */
 324 } asm_attr;
 325
 326 typedef struct proj_attr {
 327         long  proj;           /**< position of tuple sub-value which is projected */
 328 } proj_attr;
 329
 330 /** Some IR-nodes just have one attribute, these are stored here,
 331    some have more. Their name is 'irnodename_attr' */
 332 typedef union ir_attr {
 333         irg_attr       irg;           /**< For Blocks and Bad: its belonging irg */
 334         bad_attr       bad;           /**< for Bads: irg reference */
 335         anchor_attr    anchor;        /**< for Anchor: irg reference */
 336         block_attr     block;         /**< For Block: Fields needed to construct it */
 337         cmp_attr       cmp;           /**< For Cmp. */
 338         cond_attr      cond;          /**< For Cond. */
 339         const_attr     con;           /**< For Const: contains the value of the constant and a type */
 340         symconst_attr  symc;          /**< For SymConst. */
 341         sel_attr       sel;           /**< For Sel. */
 342         call_attr      call;          /**< For Call. */
 343         builtin_attr   builtin;       /**< For Builtin. */
 344         alloc_attr     alloc;         /**< For Alloc. */
 345         free_attr      free;          /**< For Free. */
 346         io_attr        instof;        /**< For InstOf */
 347         cast_attr      cast;          /**< For Cast. */
 348         load_attr      load;          /**< For Load. */
 349         store_attr     store;         /**< For Store. */
 350         phi_attr       phi;           /**< For Phi. */
 351         proj_attr      proj;          /**< For Proj. */
 352         confirm_attr   confirm;       /**< For Confirm: compare operation and region. */
 353         except_attr    except;        /**< For Phi node construction in case of exceptions */
 354         copyb_attr     copyb;         /**< For CopyB operation */
 355         bound_attr     bound;         /**< For Bound operation */
 356         conv_attr      conv;          /**< For Conv operation */
 357         div_attr       div;           /**< For Div operation */
 358         mod_attr       mod;           /**< For Mod operation */
 359         asm_attr       assem;         /**< For ASM operation. */
 360 } ir_attr;
 361
 362 /**
 363  * Edge info to put into an irn.
 364  */
 365 typedef struct irn_edge_kind_info_t {
 366         struct list_head outs_head;  /**< The list of all outs. */
 367         unsigned edges_built : 1;    /**< Set edges where built for this node. */
 368         unsigned out_count : 31;     /**< Number of outs in the list. */
 369 } irn_edge_info_t;
 370
 371 typedef irn_edge_info_t irn_edges_info_t[EDGE_KIND_LAST];
 372
 373 /**
 374  * A Def-Use edge.
 375  */
 376 typedef struct ir_def_use_edge {
 377         ir_node *use;            /** The use node of that edge. */
 378         int     pos;             /** The position of this edge in use's input array. */
 379 } ir_def_use_edge;
 380
 381 /**
 382  * The common structure of an irnode.
 383  * If the node has some attributes, they are stored in the attr field.
 384  */
 385 struct ir_node {
 386         /* ------- Basics of the representation  ------- */
 387         firm_kind kind;          /**< Distinguishes this node from others. */
 388         unsigned node_idx;       /**< The node index of this node in its graph. */
 389         ir_op *op;               /**< The Opcode of this node. */
 390         ir_mode *mode;           /**< The Mode of this node. */
 391         struct ir_node **in;     /**< The array of predecessors / operands. */
 392         ir_visited_t visited;    /**< The visited counter for walks of the graph. */
 393         void *link;              /**< To attach additional information to the node, e.g.
 394                                       used during optimization to link to nodes that
 395                                       shall replace a node. */
 396         long node_nr;            /**< A globally unique node number for each node. */
 397         /* ------- Fields for optimizations / analysis information ------- */
 398         ir_def_use_edge *out;    /**< array of def-use edges. */
 399         struct dbg_info *dbi;    /**< A pointer to information for debug support. */
 400         /* ------- For debugging ------- */
 401 #ifdef DEBUG_libfirm
 402         unsigned out_valid : 1;
 403         unsigned flags     : 31;
 404 #endif
 405         /* ------- For analyses -------- */
 406         ir_loop *loop;           /**< the loop the node is in. Access routines in irloop.h */
 407         struct ir_node **deps;   /**< Additional dependencies induced by state. */
 408         void            *backend_info;
 409         irn_edges_info_t edge_info;  /**< Everlasting out edges. */
 410
 411         /* ------- Opcode depending fields -------- */
 412         ir_attr attr;            /**< The set of attributes of this node. Depends on opcode.
 413                                       Must be last field of struct ir_node. */
 414 };
 415
 416 #include "iredgeset.h"
 417
 418 /**
 419  * Edge info to put into an irg.
 420  */
 421 typedef struct irg_edge_info_t {
 422         ir_edgeset_t     edges;          /**< A set containing all edges of the current graph. */
 423         struct list_head free_edges;     /**< list of all free edges. */
 424         struct obstack   edges_obst;     /**< Obstack, where edges are allocated on. */
 425         unsigned         allocated : 1;  /**< Set if edges are allocated on the obstack. */
 426         unsigned         activated : 1;  /**< Set if edges are activated for the graph. */
 427 } irg_edge_info_t;
 428
 429 typedef irg_edge_info_t irg_edges_info_t[EDGE_KIND_LAST];
 430
 431 /**
 432  * Index constants for nodes that can be accessed through the graph anchor node.
 433  */
 434 enum irg_anchors {
 435         anchor_end_block = 0,    /**< block the end node will belong to, same as Anchors block */
 436         anchor_start_block,      /**< block the start node will belong to */
 437         anchor_end,              /**< end node of this ir_graph */
 438         anchor_start,            /**< start node of this ir_graph */
 439         anchor_initial_exec,     /**< methods initial control flow */
 440         anchor_frame,            /**< methods frame */
 441         anchor_initial_mem,      /**< initial memory of this graph */
 442         anchor_args,             /**< methods arguments */
 443         anchor_no_mem,           /**< NoMem node of this ir_graph, the one and only in this graph */
 444         anchor_last
 445 };
 446
 447 /** A callgraph entry for callees. */
 448 typedef struct cg_callee_entry {
 449         ir_graph  *irg;        /**< The called irg. */
 450         ir_node  **call_list;  /**< The list of all calls to the irg. */
 451         size_t     max_depth;  /**< Maximum depth of all Call nodes to irg. */
 452 } cg_callee_entry;
 453
 454 /**
 455  * An ir_graph holds all information for a procedure.
 456  */
 457 struct ir_graph {
 458         firm_kind         kind;        /**< Always set to k_ir_graph. */
 459         /* --  Basics of the representation -- */
 460     unsigned last_node_idx;        /**< The last IR node index for this graph. */
 461         ir_entity  *ent;               /**< The entity of this procedure, i.e.,
 462                                             the type of the procedure and the
 463                                             class it belongs to. */
 464         ir_type *frame_type;           /**< A class type representing the stack frame.
 465                                             Can include "inner" methods. */
 466         ir_node *anchor;               /**< Pointer to the anchor node of this graph. */
 467         struct obstack *obst;          /**< The obstack where all of the ir_nodes live. */
 468         ir_node *current_block;        /**< Current block for newly gen_*()-erated ir_nodes. */
 469         struct obstack *extbb_obst;    /**< The obstack for extended basic block info. */
 470
 471         /* -- Fields for graph properties -- */
 472         irg_inline_property        inline_property;       /**< How to handle inlineing. */
 473         mtp_additional_properties  additional_properties; /**< Additional graph properties. */
 474
 475         /* -- Fields indicating different states of irgraph -- */
 476         ir_graph_state_t      state;
 477         irg_phase_state       phase_state;       /**< Compiler phase. */
 478         op_pin_state          irg_pinned_state;  /**< Flag for status of nodes. */
 479         irg_outs_state        outs_state;        /**< Out edges. */
 480         irg_dom_state         dom_state;         /**< Dominator state information. */
 481         irg_dom_state         pdom_state;        /**< Post Dominator state information. */
 482         ir_typeinfo_state     typeinfo_state;    /**< Validity of type information. */
 483         irg_callee_info_state callee_info_state; /**< Validity of callee information. */
 484         irg_loopinfo_state    loopinfo_state;    /**< State of loop information. */
 485         ir_class_cast_state   class_cast_state;  /**< Kind of cast operations in code. */
 486         irg_extblk_info_state extblk_state;      /**< State of extended basic block info. */
 487         exec_freq_state       execfreq_state;    /**< Execution frequency state. */
 488         ir_entity_usage_computed_state entity_usage_state;
 489         unsigned mem_disambig_opt;               /**< Options for the memory disambiguator. */
 490         unsigned fp_model;                       /**< floating point model of the graph. */
 491
 492         /* -- Fields for construction -- */
 493         int n_loc;                         /**< Number of local variables in this
 494                                                 procedure including procedure parameters. */
 495         void **loc_descriptions;           /**< Storage for local variable descriptions. */
 496
 497         /* -- Fields for optimizations / analysis information -- */
 498         pset *value_table;                 /**< Hash table for global value numbering (cse)
 499                                                 for optimizing use in iropt.c */
 500         ir_def_use_edge *outs;             /**< Space for the Def-Use arrays. */
 501
 502         ir_loop *loop;                     /**< The outermost loop for this graph. */
 503         void *link;                        /**< A void* field to link any information to
 504                                                 the node. */
 505
 506         ir_graph **callers;                /**< For callgraph analysis: list of caller graphs. */
 507         unsigned *caller_isbe;             /**< For callgraph analysis: raw bitset if backedge info calculated. */
 508         cg_callee_entry **callees;         /**< For callgraph analysis: list of callee calls */
 509         unsigned *callee_isbe;             /**< For callgraph analysis: raw bitset if backedge info calculated. */
 510         ir_loop   *l;                            /**< For callgraph analysis. */
 511         size_t     callgraph_loop_depth;         /**< For callgraph analysis */
 512         size_t     callgraph_recursion_depth;    /**< For callgraph analysis */
 513         double     method_execution_frequency;   /**< For callgraph analysis */
 514
 515
 516         /* -- Fields for Walking the graph -- */
 517         ir_visited_t visited;             /**< this flag is an identifier for
 518                           ir walk. it will be incremented
 519                           every time someone walks through
 520                           the graph */
 521         ir_visited_t block_visited;        /**< same as visited, for a complete block */
 522
 523         ir_visited_t self_visited;         /**< visited flag of the irg */
 524
 525         unsigned estimated_node_count;     /**< estimated number of nodes in this graph,
 526                                                 updated after every walk */
 527         irg_edges_info_t edge_info;        /**< edge info for automatic outs */
 528         ir_node **idx_irn_map;             /**< Array mapping node indexes to nodes. */
 529
 530         size_t index;                      /**< a unique number for each graph */
 531         ir_phase *phases[PHASE_LAST+1];    /**< Phase information. */
 532         void     *be_data;                 /**< backend can put in private data here */
 533
 534         unsigned  dump_nr;                 /**< number of graph dumps */
 535 #ifdef DEBUG_libfirm
 536         int   n_outs;                      /**< Size wasted for outs */
 537         long graph_nr;                     /**< a unique graph number for each
 538                                                 graph to make output readable. */
 539 #endif
 540
 541 #ifndef NDEBUG
 542         ir_resources_t reserved_resources; /**< Bitset for tracking used local resources. */
 543 #endif
 544 };
 545
 546 /**
 547  * Data structure that holds central information about a program
 548  * or a module.
 549  * One irp is created by libFirm on construction, so irp should never be NULL.
 550  *
 551  * - main_irg:  The ir graph that is the entry point to the program.
 552  *              (Anything not reachable from here may be optimized away
 553  *              if this irp represents a whole program.
 554  * - irg:       List of all ir graphs in the program or module.
 555  * - type:      A list containing all types known to the translated program.
 556  *              Some types can have several entries in this list (as a result of
 557  *              using exchange_types()).
 558  * - glob_type: The unique global type that is owner of all global entities
 559  *              of this module.
 560  */
 561 struct ir_prog {
 562         firm_kind kind;                 /**< must be k_ir_prog */
 563         ident     *name;                /**< A file name or the like. */
 564         ir_graph  *main_irg;            /**< The entry point to the compiled program
 565                                              or NULL if no point exists. */
 566         ir_graph **graphs;              /**< A list of all graphs in the ir. */
 567         ir_graph  *const_code_irg;      /**< This ir graph gives the proper environment
 568                                              to allocate nodes the represent values
 569                                              of constant entities. It is not meant as
 570                                              a procedure.  */
 571         ir_type   *segment_types[IR_SEGMENT_LAST+1];
 572         ir_type  **types;               /**< A list of all types in the ir. */
 573         ir_mode  **modes;               /**< A list of all modes in the ir. */
 574         ir_op    **opcodes;             /**< A list of all opcodes in the ir. */
 575         ident    **global_asms;         /**< An array of global ASM insertions. */
 576
 577         /* -- states of and access to generated information -- */
 578         irg_phase_state phase_state;    /**< The state of construction. */
 579
 580         irg_outs_state outs_state;      /**< The state of out edges of ir nodes. */
 581         ir_node **ip_outedges;          /**< A huge Array that contains all out edges
 582                                              in interprocedural view. */
 583         irg_outs_state trouts_state;    /**< The state of out edges of type information. */
 584
 585         irg_callee_info_state callee_info_state; /**< Validity of callee information.
 586                                                       Contains the lowest value or all irgs.  */
 587         ir_typeinfo_state typeinfo_state;    /**< Validity of type information. */
 588         inh_transitive_closure_state inh_trans_closure_state;  /**< State of transitive closure
 589                                                                     of inheritance relations. */
 590
 591         irp_callgraph_state callgraph_state; /**< The state of the callgraph. */
 592         ir_loop *outermost_cg_loop;          /**< For callgraph analysis: entry point
 593                                                       to looptree over callgraph. */
 594         size_t max_callgraph_loop_depth;        /**< needed in callgraph. */
 595         size_t max_callgraph_recursion_depth;   /**< needed in callgraph. */
 596         double max_method_execution_frequency;  /**< needed in callgraph. */
 597         irp_temperature_state temperature_state; /**< accumulated temperatures computed? */
 598         exec_freq_state execfreq_state;      /**< The state of execution frequency information */
 599         loop_nesting_depth_state lnd_state;  /**< The state of loop nesting depth information. */
 600         ir_class_cast_state class_cast_state;    /**< The state of cast operations in code. */
 601         ir_entity_usage_computed_state globals_entity_usage_state;
 602
 603         ir_exc_region_t last_region_nr;      /**< The last exception region number that was assigned. */
 604         ir_label_t last_label_nr;            /**< The highest label number for generating unique labels. */
 605         size_t max_irg_idx;                  /**< highest unused irg index */
 606         long max_node_nr;                    /**< to generate unique numbers for nodes. */
 607         unsigned dump_nr;                    /**< number of program info dumps */
 608 #ifndef NDEBUG
 609         ir_resources_t reserved_resources;   /**< Bitset for tracking used global resources. */
 610 #endif
 611 };
 612
 613 #endif