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

   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    Entry point to the representation of procedure code.
  23  * @author   Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
  24  */
  25 #include "config.h"
  26
  27 #include <string.h>
  28 #include <stddef.h>
  29
  30 #include "xmalloc.h"
  31 #include "ircons_t.h"
  32 #include "irgraph_t.h"
  33 #include "irprog_t.h"
  34 #include "irgraph_t.h"
  35 #include "irnode_t.h"
  36 #include "iropt_t.h"
  37 #include "irflag_t.h"
  38 #include "array.h"
  39 #include "irgmod.h"
  40 #include "irouts.h"
  41 #include "irhooks.h"
  42 #include "irtools.h"
  43 #include "util.h"
  44 #include "irgwalk.h"
  45 #include "irbackedge_t.h"
  46 #include "iredges_t.h"
  47 #include "type_t.h"
  48 #include "irmemory.h"
  49 #include "iroptimize.h"
  50 #include "irgopt.h"
  51
  52 #define INITIAL_IDX_IRN_MAP_SIZE 1024
  53 /** Suffix that is added to every frame type. */
  54 #define FRAME_TP_SUFFIX "frame_tp"
  55
  56 ir_graph *current_ir_graph;
  57 ir_graph *get_current_ir_graph(void)
  58 {
  59         return current_ir_graph;
  60 }
  61
  62 void set_current_ir_graph(ir_graph *graph)
  63 {
  64         current_ir_graph = graph;
  65 }
  66
  67 /** contains the suffix for frame type names */
  68 static ident *frame_type_suffix = NULL;
  69
  70 void firm_init_irgraph(void)
  71 {
  72         frame_type_suffix = new_id_from_str(FRAME_TP_SUFFIX);
  73 }
  74
  75 /**
  76  * Allocate a new IR graph.
  77  * This function respects the registered graph data. The only reason for
  78  * this function is, that there are two locations, where graphs are
  79  * allocated (new_r_ir_graph, new_const_code_irg).
  80  * @return Memory for a new graph.
  81  */
  82 static ir_graph *alloc_graph(void)
  83 {
  84         ir_graph *const res = XMALLOCZ(ir_graph);
  85         res->kind = k_ir_graph;
  86
  87         /* initialize the idx->node map. */
  88         res->idx_irn_map = NEW_ARR_F(ir_node *, INITIAL_IDX_IRN_MAP_SIZE);
  89         memset(res->idx_irn_map, 0, INITIAL_IDX_IRN_MAP_SIZE * sizeof(res->idx_irn_map[0]));
  90
  91         obstack_init(&res->obst);
  92
  93         /* value table for global value numbering for optimizing use in iropt.c */
  94         new_identities(res);
  95
  96         return res;
  97 }
  98
  99 /**
 100  * Frees an allocated IR graph
 101  */
 102 static void free_graph(ir_graph *irg)
 103 {
 104         for (ir_edge_kind_t i = EDGE_KIND_FIRST; i < EDGE_KIND_LAST; ++i)
 105                 edges_deactivate_kind(irg, i);
 106         DEL_ARR_F(irg->idx_irn_map);
 107         free(irg);
 108 }
 109
 110 void irg_set_nloc(ir_graph *res, int n_loc)
 111 {
 112         assert(irg_is_constrained(res, IR_GRAPH_CONSTRAINT_CONSTRUCTION));
 113
 114         res->n_loc = n_loc + 1;     /* number of local variables that are never
 115                                        dereferenced in this graph plus one for
 116                                        the store. This is not the number of
 117                                        parameters to the procedure!  */
 118
 119         if (res->loc_descriptions) {
 120                 xfree(res->loc_descriptions);
 121                 res->loc_descriptions = NULL;
 122         }
 123 }
 124
 125 ir_graph *new_r_ir_graph(ir_entity *ent, int n_loc)
 126 {
 127         ir_graph *res;
 128         ir_node  *first_block;
 129         ir_node  *start, *start_block, *initial_mem, *projX;
 130
 131         res = alloc_graph();
 132
 133         /* inform statistics here, as blocks will be already build on this graph */
 134         hook_new_graph(res, ent);
 135
 136         /* graphs are in construction mode by default */
 137         add_irg_constraints(res, IR_GRAPH_CONSTRAINT_CONSTRUCTION);
 138         irg_set_nloc(res, n_loc);
 139
 140         res->irg_pinned_state    = op_pin_state_pinned;
 141         res->typeinfo_state      = ir_typeinfo_none;
 142         set_irp_typeinfo_inconsistent();           /* there is a new graph with typeinfo_none. */
 143         res->callee_info_state   = irg_callee_info_none;
 144         res->class_cast_state    = ir_class_casts_transitive;
 145         res->fp_model            = fp_model_precise;
 146         res->mem_disambig_opt    = aa_opt_inherited;
 147
 148         /*-- Type information for the procedure of the graph --*/
 149         res->ent = ent;
 150         set_entity_irg(ent, res);
 151
 152         /*--  a class type so that it can contain "inner" methods as in Pascal. --*/
 153         res->frame_type = new_type_frame();
 154
 155         /* the Anchor node must be created first */
 156         res->anchor = new_r_Anchor(res);
 157
 158         /*-- Nodes needed in every graph --*/
 159         set_irg_end_block(res, new_r_immBlock(res));
 160         set_irg_end(res, new_r_End(res, 0, NULL));
 161
 162         start_block = new_r_Block_noopt(res, 0, NULL);
 163         set_irg_start_block(res, start_block);
 164         set_irg_no_mem     (res, new_r_NoMem(res));
 165         start = new_r_Start(res);
 166         set_irg_start      (res, start);
 167
 168         /* Proj results of start node */
 169         projX                   = new_r_Proj(start, mode_X, pn_Start_X_initial_exec);
 170         set_irg_initial_exec    (res, projX);
 171         set_irg_frame           (res, new_r_Proj(start, mode_P_data, pn_Start_P_frame_base));
 172         set_irg_args            (res, new_r_Proj(start, mode_T,      pn_Start_T_args));
 173         initial_mem             = new_r_Proj(start, mode_M, pn_Start_M);
 174         set_irg_initial_mem(res, initial_mem);
 175
 176         res->index       = get_irp_new_irg_idx();
 177 #ifdef DEBUG_libfirm
 178         res->graph_nr    = get_irp_new_node_nr();
 179 #endif
 180
 181         set_r_cur_block(res, start_block);
 182         set_r_store(res, initial_mem);
 183
 184         /*-- Make a block to start with --*/
 185         first_block = new_r_Block(res, 1, &projX);
 186         set_r_cur_block(res, first_block);
 187
 188         res->method_execution_frequency = -1.0;
 189
 190         return res;
 191 }
 192
 193 ir_graph *new_ir_graph(ir_entity *ent, int n_loc)
 194 {
 195         ir_graph *res = new_r_ir_graph(ent, n_loc);
 196         add_irp_irg(res);          /* remember this graph global. */
 197         return res;
 198 }
 199
 200 ir_graph *new_const_code_irg(void)
 201 {
 202         ir_graph *res = alloc_graph();
 203         ir_node  *body_block;
 204         ir_node  *end;
 205         ir_node  *end_block;
 206         ir_node  *no_mem;
 207         ir_node  *projX;
 208         ir_node  *start_block;
 209         ir_node  *start;
 210
 211         /* inform statistics here, as blocks will be already build on this graph */
 212         hook_new_graph(res, NULL);
 213
 214         res->n_loc            = 1; /* Only the memory. */
 215         res->irg_pinned_state = op_pin_state_pinned;
 216         res->fp_model         = fp_model_precise;
 217
 218         add_irg_constraints(res, IR_GRAPH_CONSTRAINT_CONSTRUCTION);
 219
 220         /* the Anchor node must be created first */
 221         res->anchor = new_r_Anchor(res);
 222
 223         /* -- The end block -- */
 224         end_block = new_r_Block_noopt(res, 0, NULL);
 225         set_irg_end_block(res, end_block);
 226         end = new_r_End(res, 0, NULL);
 227         set_irg_end(res, end);
 228
 229         /* -- The start block -- */
 230         start_block = new_r_Block_noopt(res, 0, NULL);
 231         set_irg_start_block(res, start_block);
 232         no_mem = new_r_NoMem(res);
 233         set_irg_no_mem(res, no_mem);
 234         start = new_r_Start(res);
 235         set_irg_start(res, start);
 236
 237         /* Proj results of start node */
 238         set_irg_initial_mem(res, new_r_Proj(start, mode_M, pn_Start_M));
 239         projX = new_r_Proj(start, mode_X, pn_Start_X_initial_exec);
 240
 241         body_block = new_r_Block(res, 1, &projX);
 242
 243         set_r_cur_block(res, body_block);
 244
 245         /* Set the visited flag high enough that the blocks will never be visited. */
 246         set_irn_visited(body_block, -1);
 247         set_Block_block_visited(body_block, -1);
 248         set_Block_block_visited(start_block, -1);
 249         set_irn_visited(start_block, -1);
 250
 251         return res;
 252 }
 253
 254 /**
 255  * Pre-Walker: Copies blocks and nodes from the original method graph
 256  * to the copied graph.
 257  *
 258  * @param n    A node from the original method graph.
 259  * @param env  The copied graph.
 260  */
 261 static void copy_all_nodes(ir_node *node, void *env)
 262 {
 263         ir_graph *irg      = (ir_graph*)env;
 264         ir_node  *new_node = irn_copy_into_irg(node, irg);
 265
 266         set_irn_link(node, new_node);
 267
 268         /* fix access to entities on the stack frame */
 269         if (is_Sel(new_node)) {
 270                 ir_entity *ent = get_Sel_entity(new_node);
 271                 ir_type   *tp  = get_entity_owner(ent);
 272
 273                 if (is_frame_type(tp)) {
 274                         /* replace by the copied entity */
 275                         ent = (ir_entity*)get_entity_link(ent);
 276
 277                         assert(is_entity(ent));
 278                         assert(get_entity_owner(ent) == get_irg_frame_type(irg));
 279                         set_Sel_entity(new_node, ent);
 280                 }
 281         }
 282 }
 283
 284 /**
 285  * Post-walker: Set the predecessors of the copied nodes.
 286  * The copied nodes are set as link of their original nodes. The links of
 287  * "irn" predecessors are the predecessors of copied node.
 288  */
 289 static void rewire(ir_node *irn, void *env)
 290 {
 291         (void) env;
 292         irn_rewire_inputs(irn);
 293 }
 294
 295 static ir_node *get_new_node(const ir_node *old_node)
 296 {
 297         return (ir_node*) get_irn_link(old_node);
 298 }
 299
 300 ir_graph *create_irg_copy(ir_graph *irg)
 301 {
 302         ir_graph *res;
 303
 304         res = alloc_graph();
 305
 306         res->irg_pinned_state = irg->irg_pinned_state;
 307         res->fp_model         = irg->fp_model;
 308
 309         /* clone the frame type here for safety */
 310         irp_reserve_resources(irp, IRP_RESOURCE_ENTITY_LINK);
 311         res->frame_type  = clone_frame_type(irg->frame_type);
 312
 313         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
 314
 315         /* copy all nodes from the graph irg to the new graph res */
 316         irg_walk_anchors(irg, copy_all_nodes, rewire, res);
 317
 318         /* copy the Anchor node */
 319         res->anchor = get_new_node(irg->anchor);
 320
 321         /* -- The end block -- */
 322         set_irg_end_block (res, get_new_node(get_irg_end_block(irg)));
 323         set_irg_end       (res, get_new_node(get_irg_end(irg)));
 324
 325         /* -- The start block -- */
 326         set_irg_start_block(res, get_new_node(get_irg_start_block(irg)));
 327         set_irg_no_mem     (res, get_new_node(get_irg_no_mem(irg)));
 328         set_irg_start      (res, get_new_node(get_irg_start(irg)));
 329
 330         /* Proj results of start node */
 331         set_irg_initial_mem(res, get_new_node(get_irg_initial_mem(irg)));
 332
 333         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
 334         irp_free_resources(irp, IRP_RESOURCE_ENTITY_LINK);
 335
 336         return res;
 337 }
 338
 339 void free_ir_graph(ir_graph *irg)
 340 {
 341         assert(is_ir_graph(irg));
 342
 343         remove_irp_irg(irg);
 344         confirm_irg_properties(irg, IR_GRAPH_PROPERTIES_NONE);
 345
 346         hook_free_graph(irg);
 347         free_irg_outs(irg);
 348         del_identities(irg);
 349         if (irg->ent) {
 350                 set_entity_irg(irg->ent, NULL);  /* not set in const code irg */
 351         }
 352
 353         free_End(get_irg_end(irg));
 354         obstack_free(&irg->obst, NULL);
 355         if (irg->loc_descriptions)
 356                 free(irg->loc_descriptions);
 357         irg->kind = k_BAD;
 358         free_graph(irg);
 359 }
 360
 361 int (is_ir_graph)(const void *thing)
 362 {
 363         return is_ir_graph_(thing);
 364 }
 365
 366 #ifdef DEBUG_libfirm
 367 long get_irg_graph_nr(const ir_graph *irg)
 368 {
 369         return irg->graph_nr;
 370 }
 371 #else
 372 long get_irg_graph_nr(const ir_graph *irg)
 373 {
 374         return PTR_TO_INT(irg);
 375 }
 376 #endif
 377
 378 size_t get_irg_idx(const ir_graph *irg)
 379 {
 380         return irg->index;
 381 }
 382
 383 ir_node *(get_idx_irn)(const ir_graph *irg, unsigned idx)
 384 {
 385         return get_idx_irn_(irg, idx);
 386 }
 387
 388 ir_node *(get_irg_start_block)(const ir_graph *irg)
 389 {
 390         return get_irg_start_block_(irg);
 391 }
 392
 393 void (set_irg_start_block)(ir_graph *irg, ir_node *node)
 394 {
 395         set_irg_start_block_(irg, node);
 396 }
 397
 398 ir_node *(get_irg_start)(const ir_graph *irg)
 399 {
 400         return get_irg_start_(irg);
 401 }
 402
 403 void (set_irg_start)(ir_graph *irg, ir_node *node)
 404 {
 405         set_irg_start_(irg, node);
 406 }
 407
 408 ir_node *(get_irg_end_block)(const ir_graph *irg)
 409 {
 410         return get_irg_end_block_(irg);
 411 }
 412
 413 void (set_irg_end_block)(ir_graph *irg, ir_node *node)
 414 {
 415         set_irg_end_block_(irg, node);
 416 }
 417
 418 ir_node *(get_irg_end)(const ir_graph *irg)
 419 {
 420         return get_irg_end_(irg);
 421 }
 422
 423 void (set_irg_end)(ir_graph *irg, ir_node *node)
 424 {
 425         set_irg_end_(irg, node);
 426 }
 427
 428 ir_node *(get_irg_initial_exec)(const ir_graph *irg)
 429 {
 430         return get_irg_initial_exec_(irg);
 431 }
 432
 433 void (set_irg_initial_exec)(ir_graph *irg, ir_node *node)
 434 {
 435         set_irg_initial_exec_(irg, node);
 436 }
 437
 438 ir_node *(get_irg_frame)(const ir_graph *irg)
 439 {
 440         return get_irg_frame_(irg);
 441 }
 442
 443 void (set_irg_frame)(ir_graph *irg, ir_node *node)
 444 {
 445         set_irg_frame_(irg, node);
 446 }
 447
 448 ir_node *(get_irg_initial_mem)(const ir_graph *irg)
 449 {
 450         return get_irg_initial_mem_(irg);
 451 }
 452
 453 void (set_irg_initial_mem)(ir_graph *irg, ir_node *node)
 454 {
 455         set_irg_initial_mem_(irg, node);
 456 }
 457
 458 ir_node *(get_irg_args)(const ir_graph *irg)
 459 {
 460         return get_irg_args_(irg);
 461 }
 462
 463 void (set_irg_args)(ir_graph *irg, ir_node *node)
 464 {
 465         set_irg_args_(irg, node);
 466 }
 467
 468 ir_node *(get_irg_no_mem)(const ir_graph *irg)
 469 {
 470         return get_irg_no_mem_(irg);
 471 }
 472
 473 void (set_irg_no_mem)(ir_graph *irg, ir_node *node)
 474 {
 475         set_irg_no_mem_(irg, node);
 476 }
 477
 478 ir_entity *(get_irg_entity)(const ir_graph *irg)
 479 {
 480         return get_irg_entity_(irg);
 481 }
 482
 483 void (set_irg_entity)(ir_graph *irg, ir_entity *ent)
 484 {
 485         set_irg_entity_(irg, ent);
 486 }
 487
 488 ir_type *(get_irg_frame_type)(ir_graph *irg)
 489 {
 490         return get_irg_frame_type_(irg);
 491 }
 492
 493 void (set_irg_frame_type)(ir_graph *irg, ir_type *ftp)
 494 {
 495         set_irg_frame_type_(irg, ftp);
 496 }
 497
 498 int get_irg_n_locs(ir_graph *irg)
 499 {
 500         return irg->n_loc - 1;
 501 }
 502
 503 int node_is_in_irgs_storage(const ir_graph *irg, const ir_node *n)
 504 {
 505         /* Check whether the ir_node pointer is on the obstack.
 506          * A more sophisticated check would test the "whole" ir_node. */
 507         for (struct _obstack_chunk const *p = irg->obst.chunk; p; p = p->prev) {
 508                 if (((char *)p->contents <= (char *)n) && ((char *)n < (char *)p->limit))
 509                         return 1;
 510         }
 511
 512         return 0;
 513 }
 514
 515 op_pin_state (get_irg_pinned)(const ir_graph *irg)
 516 {
 517         return get_irg_pinned_(irg);
 518 }
 519
 520 irg_callee_info_state (get_irg_callee_info_state)(const ir_graph *irg)
 521 {
 522         return get_irg_callee_info_state_(irg);
 523 }
 524
 525 void (set_irg_callee_info_state)(ir_graph *irg, irg_callee_info_state s)
 526 {
 527         set_irg_callee_info_state_(irg, s);
 528 }
 529
 530 void (set_irg_link)(ir_graph *irg, void *thing)
 531 {
 532         set_irg_link_(irg, thing);
 533 }
 534
 535 void *(get_irg_link)(const ir_graph *irg)
 536 {
 537         return get_irg_link_(irg);
 538 }
 539
 540 ir_visited_t (get_irg_visited)(const ir_graph *irg)
 541 {
 542         return get_irg_visited_(irg);
 543 }
 544
 545 /** maximum visited flag content of all ir_graph visited fields. */
 546 static ir_visited_t max_irg_visited = 0;
 547
 548 void set_irg_visited(ir_graph *irg, ir_visited_t visited)
 549 {
 550         irg->visited = visited;
 551         if (irg->visited > max_irg_visited) {
 552                 max_irg_visited = irg->visited;
 553         }
 554 }
 555
 556 void inc_irg_visited(ir_graph *irg)
 557 {
 558         ++irg->visited;
 559         if (irg->visited > max_irg_visited) {
 560                 max_irg_visited = irg->visited;
 561         }
 562 }
 563
 564 ir_visited_t get_max_irg_visited(void)
 565 {
 566         return max_irg_visited;
 567 }
 568
 569 void set_max_irg_visited(int val)
 570 {
 571         max_irg_visited = val;
 572 }
 573
 574 ir_visited_t inc_max_irg_visited(void)
 575 {
 576 #ifndef NDEBUG
 577         size_t i;
 578         for (i = 0; i < get_irp_n_irgs(); i++)
 579                 assert(max_irg_visited >= get_irg_visited(get_irp_irg(i)));
 580 #endif
 581         return ++max_irg_visited;
 582 }
 583
 584 ir_visited_t (get_irg_block_visited)(const ir_graph *irg)
 585 {
 586         return get_irg_block_visited_(irg);
 587 }
 588
 589 void (set_irg_block_visited)(ir_graph *irg, ir_visited_t visited)
 590 {
 591         set_irg_block_visited_(irg, visited);
 592 }
 593
 594 void (inc_irg_block_visited)(ir_graph *irg)
 595 {
 596   inc_irg_block_visited_(irg);
 597 }
 598
 599 unsigned (get_irg_fp_model)(const ir_graph *irg)
 600 {
 601         return get_irg_fp_model_(irg);
 602 }
 603
 604 void set_irg_fp_model(ir_graph *irg, unsigned model)
 605 {
 606         irg->fp_model = model;
 607 }
 608
 609 void set_irg_loc_description(ir_graph *irg, int n, void *description)
 610 {
 611         assert(0 <= n && n < irg->n_loc);
 612
 613         if (! irg->loc_descriptions)
 614                 irg->loc_descriptions = XMALLOCNZ(void*, irg->n_loc);
 615
 616         irg->loc_descriptions[n] = description;
 617 }
 618
 619 void *get_irg_loc_description(ir_graph *irg, int n)
 620 {
 621         assert(0 <= n && n < irg->n_loc);
 622         return irg->loc_descriptions ? irg->loc_descriptions[n] : NULL;
 623 }
 624
 625 #ifndef NDEBUG
 626 void ir_reserve_resources(ir_graph *irg, ir_resources_t resources)
 627 {
 628         assert((irg->reserved_resources & resources) == 0);
 629         irg->reserved_resources |= resources;
 630 }
 631
 632 void ir_free_resources(ir_graph *irg, ir_resources_t resources)
 633 {
 634         assert((irg->reserved_resources & resources) == resources);
 635         irg->reserved_resources &= ~resources;
 636 }
 637
 638 ir_resources_t ir_resources_reserved(const ir_graph *irg)
 639 {
 640         return irg->reserved_resources;
 641 }
 642 #endif
 643
 644 unsigned get_irg_last_idx(const ir_graph *irg)
 645 {
 646         return irg->last_node_idx;
 647 }
 648
 649 void add_irg_constraints(ir_graph *irg, ir_graph_constraints_t constraints)
 650 {
 651         irg->constraints |= constraints;
 652 }
 653
 654 void clear_irg_constraints(ir_graph *irg, ir_graph_constraints_t constraints)
 655 {
 656         irg->constraints &= ~constraints;
 657 }
 658
 659 int (irg_is_constrained)(const ir_graph *irg, ir_graph_constraints_t constraints)
 660 {
 661         return irg_is_constrained_(irg, constraints);
 662 }
 663
 664 void (add_irg_properties)(ir_graph *irg, ir_graph_properties_t props)
 665 {
 666         add_irg_properties_(irg, props);
 667 }
 668
 669 void (clear_irg_properties)(ir_graph *irg, ir_graph_properties_t props)
 670 {
 671         clear_irg_properties_(irg, props);
 672 }
 673
 674 int (irg_has_properties)(const ir_graph *irg, ir_graph_properties_t props)
 675 {
 676         return irg_has_properties_(irg, props);
 677 }
 678
 679 typedef void (*assure_property_func)(ir_graph *irg);
 680
 681 void assure_irg_properties(ir_graph *irg, ir_graph_properties_t props)
 682 {
 683         static struct {
 684                 ir_graph_properties_t property;
 685                 assure_property_func  func;
 686         } property_functions[] = {
 687                 { IR_GRAPH_PROPERTY_ONE_RETURN,               normalize_one_return },
 688                 { IR_GRAPH_PROPERTY_MANY_RETURNS,             normalize_n_returns },
 689                 { IR_GRAPH_PROPERTY_NO_CRITICAL_EDGES,        remove_critical_cf_edges },
 690                 { IR_GRAPH_PROPERTY_NO_UNREACHABLE_CODE,      remove_unreachable_code },
 691                 { IR_GRAPH_PROPERTY_NO_BADS,                  remove_bads },
 692                 { IR_GRAPH_PROPERTY_NO_TUPLES,                remove_tuples },
 693                 { IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE,     assure_doms },
 694                 { IR_GRAPH_PROPERTY_CONSISTENT_POSTDOMINANCE, assure_postdoms },
 695                 { IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES,     assure_edges },
 696                 { IR_GRAPH_PROPERTY_CONSISTENT_OUTS,          assure_irg_outs },
 697                 { IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO,      assure_loopinfo },
 698                 { IR_GRAPH_PROPERTY_CONSISTENT_ENTITY_USAGE,  assure_irg_entity_usage_computed },
 699                 { IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE_FRONTIERS, ir_compute_dominance_frontiers },
 700         };
 701         size_t i;
 702         for (i = 0; i < ARRAY_SIZE(property_functions); ++i) {
 703                 ir_graph_properties_t missing = props & ~irg->properties;
 704                 if (missing & property_functions[i].property)
 705                         property_functions[i].func(irg);
 706         }
 707         assert((props & ~irg->properties) == IR_GRAPH_PROPERTIES_NONE);
 708 }
 709
 710 void confirm_irg_properties(ir_graph *irg, ir_graph_properties_t props)
 711 {
 712         clear_irg_properties(irg, ~props);
 713         if (! (props & IR_GRAPH_PROPERTY_CONSISTENT_OUT_EDGES))
 714                 edges_deactivate(irg);
 715         if (! (props & IR_GRAPH_PROPERTY_CONSISTENT_OUTS)
 716             && (irg->properties & IR_GRAPH_PROPERTY_CONSISTENT_OUTS))
 717             free_irg_outs(irg);
 718         if (! (props & IR_GRAPH_PROPERTY_CONSISTENT_DOMINANCE_FRONTIERS))
 719                 ir_free_dominance_frontiers(irg);
 720 }