nsz Git - libfirm/blob - ir/ir/irgraph.c

   1 /*
   2  * Copyright (C) 1995-2007 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, Michael Beck
  24  * @version  $Id$
  25  */
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #ifdef HAVE_STRING_H
  31 # include <string.h>
  32 #endif
  33 #ifdef HAVE_STDDEF_H
  34 # include <stddef.h>
  35 #endif
  36
  37 #include "xmalloc.h"
  38 #include "ircons.h"
  39 #include "irgraph_t.h"
  40 #include "irprog_t.h"
  41 #include "irnode_t.h"
  42 #include "iropt_t.h"
  43 #include "irflag_t.h"
  44 #include "array.h"
  45 #include "irgmod.h"
  46 #include "mangle.h"
  47 #include "irouts.h"
  48 #include "irhooks.h"
  49 #include "irtools.h"
  50 #include "irgwalk.h"
  51 #include "iredges_t.h"
  52 #include "type_t.h"
  53 #include "irmemory.h"
  54
  55 #define INITIAL_IDX_IRN_MAP_SIZE 1024
  56
  57 /**
  58  * Indicates, whether additional data can be registered to graphs.
  59  * If set to 1, this is not possible anymore.
  60  */
  61 static int forbid_new_data = 0;
  62
  63 /**
  64  * The amount of additional space for custom data to be allocated upon
  65  * creating a new graph.
  66  */
  67 static size_t additional_graph_data_size = 0;
  68
  69 ir_graph *current_ir_graph;
  70 ir_graph *get_current_ir_graph(void) {
  71   return current_ir_graph;
  72 }
  73 void set_current_ir_graph(ir_graph *graph) {
  74   current_ir_graph = graph;
  75 }
  76
  77
  78 int firm_interprocedural_view = 0;
  79
  80 int (get_interprocedural_view)(void) {
  81   return _get_interprocedural_view();
  82 }
  83
  84 void (set_interprocedural_view)(int state) {
  85   firm_interprocedural_view = state;
  86
  87   /* set function vectors for faster access */
  88   if (state) {
  89     _get_irn_arity = _get_irn_inter_arity;
  90     _get_irn_n     = _get_irn_inter_n;
  91   }
  92   else {
  93     _get_irn_arity = _get_irn_intra_arity;
  94     _get_irn_n     = _get_irn_intra_n;
  95   }
  96 }
  97
  98 /** contains the suffix for frame type names */
  99 static ident *frame_type_suffix = NULL;
 100
 101 /* initialize the IR graph module */
 102 void firm_init_irgraph(void) {
 103   frame_type_suffix = new_id_from_str(FRAME_TP_SUFFIX);
 104   forbid_new_data   = 1;
 105 }
 106
 107 /**
 108  * Allocate a new IR graph.
 109  * This function respects the registered graph data. The only reason for
 110  * this function is, that there are two locations, where graphs are
 111  * allocated (new_r_ir_graph, new_const_code_irg).
 112  * @return Memory for a new graph.
 113  */
 114 static ir_graph *alloc_graph(void) {
 115   size_t size = sizeof(ir_graph) + additional_graph_data_size;
 116   char *ptr = xmalloc(size);
 117   memset(ptr, 0, size);
 118
 119   return (ir_graph *) (ptr + additional_graph_data_size);
 120 }
 121
 122 /**
 123  * Frees an allocated IR graph
 124  */
 125 static void free_graph(ir_graph *irg) {
 126   char *ptr = (char *)irg;
 127   free(ptr - additional_graph_data_size);
 128 }
 129
 130 #if USE_EXPLICIT_PHI_IN_STACK
 131 /* really defined in ircons.c */
 132 typedef struct Phi_in_stack Phi_in_stack;
 133 Phi_in_stack *new_Phi_in_stack();
 134 void free_Phi_in_stack(Phi_in_stack *s);
 135 #endif
 136
 137 /* Allocates a list of nodes:
 138     - The start block containing a start node and Proj nodes for it's four
 139       results (X, M, P, Tuple).
 140     - The end block containing an end node. This block is not matured after
 141       new_ir_graph as predecessors need to be added to it.
 142     - The current block, which is empty and also not matured.
 143    Further it allocates several datastructures needed for graph construction
 144    and optimization.
 145 */
 146 ir_graph *
 147 new_r_ir_graph (ir_entity *ent, int n_loc)
 148 {
 149   ir_graph *res;
 150   ir_node  *first_block;
 151   ir_node  *end, *start, *start_block, *initial_mem, *projX;
 152
 153   res = alloc_graph();
 154   res->kind = k_ir_graph;
 155
 156   //edges_init_graph_kind(res, EDGE_KIND_NORMAL);
 157   //edges_init_graph_kind(res, EDGE_KIND_BLOCK);
 158
 159   /* initialize the idx->node map. */
 160   res->idx_irn_map = NEW_ARR_F(ir_node *, INITIAL_IDX_IRN_MAP_SIZE);
 161   memset(res->idx_irn_map, 0, INITIAL_IDX_IRN_MAP_SIZE * sizeof(res->idx_irn_map[0]));
 162
 163   /* inform statistics here, as blocks will be already build on this graph */
 164   hook_new_graph(res, ent);
 165
 166   current_ir_graph = res;
 167
 168   /*-- initialized for each graph. --*/
 169   if (get_opt_precise_exc_context()) {
 170     res->n_loc = n_loc + 1 + 1; /* number of local variables that are never
 171                    dereferenced in this graph plus one for
 172                    the store plus one for links to fragile
 173                    operations.  n_loc is not the number of
 174                    parameters to the procedure!  */
 175   }
 176   else {
 177     res->n_loc = n_loc + 1;  /* number of local variables that are never
 178                 dereferenced in this graph plus one for
 179                 the store. This is not the number of parameters
 180                 to the procedure!  */
 181   }
 182
 183   /* descriptions will be allocated on demand */
 184   res->loc_descriptions = NULL;
 185
 186   res->visited       = 0; /* visited flag, for the ir walker */
 187   res->block_visited = 0; /* visited flag, for the 'block'-walker */
 188
 189 #if USE_EXPLICIT_PHI_IN_STACK
 190   res->Phi_in_stack = new_Phi_in_stack();  /* A stack needed for automatic Phi
 191                                 generation */
 192 #endif
 193   res->kind = k_ir_graph;
 194   res->obst = xmalloc (sizeof(*res->obst));
 195   obstack_init(res->obst);
 196   res->extbb_obst = NULL;
 197
 198   res->last_node_idx = 0;
 199
 200   res->value_table = new_identities (); /* value table for global value
 201                        numbering for optimizing use in
 202                        iropt.c */
 203   res->outs = NULL;
 204
 205   res->inline_property       = irg_inline_any;
 206   res->additional_properties = mtp_property_inherited;  /* inherited from type */
 207
 208   res->phase_state         = phase_building;
 209   res->irg_pinned_state    = op_pin_state_pinned;
 210   res->outs_state          = outs_none;
 211   res->dom_state           = dom_none;
 212   res->pdom_state          = dom_none;
 213   res->typeinfo_state      = ir_typeinfo_none;
 214   set_irp_typeinfo_inconsistent();           /* there is a new graph with typeinfo_none. */
 215   res->callee_info_state   = irg_callee_info_none;
 216   res->loopinfo_state      = loopinfo_none;
 217   res->class_cast_state    = ir_class_casts_transitive;
 218   res->extblk_state        = ir_extblk_info_none;
 219   res->execfreq_state      = exec_freq_none;
 220   res->fp_model            = fp_model_precise;
 221   res->adr_taken_state     = ir_address_taken_not_computed;
 222   res->mem_disambig_opt    = aa_opt_inherited;
 223
 224   /*-- Type information for the procedure of the graph --*/
 225   res->ent = ent;
 226   set_entity_irg(ent, res);
 227
 228   /*--  a class type so that it can contain "inner" methods as in Pascal. --*/
 229   res->frame_type = new_type_frame(mangle(get_entity_ident(ent), frame_type_suffix));
 230
 231   /*-- Nodes needed in every graph --*/
 232   set_irg_end_block (res, new_immBlock());
 233   end               = new_End();
 234   set_irg_end       (res, end);
 235   set_irg_end_reg   (res, end);
 236   set_irg_end_except(res, end);
 237
 238   start_block = new_immBlock();
 239   set_irg_start_block(res, start_block);
 240   set_irg_bad        (res, new_ir_node(NULL, res, start_block, op_Bad, mode_T, 0, NULL));
 241   set_irg_no_mem     (res, new_ir_node(NULL, res, start_block, op_NoMem, mode_M, 0, NULL));
 242   start = new_Start();
 243   set_irg_start      (res, start);
 244
 245   /* Proj results of start node */
 246   projX                   = new_Proj(start, mode_X, pn_Start_X_initial_exec);
 247   set_irg_frame           (res, new_Proj(start, mode_P_data, pn_Start_P_frame_base));
 248   set_irg_globals         (res, new_Proj(start, mode_P_data, pn_Start_P_globals));
 249   set_irg_tls             (res, new_Proj(start, mode_P_data, pn_Start_P_tls));
 250   set_irg_args            (res, new_Proj(start, mode_T,      pn_Start_T_args));
 251   set_irg_value_param_base(res, new_Proj(start, mode_P_data, pn_Start_P_value_arg_base));
 252   initial_mem             = new_Proj(start, mode_M, pn_Start_M);
 253   set_irg_initial_mem(res, initial_mem);
 254
 255   add_immBlock_pred(start_block, projX);
 256   set_store(initial_mem);
 257
 258 #ifdef DEBUG_libfirm
 259   res->graph_nr    = get_irp_new_node_nr();
 260 #endif
 261   res->proj_args   = NULL;
 262
 263   /*
 264    * The code generation needs it. leave it in now.
 265    * Use of this edge is matter of discussion, unresolved. Also possible:
 266    * add_immBlock_pred(res->start_block, res->start_block), but invalid typed.
 267    */
 268   mature_immBlock(res->current_block);
 269
 270   /*-- Make a block to start with --*/
 271   first_block = new_immBlock();
 272   add_immBlock_pred(first_block, projX);
 273
 274   res->method_execution_frequency = -1;
 275   res->estimated_node_count       = 0;
 276
 277   return res;
 278 }
 279
 280
 281 ir_graph *
 282 new_ir_graph(ir_entity *ent, int n_loc)
 283 {
 284   ir_graph *res = new_r_ir_graph(ent, n_loc);
 285   add_irp_irg(res);          /* remember this graph global. */
 286   return res;
 287 }
 288
 289 /* Make a rudimentary IR graph for the constant code.
 290    Must look like a correct irg, spare everything else. */
 291 ir_graph *new_const_code_irg(void) {
 292   ir_graph *res;
 293   ir_node  *end, *start_block, *start, *projX;
 294
 295   res = alloc_graph();
 296
 297   /* initialize the idx->node map. */
 298   res->idx_irn_map = NEW_ARR_F(ir_node *, INITIAL_IDX_IRN_MAP_SIZE);
 299   memset(res->idx_irn_map, 0, INITIAL_IDX_IRN_MAP_SIZE * sizeof(res->idx_irn_map[0]));
 300
 301   /* inform statistics here, as blocks will be already build on this graph */
 302   hook_new_graph(res, NULL);
 303
 304   current_ir_graph = res;
 305   res->n_loc = 1;         /* Only the memory. */
 306   res->visited = 0;       /* visited flag, for the ir walker */
 307   res->block_visited = 0; /* visited flag, for the 'block'-walker */
 308 #if USE_EXPLICIT_PHI_IN_STACK
 309   res->Phi_in_stack = NULL;
 310 #endif
 311   res->kind = k_ir_graph;
 312   res->obst      = xmalloc (sizeof(*res->obst));
 313   obstack_init (res->obst);
 314   res->extbb_obst = NULL;
 315
 316   res->last_node_idx = 0;
 317
 318   res->phase_state      = phase_building;
 319   res->irg_pinned_state = op_pin_state_pinned;
 320   res->extblk_state     = ir_extblk_info_none;
 321   res->fp_model         = fp_model_precise;
 322
 323   res->value_table = new_identities (); /* value table for global value
 324                        numbering for optimizing use in
 325                        iropt.c */
 326   res->ent = NULL;
 327   res->frame_type  = NULL;
 328
 329   /* -- The end block -- */
 330   set_irg_end_block (res, new_immBlock());
 331   end = new_End();
 332   set_irg_end       (res, end);
 333   set_irg_end_reg   (res, end);
 334   set_irg_end_except(res, end);
 335   mature_immBlock(get_cur_block());  /* mature the end block */
 336
 337   /* -- The start block -- */
 338   start_block        = new_immBlock();
 339   set_irg_start_block(res, start_block);
 340   set_irg_bad        (res, new_ir_node (NULL, res, start_block, op_Bad, mode_T, 0, NULL));
 341   set_irg_no_mem     (res, new_ir_node (NULL, res, start_block, op_NoMem, mode_M, 0, NULL));
 342   start              = new_Start();
 343   set_irg_start      (res, start);
 344
 345   /* Proj results of start node */
 346   set_irg_initial_mem(res, new_Proj(start, mode_M, pn_Start_M));
 347   projX = new_Proj(start, mode_X, pn_Start_X_initial_exec);
 348   add_immBlock_pred(start_block, projX);
 349   mature_immBlock  (start_block);  /* mature the start block */
 350
 351   add_immBlock_pred(new_immBlock(), projX);
 352   mature_immBlock  (get_cur_block());   /* mature the 'body' block for expressions */
 353
 354   /* Set the visited flag high enough that the blocks will never be visited. */
 355   set_irn_visited(get_cur_block(), -1);
 356   set_Block_block_visited(get_cur_block(), -1);
 357   set_Block_block_visited(start_block, -1);
 358   set_irn_visited(start_block, -1);
 359   set_irn_visited(get_irg_bad(res), -1);
 360   set_irn_visited(get_irg_no_mem(res), -1);
 361
 362   res->phase_state = phase_high;
 363
 364   return res;
 365 }
 366
 367 /* Defined in iropt.c */
 368 void  del_identities (pset *value_table);
 369
 370 /* Frees the passed irgraph.
 371    Deallocates all nodes in this graph and the ir_graph structure.
 372    Sets the field irgraph in the corresponding entity to NULL.
 373    Does not remove the irgraph from the list in irprog (requires
 374    inefficient search, call remove_irp_irg by hand).
 375    Does not free types, entities or modes that are used only by this
 376    graph, nor the entity standing for this graph. */
 377 void free_ir_graph (ir_graph *irg) {
 378   assert(is_ir_graph(irg));
 379
 380   hook_free_graph(irg);
 381   if (irg->outs_state != outs_none) free_irg_outs(irg);
 382   if (irg->frame_type)  free_type(irg->frame_type);
 383   if (irg->value_table) del_identities(irg->value_table);
 384   if (irg->ent) {
 385     ir_peculiarity pec = get_entity_peculiarity (irg->ent);
 386     set_entity_peculiarity (irg->ent, peculiarity_description);
 387     set_entity_irg(irg->ent, NULL);  /* not set in const code irg */
 388     set_entity_peculiarity (irg->ent, pec);
 389   }
 390
 391   free_End(get_irg_end(irg));
 392   obstack_free(irg->obst,NULL);
 393   free(irg->obst);
 394 #if USE_EXPLICIT_PHI_IN_STACK
 395   free_Phi_in_stack(irg->Phi_in_stack);
 396 #endif
 397   if (irg->loc_descriptions)
 398     free(irg->loc_descriptions);
 399   irg->kind = k_BAD;
 400   free_graph(irg);
 401 }
 402
 403 /* access routines for all ir_graph attributes:
 404    templates:
 405    {attr type} get_irg_{attribute name} (ir_graph *irg);
 406    void set_irg_{attr name} (ir_graph *irg, {attr type} {attr}); */
 407
 408 int
 409 (is_ir_graph)(const void *thing) {
 410   return _is_ir_graph(thing);
 411 }
 412
 413 /* Outputs a unique number for this node */
 414 long get_irg_graph_nr(ir_graph *irg) {
 415   assert(irg);
 416 #ifdef DEBUG_libfirm
 417   return irg->graph_nr;
 418 #else
 419   return (long)PTR_TO_INT(irg);
 420 #endif
 421 }
 422
 423 ir_node *
 424 (get_irg_start_block)(const ir_graph *irg) {
 425   return _get_irg_start_block(irg);
 426 }
 427
 428 void
 429 (set_irg_start_block)(ir_graph *irg, ir_node *node) {
 430   _set_irg_start_block(irg, node);
 431 }
 432
 433 ir_node *
 434 (get_irg_start)(const ir_graph *irg) {
 435   return _get_irg_start(irg);
 436 }
 437
 438 void
 439 (set_irg_start)(ir_graph *irg, ir_node *node) {
 440   _set_irg_start(irg, node);
 441 }
 442
 443 ir_node *
 444 (get_irg_end_block)(const ir_graph *irg) {
 445   return _get_irg_end_block(irg);
 446 }
 447
 448 void
 449 (set_irg_end_block)(ir_graph *irg, ir_node *node) {
 450   _set_irg_end_block(irg, node);
 451 }
 452
 453 ir_node *
 454 (get_irg_end)(const ir_graph *irg) {
 455   return _get_irg_end(irg);
 456 }
 457
 458 void
 459 (set_irg_end)(ir_graph *irg, ir_node *node) {
 460   _set_irg_end(irg, node);
 461 }
 462
 463 ir_node *
 464 (get_irg_end_reg)(const ir_graph *irg) {
 465   return _get_irg_end_reg(irg);
 466 }
 467
 468 void     set_irg_end_reg (ir_graph *irg, ir_node *node) {
 469   assert(get_irn_op(node) == op_EndReg || get_irn_op(node) == op_End);
 470   irg->anchors[anchor_end_reg] = node;
 471 }
 472
 473 ir_node *
 474 (get_irg_end_except)(const ir_graph *irg) {
 475   return _get_irg_end_except(irg);
 476 }
 477
 478 void     set_irg_end_except (ir_graph *irg, ir_node *node) {
 479   assert(get_irn_op(node) == op_EndExcept || get_irn_op(node) == op_End);
 480   irg->anchors[anchor_end_except] = node;
 481 }
 482
 483 ir_node *
 484 (get_irg_frame)(const ir_graph *irg) {
 485   return _get_irg_frame(irg);
 486 }
 487
 488 void
 489 (set_irg_frame)(ir_graph *irg, ir_node *node) {
 490   _set_irg_frame(irg, node);
 491 }
 492
 493 ir_node *
 494 (get_irg_globals)(const ir_graph *irg) {
 495   return _get_irg_globals(irg);
 496 }
 497
 498 void
 499 (set_irg_globals)(ir_graph *irg, ir_node *node) {
 500   _set_irg_globals(irg, node);
 501 }
 502
 503 ir_node *
 504 (get_irg_tls)(const ir_graph *irg) {
 505   return _get_irg_tls(irg);
 506 }
 507
 508 void
 509 (set_irg_tls)(ir_graph *irg, ir_node *node) {
 510   _set_irg_tls(irg, node);
 511 }
 512
 513 ir_node *
 514 (get_irg_initial_mem)(const ir_graph *irg) {
 515   return _get_irg_initial_mem(irg);
 516 }
 517
 518 void
 519 (set_irg_initial_mem)(ir_graph *irg, ir_node *node) {
 520   _set_irg_initial_mem(irg, node);
 521 }
 522
 523 ir_node *
 524 (get_irg_args)(const ir_graph *irg) {
 525   return _get_irg_args(irg);
 526 }
 527
 528 void
 529 (set_irg_args)(ir_graph *irg, ir_node *node) {
 530   _set_irg_args(irg, node);
 531 }
 532
 533 ir_node *
 534 (get_irg_value_param_base)(const ir_graph *irg) {
 535   return _get_irg_value_param_base(irg);
 536 }
 537
 538 void
 539 (set_irg_value_param_base)(ir_graph *irg, ir_node *node) {
 540   _set_irg_value_param_base(irg, node);
 541 }
 542
 543 ir_node **
 544 (get_irg_proj_args) (const ir_graph *irg) {
 545   return _get_irg_proj_args (irg);
 546 }
 547
 548 void
 549 (set_irg_proj_args) (ir_graph *irg, ir_node **nodes) {
 550   _set_irg_proj_args (irg, nodes);
 551 }
 552
 553 ir_node *
 554 (get_irg_bad)(const ir_graph *irg) {
 555   return _get_irg_bad(irg);
 556 }
 557
 558 void
 559 (set_irg_bad)(ir_graph *irg, ir_node *node) {
 560   _set_irg_bad(irg, node);
 561 }
 562
 563 ir_node *
 564 (get_irg_no_mem)(const ir_graph *irg) {
 565   return _get_irg_no_mem(irg);
 566 }
 567
 568 void
 569 (set_irg_no_mem)(ir_graph *irg, ir_node *node) {
 570   _set_irg_no_mem(irg, node);
 571 }
 572
 573 ir_node *
 574 (get_irg_current_block)(const ir_graph *irg) {
 575   return _get_irg_current_block(irg);
 576 }
 577
 578 void
 579 (set_irg_current_block)(ir_graph *irg, ir_node *node) {
 580   _set_irg_current_block(irg, node);
 581 }
 582
 583 ir_entity *
 584 (get_irg_entity)(const ir_graph *irg) {
 585   return _get_irg_entity(irg);
 586 }
 587
 588 void
 589 (set_irg_entity)(ir_graph *irg, ir_entity *ent) {
 590   _set_irg_entity(irg, ent);
 591 }
 592
 593 ir_type *
 594 (get_irg_frame_type)(ir_graph *irg) {
 595   return _get_irg_frame_type(irg);
 596 }
 597
 598 void
 599 (set_irg_frame_type)(ir_graph *irg, ir_type *ftp) {
 600   _set_irg_frame_type(irg, ftp);
 601 }
 602
 603 int
 604 get_irg_n_locs (ir_graph *irg)
 605 {
 606   if (get_opt_precise_exc_context())
 607     return irg->n_loc - 1 - 1;
 608   else
 609     return irg->n_loc - 1;
 610 }
 611
 612 void
 613 set_irg_n_loc (ir_graph *irg, int n_loc)
 614 {
 615   if (get_opt_precise_exc_context())
 616     irg->n_loc = n_loc + 1 + 1;
 617   else
 618     irg->n_loc = n_loc + 1;
 619 }
 620
 621
 622
 623 /* Returns the obstack associated with the graph. */
 624 struct obstack *
 625 (get_irg_obstack)(const ir_graph *irg) {
 626   return _get_irg_obstack(irg);
 627 }
 628
 629 /*
 630  * Returns true if the node n is allocated on the storage of graph irg.
 631  *
 632  * Implementation is GLIBC specific as is uses the internal _obstack_chunk implementation.
 633  */
 634 int node_is_in_irgs_storage(ir_graph *irg, ir_node *n)
 635 {
 636   struct _obstack_chunk *p;
 637
 638   /*
 639    * checks weather the ir_node pointer is on the obstack.
 640    * A more sophisticated check would test the "whole" ir_node
 641    */
 642   for (p = irg->obst->chunk; p; p = p->prev) {
 643     if (((char *)p->contents <= (char *)n) && ((char *)n < (char *)p->limit))
 644       return 1;
 645   }
 646
 647   return 0;
 648 }
 649
 650 irg_phase_state
 651 (get_irg_phase_state)(const ir_graph *irg) {
 652   return _get_irg_phase_state(irg);
 653 }
 654
 655 void
 656 (set_irg_phase_state)(ir_graph *irg, irg_phase_state state) {
 657   _set_irg_phase_state(irg, state);
 658 }
 659
 660 op_pin_state
 661 (get_irg_pinned)(const ir_graph *irg) {
 662   return _get_irg_pinned(irg);
 663 }
 664
 665 irg_outs_state
 666 (get_irg_outs_state)(const ir_graph *irg) {
 667   return _get_irg_outs_state(irg);
 668 }
 669
 670 void
 671 (set_irg_outs_inconsistent)(ir_graph *irg) {
 672   _set_irg_outs_inconsistent(irg);
 673 }
 674
 675 irg_extblk_state
 676 (get_irg_extblk_state)(const ir_graph *irg) {
 677   return _get_irg_extblk_state(irg);
 678 }
 679
 680 void
 681 (set_irg_extblk_inconsistent)(ir_graph *irg) {
 682   _set_irg_extblk_inconsistent(irg);
 683 }
 684
 685 irg_dom_state
 686 (get_irg_dom_state)(const ir_graph *irg) {
 687   return _get_irg_dom_state(irg);
 688 }
 689
 690 irg_dom_state
 691 (get_irg_postdom_state)(const ir_graph *irg) {
 692   return _get_irg_postdom_state(irg);
 693 }
 694
 695 void
 696 (set_irg_doms_inconsistent)(ir_graph *irg) {
 697   _set_irg_doms_inconsistent(irg);
 698 }
 699
 700 irg_loopinfo_state
 701 (get_irg_loopinfo_state)(const ir_graph *irg) {
 702   return _get_irg_loopinfo_state(irg);
 703 }
 704
 705 void
 706 (set_irg_loopinfo_state)(ir_graph *irg, irg_loopinfo_state s) {
 707   _set_irg_loopinfo_state(irg, s);
 708 }
 709
 710 void
 711 (set_irg_loopinfo_inconsistent)(ir_graph *irg) {
 712   _set_irg_loopinfo_inconsistent(irg);
 713 }
 714
 715 void set_irp_loopinfo_inconsistent(void) {
 716   int i, n_irgs = get_irp_n_irgs();
 717   for (i = 0; i < n_irgs; ++i) {
 718     set_irg_loopinfo_inconsistent(get_irp_irg(i));
 719   }
 720 }
 721
 722
 723
 724 void
 725 (set_irg_pinned)(ir_graph *irg, op_pin_state p) {
 726   _set_irg_pinned(irg, p);
 727 }
 728
 729 irg_callee_info_state
 730 (get_irg_callee_info_state)(const ir_graph *irg) {
 731   return _get_irg_callee_info_state(irg);
 732 }
 733
 734 void
 735 (set_irg_callee_info_state)(ir_graph *irg, irg_callee_info_state s) {
 736   _set_irg_callee_info_state(irg, s);
 737 }
 738
 739 irg_inline_property
 740 (get_irg_inline_property)(const ir_graph *irg) {
 741   return _get_irg_inline_property(irg);
 742 }
 743
 744 void
 745 (set_irg_inline_property)(ir_graph *irg, irg_inline_property s) {
 746   _set_irg_inline_property(irg, s);
 747 }
 748
 749 unsigned
 750 (get_irg_additional_properties)(const ir_graph *irg) {
 751   return _get_irg_additional_properties(irg);
 752 }
 753
 754 void
 755 (set_irg_additional_properties)(ir_graph *irg, unsigned property_mask) {
 756   _set_irg_additional_properties(irg, property_mask);
 757 }
 758
 759 void
 760 (set_irg_additional_property)(ir_graph *irg, mtp_additional_property flag) {
 761   _set_irg_additional_property(irg, flag);
 762 }
 763
 764 void
 765 (set_irg_link)(ir_graph *irg, void *thing) {
 766   _set_irg_link(irg, thing);
 767 }
 768
 769 void *
 770 (get_irg_link)(const ir_graph *irg) {
 771   return _get_irg_link(irg);
 772 }
 773
 774 /** maximum visited flag content of all ir_graph visited fields. */
 775 static unsigned long max_irg_visited = 0;
 776
 777 unsigned long
 778 (get_irg_visited)(const ir_graph *irg) {
 779   return _get_irg_visited(irg);
 780 }
 781
 782 void
 783 set_irg_visited (ir_graph *irg, unsigned long visited)
 784 {
 785   irg->visited = visited;
 786   if (irg->visited > max_irg_visited) {
 787     max_irg_visited = irg->visited;
 788   }
 789 }
 790
 791 void
 792 inc_irg_visited (ir_graph *irg)
 793 {
 794   if (++irg->visited > max_irg_visited) {
 795     max_irg_visited = irg->visited;
 796   }
 797 }
 798
 799 unsigned long
 800 get_max_irg_visited(void)
 801 {
 802   /*
 803   int i;
 804   for(i = 0; i < get_irp_n_irgs(); i++)
 805   assert(max_irg_visited >= get_irg_visited(get_irp_irg(i)));
 806    */
 807   return max_irg_visited;
 808 }
 809
 810 void set_max_irg_visited(int val) {
 811   max_irg_visited = val;
 812 }
 813
 814 unsigned long
 815 inc_max_irg_visited(void)
 816 {
 817   /*
 818   int i;
 819   for(i = 0; i < get_irp_n_irgs(); i++)
 820   assert(max_irg_visited >= get_irg_visited(get_irp_irg(i)));
 821   */
 822   max_irg_visited++;
 823   return max_irg_visited;
 824 }
 825
 826 unsigned long
 827 (get_irg_block_visited)(const ir_graph *irg) {
 828   return _get_irg_block_visited(irg);
 829 }
 830
 831 void
 832 (set_irg_block_visited)(ir_graph *irg, unsigned long visited) {
 833   _set_irg_block_visited(irg, visited);
 834 }
 835
 836 void
 837 (inc_irg_block_visited)(ir_graph *irg) {
 838   _inc_irg_block_visited(irg);
 839 }
 840
 841 /* Return the floating point model of this graph. */
 842 unsigned (get_irg_fp_model)(const ir_graph *irg) {
 843   return _get_irg_fp_model(irg);
 844 }
 845
 846 /* Sets the floating point model for this graph. */
 847 void set_irg_fp_model(ir_graph *irg, unsigned model) {
 848   irg->fp_model = model;
 849 }
 850
 851 /**
 852  * walker Start->End: places Proj nodes into the same block
 853  * as it's predecessors
 854  *
 855  * @param n    the node
 856  * @param env  ignored
 857  */
 858 static void normalize_proj_walker(ir_node *n, void *env){
 859   if (is_Proj(n)) {
 860     ir_node *pred  = get_Proj_pred(n);
 861     ir_node *block = get_nodes_block(pred);
 862
 863     set_nodes_block(n, block);
 864   }
 865 }
 866
 867 /* move Proj nodes into the same block as its predecessors */
 868 void normalize_proj_nodes(ir_graph *irg) {
 869   irg_walk_graph(irg, NULL, normalize_proj_walker, NULL);
 870   set_irg_outs_inconsistent(irg);
 871 }
 872
 873 /* set a description for local value n */
 874 void set_irg_loc_description(ir_graph *irg, int n, void *description) {
 875   assert(0 <= n && n < irg->n_loc);
 876
 877   if (! irg->loc_descriptions)
 878     irg->loc_descriptions = xcalloc(sizeof(*irg->loc_descriptions), irg->n_loc);
 879
 880   irg->loc_descriptions[n] = description;
 881 }
 882
 883 /* get the description for local value n */
 884 void *get_irg_loc_description(ir_graph *irg, int n) {
 885   assert(0 <= n && n < irg->n_loc);
 886   return irg->loc_descriptions ? irg->loc_descriptions[n] : NULL;
 887 }
 888
 889 #ifndef NDEBUG
 890 void set_using_block_visited(ir_graph *irg) {
 891         assert(irg->using_block_visited == 0);
 892         irg->using_block_visited = 1;
 893 }
 894
 895 void clear_using_block_visited(ir_graph *irg) {
 896         assert(irg->using_block_visited == 1);
 897         irg->using_block_visited = 0;
 898 }
 899
 900 int using_block_visited(const ir_graph *irg) {
 901         return irg->using_block_visited;
 902 }
 903
 904
 905 void set_using_visited(ir_graph *irg) {
 906         assert(irg->using_visited == 0);
 907         irg->using_visited = 1;
 908 }
 909
 910 void clear_using_visited(ir_graph *irg) {
 911         assert(irg->using_visited == 1);
 912         irg->using_visited = 0;
 913 }
 914
 915 int using_visited(const ir_graph *irg) {
 916         return irg->using_visited;
 917 }
 918
 919
 920 void set_using_irn_link(ir_graph *irg) {
 921         assert(irg->using_irn_link == 0);
 922         irg->using_irn_link = 1;
 923 }
 924
 925 void clear_using_irn_link(ir_graph *irg) {
 926         assert(irg->using_irn_link == 1);
 927         irg->using_irn_link = 0;
 928 }
 929
 930 int using_irn_link(const ir_graph *irg) {
 931         return irg->using_irn_link;
 932 }
 933 #endif
 934
 935 /* Returns a estimated node count of the irg. */
 936 unsigned (get_irg_estimated_node_cnt)(const ir_graph *irg) {
 937   return _get_irg_estimated_node_cnt(irg);
 938 }
 939
 940 /* Returns the last irn index for this graph. */
 941 unsigned get_irg_last_idx(const ir_graph *irg) {
 942   return irg->last_node_idx;
 943 }
 944
 945 /* register additional space in an IR graph */
 946 size_t register_additional_graph_data(size_t size)
 947 {
 948   assert(!forbid_new_data && "Too late to register additional node data");
 949
 950   if (forbid_new_data)
 951     return 0;
 952
 953   return additional_graph_data_size += size;
 954 }