nsz Git - libfirm/blob - ir/ir/irgwalk.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   Functions for traversing ir graphs
  23  * @author  Boris Boesler, Goetz Lindenmaier, Michael Beck
  24  * @version $Id$
  25  * @summary
  26  *  traverse an ir graph
  27  *  - execute the pre function before recursion
  28  *  - execute the post function after recursion
  29  */
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #ifdef HAVE_STDLIB_H
  35 # include <stdlib.h>
  36 #endif
  37
  38 #include "irnode_t.h"
  39 #include "irgraph_t.h" /* visited flag */
  40 #include "irprog.h"
  41 #include "irgwalk.h"
  42 #include "typewalk.h"
  43 #include "irhooks.h"
  44 #include "ircgcons.h"
  45
  46 #include "pset_new.h"
  47 #include "array.h"
  48
  49 /**
  50  * Walk over an interprocedural graph (callgraph).
  51  * Visits only graphs in irg_set.
  52  */
  53 static void irg_walk_cg(ir_node * node, unsigned long visited,
  54                         pset_new_t *irg_set, irg_walk_func *pre,
  55                         irg_walk_func *post, void * env) {
  56   int i;
  57   ir_graph * rem = current_ir_graph;
  58   ir_node * pred;
  59
  60   assert(node && node->kind == k_ir_node);
  61   if (get_irn_visited(node) >= visited) return;
  62
  63   set_irn_visited(node, visited);
  64
  65   if (pre) pre(node, env);
  66
  67   pred = skip_Proj(node);
  68   if (get_irn_op(pred) == op_CallBegin
  69       || get_irn_op(pred) == op_EndReg
  70       || get_irn_op(pred) == op_EndExcept) {
  71     current_ir_graph = get_irn_irg(pred);
  72   }
  73
  74   if (is_no_Block(node)) { /* not block */
  75     irg_walk_cg(get_nodes_block(node), visited, irg_set, pre, post, env);
  76   }
  77
  78   if (get_irn_op(node) == op_Block) { /* block */
  79     for (i = get_irn_arity(node) - 1; i >= 0; --i) {
  80       ir_node * exec = get_irn_n(node, i);
  81       ir_node * pred = skip_Proj(exec);
  82       if ((get_irn_op(pred) != op_CallBegin
  83            && get_irn_op(pred) != op_EndReg
  84            && get_irn_op(pred) != op_EndExcept)
  85           || pset_new_contains(irg_set, get_irn_irg(pred))) {
  86         irg_walk_cg(exec, visited, irg_set, pre, post, env);
  87       }
  88     }
  89   } else if (get_irn_op(node) == op_Filter) { /* filter */
  90     for (i = get_irn_arity(node) - 1; i >= 0; --i) {
  91       ir_node * pred = get_irn_n(node, i);
  92       if (get_irn_op(pred) == op_Unknown || get_irn_op(pred) == op_Bad) {
  93         irg_walk_cg(pred, visited, irg_set, pre, post, env);
  94       } else {
  95         ir_node * exec;
  96         exec = skip_Proj(get_Block_cfgpred(get_nodes_block(node), i));
  97
  98         if (op_Bad == get_irn_op (exec)) {
  99           continue;
 100         }
 101
 102         assert(get_irn_op(exec) == op_CallBegin
 103                || get_irn_op(exec) == op_EndReg
 104                || get_irn_op(exec) == op_EndExcept);
 105         if (pset_new_contains(irg_set, get_irn_irg(exec))) {
 106           current_ir_graph = get_irn_irg(exec);
 107           irg_walk_cg(pred, visited, irg_set, pre, post, env);
 108           current_ir_graph = rem;
 109         }
 110       }
 111     }
 112   } else {                      /* everything else */
 113     for (i = get_irn_arity(node) - 1; i >= 0; --i) {
 114       irg_walk_cg(get_irn_n(node, i), visited, irg_set, pre, post, env);
 115     }
 116   }
 117
 118   if (post) post(node, env);
 119
 120   current_ir_graph = rem;
 121 }
 122
 123
 124 /**
 125  * Insert all ir_graphs in irg_set, that are (transitive) reachable.
 126  */
 127 static void collect_irgs(ir_node * node, pset_new_t *irg_set) {
 128   if (is_Call(node)) {
 129     int i;
 130     for (i = get_Call_n_callees(node) - 1; i >= 0; --i) {
 131       ir_entity * ent = get_Call_callee(node, i);
 132       ir_graph * irg = get_entity_irg(ent);
 133       if (irg && !pset_new_contains(irg_set, irg)) {
 134         pset_new_insert(irg_set, irg);
 135         irg_walk_graph(irg, (irg_walk_func *) collect_irgs, NULL, irg_set);
 136       }
 137     }
 138   }
 139 }
 140
 141 /**
 142  * specialized version of irg_walk_2, called if only pre callback exists
 143  *
 144  * @return number of visited nodes
 145  */
 146 static unsigned
 147 irg_walk_2_pre(ir_node *node, irg_walk_func *pre, void * env) {
 148   int i;
 149   unsigned cnt = 1;
 150   ir_graph *irg = current_ir_graph;
 151
 152   set_irn_visited(node, irg->visited);
 153
 154   pre(node, env);
 155
 156   if (node->op != op_Block) {
 157     ir_node *pred = get_irn_n(node, -1);
 158     if (pred->visited < irg->visited)
 159       cnt += irg_walk_2_pre(pred, pre, env);
 160   }
 161   for (i = get_irn_arity(node) - 1; i >= 0; --i) {
 162     ir_node *pred = get_irn_n(node, i);
 163     if (pred->visited < irg->visited)
 164       cnt += irg_walk_2_pre(pred, pre, env);
 165   }
 166   return cnt;
 167 }
 168
 169 /**
 170  * specialized version of irg_walk_2, called if only post callback exists
 171  *
 172  * @return number of visited nodes
 173  */
 174 static unsigned
 175 irg_walk_2_post(ir_node *node, irg_walk_func *post, void * env) {
 176   int i;
 177   unsigned cnt = 1;
 178   ir_graph *irg = current_ir_graph;
 179
 180   set_irn_visited(node, irg->visited);
 181
 182   if (node->op != op_Block) {
 183     ir_node *pred = get_irn_n(node, -1);
 184     if (pred->visited < irg->visited)
 185       cnt += irg_walk_2_post(pred, post, env);
 186   }
 187   for (i = get_irn_arity(node) - 1; i >= 0; --i) {
 188     ir_node *pred = get_irn_n(node, i);
 189     if (pred->visited < irg->visited)
 190       cnt += irg_walk_2_post(pred, post, env);
 191   }
 192
 193   post(node, env);
 194
 195   return cnt;
 196 }
 197
 198 /**
 199  * specialized version of irg_walk_2, called if pre and post callbacks exist
 200  *
 201  * @return number of visited nodes
 202  */
 203 static unsigned
 204 irg_walk_2_both(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env) {
 205   int i;
 206   unsigned cnt = 1;
 207   ir_graph *irg = current_ir_graph;
 208
 209   set_irn_visited(node, irg->visited);
 210
 211   pre(node, env);
 212
 213   if (node->op != op_Block) {
 214     ir_node *pred = get_irn_n(node, -1);
 215     if (pred->visited < irg->visited)
 216       cnt += irg_walk_2_both(pred, pre, post, env);
 217   }
 218   for (i = get_irn_arity(node) - 1; i >= 0; --i) {
 219     ir_node *pred = get_irn_n(node, i);
 220     if (pred->visited < irg->visited)
 221       cnt += irg_walk_2_both(pred, pre, post, env);
 222   }
 223
 224   post(node, env);
 225
 226   return cnt;
 227 }
 228
 229 /**
 230  * Intraprozedural graph walker.
 231  *
 232  * @return number of visited nodes
 233  */
 234 static unsigned
 235 irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env)
 236 {
 237   if (node->visited < current_ir_graph->visited) {
 238     if      (!post) return irg_walk_2_pre (node, pre, env);
 239     else if (!pre)  return irg_walk_2_post(node, post, env);
 240     else            return irg_walk_2_both(node, pre, post, env);
 241   }
 242   return 0;
 243 }
 244
 245 /* a counter */
 246 static unsigned nodes_touched = 0;
 247
 248 /*
 249  * generic graph walker
 250  */
 251 void irg_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 252 {
 253   assert(is_ir_node(node));
 254
 255   if (get_interprocedural_view()) {
 256         pset_new_t           irg_set;
 257         pset_new_iterator_t  iter;
 258     unsigned long        visited;
 259     ir_graph            *irg;
 260     assert(get_irp_ip_view_state() == ip_view_valid);
 261
 262         pset_new_init(&irg_set);
 263     set_interprocedural_view(0);
 264     pset_new_insert(&irg_set, current_ir_graph);
 265     irg_walk(node, (irg_walk_func *) collect_irgs, NULL, &irg_set);
 266     set_interprocedural_view(1);
 267     visited = get_max_irg_visited() + 1;
 268
 269         foreach_pset_new(&irg_set, irg, iter) {
 270       set_irg_visited(irg, visited);
 271     }
 272     irg_walk_cg(node, visited, &irg_set, pre, post, env);
 273         pset_new_destroy(&irg_set);
 274   } else {
 275     set_using_visited(current_ir_graph);
 276     inc_irg_visited(current_ir_graph);
 277     nodes_touched = irg_walk_2(node, pre, post, env);
 278     clear_using_visited(current_ir_graph);
 279   }
 280   return;
 281 }
 282
 283 /*
 284  * walk over a graph
 285  */
 286 void irg_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env) {
 287   ir_graph * rem = current_ir_graph;
 288
 289   hook_irg_walk(irg, (generic_func *)pre, (generic_func *)post);
 290   current_ir_graph = irg;
 291   irg_walk(get_irg_end(irg), pre, post, env);
 292   irg->estimated_node_count = nodes_touched;
 293   current_ir_graph = rem;
 294 }
 295
 296 /* Executes irg_walk(end, pre, post, env) for all irgraphs in irprog.
 297    Sets current_ir_graph properly for each walk.  Conserves current
 298    current_ir_graph. */
 299 void all_irg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) {
 300   int i;
 301   ir_graph *irg, *rem;
 302
 303   rem = current_ir_graph;
 304
 305   for (i = 0; i < get_irp_n_irgs(); i++) {
 306     irg = get_irp_irg(i);
 307     current_ir_graph = irg;
 308     irg_walk(get_irg_end(irg), pre, post, env);
 309   }
 310   current_ir_graph = rem;
 311 }
 312
 313 /***************************************************************************/
 314
 315 /**
 316  * specialized version of irg_walk_in_or_dep_2, called if only pre callback exists
 317  *
 318  * @return number of visited nodes
 319  */
 320 static unsigned
 321 irg_walk_in_or_dep_2_pre(ir_node *node, irg_walk_func *pre, void *env) {
 322   int i;
 323   unsigned cnt = 1;
 324   ir_graph *irg = current_ir_graph;
 325
 326   set_irn_visited(node, irg->visited);
 327
 328   pre(node, env);
 329
 330   if (node->op != op_Block) {
 331     ir_node *pred = get_irn_n(node, -1);
 332     if (pred->visited < irg->visited)
 333       cnt += irg_walk_in_or_dep_2_pre(pred, pre, env);
 334   }
 335   for (i = get_irn_ins_or_deps(node) - 1; i >= 0; --i) {
 336     ir_node *pred = get_irn_in_or_dep(node, i);
 337     if (pred->visited < irg->visited)
 338       cnt += irg_walk_in_or_dep_2_pre(pred, pre, env);
 339   }
 340   return cnt;
 341 }
 342
 343 /**
 344  * specialized version of irg_walk_in_or_dep_2, called if only post callback exists
 345  *
 346  * @return number of visited nodes
 347  */
 348 static unsigned
 349 irg_walk_in_or_dep_2_post(ir_node *node, irg_walk_func *post, void *env) {
 350   int i;
 351   unsigned cnt = 1;
 352   ir_graph *irg = current_ir_graph;
 353
 354   set_irn_visited(node, irg->visited);
 355
 356   if (node->op != op_Block) {
 357     ir_node *pred = get_irn_n(node, -1);
 358     if (pred->visited < irg->visited)
 359       cnt += irg_walk_in_or_dep_2_post(pred, post, env);
 360   }
 361   for (i = get_irn_ins_or_deps(node) - 1; i >= 0; --i) {
 362     ir_node *pred = get_irn_in_or_dep(node, i);
 363     if (pred->visited < irg->visited)
 364       cnt += irg_walk_in_or_dep_2_post(pred, post, env);
 365   }
 366
 367   post(node, env);
 368
 369   return cnt;
 370 }
 371
 372 /**
 373  * specialized version of irg_walk_in_or_dep_2, called if pre and post callbacks exist
 374  *
 375  * @return number of visited nodes
 376  */
 377 static unsigned
 378 irg_walk_in_or_dep_2_both(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env) {
 379   int i;
 380   unsigned cnt = 1;
 381   ir_graph *irg = current_ir_graph;
 382
 383   set_irn_visited(node, irg->visited);
 384
 385   pre(node, env);
 386
 387   if (node->op != op_Block) {
 388     ir_node *pred = get_irn_n(node, -1);
 389     if (pred->visited < irg->visited)
 390       cnt += irg_walk_in_or_dep_2_both(pred, pre, post, env);
 391   }
 392   for (i = get_irn_ins_or_deps(node) - 1; i >= 0; --i) {
 393     ir_node *pred = get_irn_in_or_dep(node, i);
 394     if (pred->visited < irg->visited)
 395       cnt += irg_walk_in_or_dep_2_both(pred, pre, post, env);
 396   }
 397
 398   post(node, env);
 399
 400   return cnt;
 401 }
 402
 403 /**
 404  * Intraprozedural graph walker. Follows dependency edges as well.
 405  *
 406  * @return number of visited nodes
 407  */
 408 static unsigned
 409 irg_walk_in_or_dep_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 410 {
 411   if (node->visited < current_ir_graph->visited) {
 412     if      (! post) return irg_walk_in_or_dep_2_pre (node, pre, env);
 413     else if (! pre)  return irg_walk_in_or_dep_2_post(node, post, env);
 414     else             return irg_walk_in_or_dep_2_both(node, pre, post, env);
 415   }
 416   return 0;
 417 }
 418
 419 /*
 420  * Generic graph walker. Follows dependency edges as well.
 421  */
 422 void irg_walk_in_or_dep(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 423 {
 424   assert(is_ir_node(node));
 425
 426   if (get_interprocedural_view()) {
 427         assert(0 && "This is not yet implemented.");
 428   } else {
 429     set_using_visited(current_ir_graph);
 430     inc_irg_visited(current_ir_graph);
 431     nodes_touched = irg_walk_in_or_dep_2(node, pre, post, env);
 432     clear_using_visited(current_ir_graph);
 433   }
 434   return;
 435 }
 436
 437 /*
 438  * Walk over a graph. Follow all edges (including dependencies)
 439  */
 440 void irg_walk_in_or_dep_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env) {
 441   ir_graph * rem = current_ir_graph;
 442
 443   hook_irg_walk(irg, (generic_func *)pre, (generic_func *)post);
 444   current_ir_graph = irg;
 445   irg_walk_in_or_dep(get_irg_end(irg), pre, post, env);
 446   irg->estimated_node_count = nodes_touched;
 447   current_ir_graph = rem;
 448 }
 449
 450 /***************************************************************************/
 451
 452 /**
 453  * Returns current_ir_graph and sets it to the irg of predecessor index
 454  * of node n.
 455  */
 456 static INLINE ir_graph *
 457 switch_irg (ir_node *n, int index) {
 458   ir_graph *old_current = current_ir_graph;
 459
 460   if (get_interprocedural_view()) {
 461     /* Only Filter and Block nodes can have predecessors in other graphs. */
 462     if (get_irn_op(n) == op_Filter)
 463       n = get_nodes_block(n);
 464     if (get_irn_op(n) == op_Block) {
 465       ir_node *cfop = skip_Proj(get_Block_cfgpred(n, index));
 466       if (is_ip_cfop(cfop)) {
 467         current_ir_graph = get_irn_irg(cfop);
 468       }
 469     }
 470   }
 471
 472   return old_current;
 473 }
 474
 475 static void
 476 cg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env)
 477 {
 478   int i;
 479   ir_graph *rem = NULL;
 480   assert(node);
 481
 482   if (get_irn_visited(node) < get_irg_visited(current_ir_graph)) {
 483     set_irn_visited(node, get_irg_visited(current_ir_graph));
 484
 485     if (pre) pre(node, env);
 486
 487     if (is_no_Block(node))
 488       cg_walk_2(get_nodes_block(node), pre, post, env);
 489     for (i = get_irn_arity(node) - 1; i >= 0; --i) {
 490       rem = switch_irg(node, i);  /* @@@ AS: Is this wrong? We do have to
 491                                              switch to the irg of the predecessor, don't we? */
 492       cg_walk_2(get_irn_n(node, i), pre, post, env);
 493       current_ir_graph = rem;
 494     }
 495
 496     if (post) post(node, env);
 497   }
 498   return;
 499 }
 500
 501
 502 /* Walks all irgs in interprocedural view.  Visits each node only once. */
 503 void cg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) {
 504   int i;
 505   ir_graph *rem = current_ir_graph;
 506   int rem_view = get_interprocedural_view();
 507
 508   set_interprocedural_view(1);
 509
 510   inc_max_irg_visited();
 511   /* Fix all irg_visited flags */
 512   for (i = 0; i < get_irp_n_irgs(); i++)
 513     set_irg_visited(get_irp_irg(i), get_max_irg_visited());
 514
 515   /* Walk starting at unreachable procedures. Only these
 516    * have End blocks visible in interprocedural view. */
 517   for (i = 0; i < get_irp_n_irgs(); i++) {
 518     ir_node *sb;
 519     current_ir_graph = get_irp_irg(i);
 520
 521     sb = get_irg_start_block(current_ir_graph);
 522
 523     if ((get_Block_n_cfgpreds(sb) > 1) ||
 524     (get_nodes_block(get_Block_cfgpred(sb, 0)) != sb)) continue;
 525
 526     cg_walk_2(get_irg_end(current_ir_graph), pre, post, env);
 527   }
 528
 529   /* Check whether we walked all procedures: there could be procedures
 530      with cyclic calls but no call from the outside. */
 531   for (i = 0; i < get_irp_n_irgs(); i++) {
 532     ir_node *sb;
 533     current_ir_graph = get_irp_irg(i);
 534
 535     /* Test start block: if inner procedure end and end block are not
 536      * visible and therefore not marked. */
 537     sb = get_irg_start_block(current_ir_graph);
 538     if (get_irn_visited(sb) < get_irg_visited(current_ir_graph)) {
 539       cg_walk_2(sb, pre, post, env);
 540     }
 541   }
 542
 543   /* Walk all endless loops in inner procedures.
 544    * We recognize an inner procedure if the End node is not visited. */
 545   for (i = 0; i < get_irp_n_irgs(); i++) {
 546     ir_node *e;
 547     current_ir_graph = get_irp_irg(i);
 548     e = get_irg_end(current_ir_graph);
 549     if (get_irn_visited(e) < get_irg_visited(current_ir_graph)) {
 550       int j;
 551       /* Don't visit the End node. */
 552       for (j = 0; j < get_End_n_keepalives(e); j++)
 553     cg_walk_2(get_End_keepalive(e, j), pre, post, env);
 554     }
 555   }
 556
 557   set_interprocedural_view(rem_view);
 558   current_ir_graph = rem;
 559 }
 560
 561
 562 /***************************************************************************/
 563
 564 /* Walks back from n until it finds a real cf op. */
 565 static ir_node *get_cf_op(ir_node *n) {
 566   ir_node *pred;
 567
 568   n = skip_Id(n);
 569   n = skip_Tuple(n);
 570   pred = skip_Proj(n);
 571   if (!(is_cfop(pred) || is_fragile_op(pred) || is_Bad(pred)))
 572     n = get_cf_op(n);
 573
 574   return skip_Proj(n);
 575 }
 576
 577 static void irg_block_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 578 {
 579   int i;
 580
 581   if (Block_not_block_visited(node)) {
 582     mark_Block_block_visited(node);
 583
 584     if(pre) pre(node, env);
 585
 586     for(i = get_Block_n_cfgpreds(node) - 1; i >= 0; --i) {
 587       /* find the corresponding predecessor block. */
 588       ir_node *pred = get_cf_op(get_Block_cfgpred(node, i));
 589       pred = get_nodes_block(pred);
 590       if(get_irn_opcode(pred) == iro_Block) {
 591         /* recursion */
 592         irg_block_walk_2(pred, pre, post, env);
 593       }
 594       else {
 595         assert(get_irn_opcode(pred) == iro_Bad);
 596       }
 597     }
 598
 599     if(post) post(node, env);
 600   }
 601   return;
 602 }
 603
 604
 605 /* walks only over Block nodes in the graph.  Has it's own visited
 606    flag, so that it can be interleaved with the other walker.         */
 607 void irg_block_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 608 {
 609   ir_node *block, *pred;
 610   int i;
 611
 612   hook_irg_block_walk(current_ir_graph, node, (generic_func *)pre, (generic_func *)post);
 613
 614   assert(node);
 615   assert(!get_interprocedural_view());   /* interprocedural_view not implemented, because it
 616                     * interleaves with irg_walk */
 617   set_using_block_visited(current_ir_graph);
 618   inc_irg_block_visited(current_ir_graph);
 619   block = is_Block(node) ? node : get_nodes_block(node);
 620   assert(get_irn_op(block) == op_Block);
 621   irg_block_walk_2(block, pre, post, env);
 622
 623   /* keepalive: the endless loops ... */
 624   if (get_irn_op(node) == op_End) {
 625     int arity = get_irn_arity(node);
 626     for (i = 0; i < arity; i++) {
 627       pred = get_irn_n(node, i);
 628       if (get_irn_op(pred) == op_Block)
 629         irg_block_walk_2(pred, pre, post, env);
 630     }
 631     /* Sometimes the blocks died, but are still reachable through Phis.
 632      * Make sure the algorithms that try to remove these reach them. */
 633     for (i = 0; i < arity; i++) {
 634       pred = get_irn_n(node, i);
 635       if (get_irn_op(pred) == op_Phi) {
 636         ir_node *block = get_nodes_block(pred);
 637
 638         if (! is_Bad(block))
 639           irg_block_walk_2(block, pre, post, env);
 640       }
 641     }
 642   }
 643
 644   clear_using_block_visited(current_ir_graph);
 645 }
 646
 647 /*
 648  * walk over a graph block wise
 649  */
 650 void irg_block_walk_graph(ir_graph *irg, irg_walk_func *pre,
 651               irg_walk_func *post, void *env) {
 652   ir_graph * rem = current_ir_graph;
 653   current_ir_graph = irg;
 654   irg_block_walk(get_irg_end(irg), pre, post, env);
 655   current_ir_graph = rem;
 656 }
 657
 658 /*
 659  * Additionally walk over all anchors. Do NOT increase the visit flag.
 660  */
 661 void irg_walk_anchors(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env) {
 662   int i;
 663   ir_graph * rem = current_ir_graph;
 664   current_ir_graph = irg;
 665
 666   for (i = 0; i < anchor_max; ++i) {
 667     ir_node *anchor = irg->anchors[i];
 668
 669     irg_walk_2(anchor, pre, post, env);
 670   }
 671   current_ir_graph = rem;
 672 }
 673
 674 /********************************************************************/
 675
 676 typedef struct walk_env {
 677   irg_walk_func *pre;
 678   irg_walk_func *post;
 679   void *env;
 680 } walk_env;
 681
 682 /**
 683  * Walk to all constant expressions in this entity.
 684  */
 685 static void walk_entity(ir_entity *ent, void *env)
 686 {
 687   walk_env *my_env = (walk_env *)env;
 688
 689   if (get_entity_variability(ent) != variability_uninitialized) {
 690     if (is_atomic_entity(ent)) {
 691       irg_walk(get_atomic_ent_value(ent), my_env->pre, my_env->post, my_env->env);
 692     }
 693     else {
 694       int i, n_vals = get_compound_ent_n_values(ent);
 695
 696       for (i = 0; i < n_vals; i++)
 697         irg_walk(get_compound_ent_value(ent, i), my_env->pre, my_env->post, my_env->env);
 698     }
 699   }
 700 }
 701
 702 /* Walks over all code in const_code_irg. */
 703 void walk_const_code(irg_walk_func *pre, irg_walk_func *post, void *env) {
 704   int i, j;
 705   walk_env my_env;
 706
 707   ir_graph *rem = current_ir_graph;
 708   current_ir_graph = get_const_code_irg();
 709   inc_irg_visited(current_ir_graph);
 710
 711   my_env.pre = pre;
 712   my_env.post = post;
 713   my_env.env = env;
 714
 715   /* Walk all types that can contain constant entities.  */
 716   walk_types_entities(get_glob_type(), &walk_entity, &my_env);
 717   for (i = 0; i < get_irp_n_types(); i++)
 718     walk_types_entities(get_irp_type(i), &walk_entity, &my_env);
 719   for (i = 0; i < get_irp_n_irgs(); i++)
 720     walk_types_entities(get_irg_frame_type(get_irp_irg(i)), &walk_entity, &my_env);
 721
 722   /* Walk constant array bounds. */
 723   for (i = 0; i < get_irp_n_types(); i++) {
 724     ir_type *tp = get_irp_type(i);
 725     if (is_Array_type(tp)) {
 726       for (j = 0; j < get_array_n_dimensions(tp); j++) {
 727         ir_node *n = get_array_lower_bound(tp, j);
 728         if (n) irg_walk(n, pre, post, env);
 729         n = get_array_upper_bound(tp, j);
 730         if (n) irg_walk(n, pre, post, env);
 731       }
 732     }
 733   }
 734
 735   current_ir_graph = rem;
 736 }