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