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

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irgwalk.c
   4  * Purpose:
   5  * Author:      Boris Boesler
   6  * Modified by: Goetz Lindenmaier
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1999-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12
  13 /**
  14 * traverse an ir graph
  15 * - execute the pre function before recursion
  16 * - execute the post function after recursion
  17 */
  18
  19
  20 #ifdef HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 # include <stdlib.h>
  25
  26 # include "irnode_t.h"
  27 # include "irgraph_t.h" /* visited flag */
  28 # include "irprog.h"
  29 # include "irgwalk.h"
  30 # include "typewalk.h"
  31 # include "firmstat.h"
  32 # include "ircgcons.h"
  33
  34 # include "eset.h"
  35 # include "array.h"
  36
  37 /* walk over an interprocedural graph (callgraph). Visits only graphs in irg_set. */
  38 static void irg_walk_cg(ir_node * node, int visited, eset * irg_set,
  39                         irg_walk_func *pre, irg_walk_func *post, void * env) {
  40   int i;
  41   ir_graph * rem = current_ir_graph;
  42   ir_node * pred;
  43
  44   assert(node && node->kind == k_ir_node);
  45   if (get_irn_visited(node) >= visited) return;
  46
  47   set_irn_visited(node, visited);
  48
  49   if (pre) pre(node, env);
  50
  51   pred = skip_Proj(node);
  52   if (get_irn_op(pred) == op_CallBegin
  53       || get_irn_op(pred) == op_EndReg
  54       || get_irn_op(pred) == op_EndExcept) {
  55     current_ir_graph = get_irn_irg(pred);
  56   }
  57
  58   if (is_no_Block(node)) { /* not block */
  59     irg_walk_cg(get_nodes_block(node), visited, irg_set, pre, post, env);
  60   }
  61
  62   if (get_irn_op(node) == op_Block) { /* block */
  63     for (i = get_irn_arity(node) - 1; i >= 0; --i) {
  64       ir_node * exec = get_irn_n(node, i);
  65       ir_node * pred = skip_Proj(exec);
  66       if ((get_irn_op(pred) != op_CallBegin
  67            && get_irn_op(pred) != op_EndReg
  68            && get_irn_op(pred) != op_EndExcept)
  69           || eset_contains(irg_set, get_irn_irg(pred))) {
  70         irg_walk_cg(exec, visited, irg_set, pre, post, env);
  71       }
  72     }
  73   } else if (get_irn_op(node) == op_Filter) { /* filter */
  74     for (i = get_irn_arity(node) - 1; i >= 0; --i) {
  75       ir_node * pred = get_irn_n(node, i);
  76       if (get_irn_op(pred) == op_Unknown || get_irn_op(pred) == op_Bad) {
  77         irg_walk_cg(pred, visited, irg_set, pre, post, env);
  78       } else {
  79         ir_node * exec;
  80         exec = skip_Proj(get_Block_cfgpred(get_nodes_block(node), i));
  81
  82         if (op_Bad == get_irn_op (exec)) {
  83           continue;
  84         }
  85
  86         assert(get_irn_op(exec) == op_CallBegin
  87                || get_irn_op(exec) == op_EndReg
  88                || get_irn_op(exec) == op_EndExcept);
  89         if (eset_contains(irg_set, get_irn_irg(exec))) {
  90           current_ir_graph = get_irn_irg(exec);
  91           irg_walk_cg(pred, visited, irg_set, pre, post, env);
  92           current_ir_graph = rem;
  93         }
  94       }
  95     }
  96   } else {                      /* everything else */
  97     for (i = get_irn_arity(node) - 1; i >= 0; --i) {
  98       irg_walk_cg(get_irn_n(node, i), visited, irg_set, pre, post, env);
  99     }
 100   }
 101
 102   if (post) post(node, env);
 103
 104   current_ir_graph = rem;
 105 }
 106
 107
 108 /* Insert all ir_graphs in irg_set, that are (transitive) reachable. */
 109 static void collect_irgs(ir_node * node, eset * irg_set) {
 110   if (get_irn_op(node) == op_Call) {
 111     int i;
 112     for (i = get_Call_n_callees(node) - 1; i >= 0; --i) {
 113       entity * ent = get_Call_callee(node, i);
 114       ir_graph * irg = ent ? get_entity_irg(ent) : NULL;
 115       if (irg && !eset_contains(irg_set, irg)) {
 116     eset_insert(irg_set, irg);
 117     irg_walk_graph(irg, (irg_walk_func *) collect_irgs, NULL, irg_set);
 118       }
 119     }
 120   }
 121 }
 122
 123 static void
 124 irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env)
 125 {
 126   int i;
 127   assert(node && node->kind==k_ir_node);
 128 #if 0 /* safe */
 129   if (get_irn_visited(node) < get_irg_visited(current_ir_graph)) {
 130     set_irn_visited(node, get_irg_visited(current_ir_graph));
 131
 132     if (pre) pre(node, env);
 133
 134     if (is_no_Block(node))
 135       irg_walk_2(get_nodes_block(node), pre, post, env);
 136     for (i = get_irn_arity(node) - 1; i >= 0; --i)
 137       irg_walk_2(get_irn_n(node, i), pre, post, env);
 138
 139     if (post) post(node, env);
 140   }
 141 #else /* faster */
 142   if (node->visited < current_ir_graph->visited) {
 143     set_irn_visited(node, current_ir_graph->visited);
 144
 145     if (pre) pre(node, env);
 146
 147     if (node->op != op_Block)
 148       irg_walk_2(get_irn_n(node, -1), pre, post, env);
 149     for (i = get_irn_arity(node) - 1; i >= 0; --i)
 150       irg_walk_2(get_irn_n(node, i), pre, post, env);
 151
 152     if (post) post(node, env);
 153   }
 154 #endif
 155 }
 156
 157
 158 void irg_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 159 {
 160   assert(node  && node->kind==k_ir_node);
 161
 162   if (interprocedural_view) {
 163     eset * irg_set = eset_create();
 164     int visited;
 165     ir_graph * irg;
 166     assert(get_irp_ip_view_state() == ip_view_valid);
 167
 168     interprocedural_view = false;
 169     eset_insert(irg_set, current_ir_graph);
 170     irg_walk(node, (irg_walk_func *) collect_irgs, NULL, irg_set);
 171     interprocedural_view = true;
 172     visited = get_max_irg_visited() + 1;
 173     for (irg = eset_first(irg_set); irg; irg = eset_next(irg_set)) {
 174       set_irg_visited(irg, visited);
 175     }
 176     irg_walk_cg(node, visited, irg_set, pre, post, env);
 177     eset_destroy(irg_set);
 178   } else {
 179     inc_irg_visited(current_ir_graph);
 180     irg_walk_2(node, pre, post, env);
 181   }
 182   return;
 183 }
 184
 185
 186 void irg_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env) {
 187   ir_graph * rem = current_ir_graph;
 188
 189   stat_irg_walk(irg, (void *)pre, (void *)post);
 190   current_ir_graph = irg;
 191   irg_walk(get_irg_end(irg), pre, post, env);
 192   current_ir_graph = rem;
 193 }
 194
 195 /* Executes irg_walk(end, pre, post, env) for all irgraphs in irprog.
 196    Sets current_ir_graph properly for each walk.  Conserves current
 197    current_ir_graph. */
 198 void all_irg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) {
 199   int i;
 200   ir_graph *irg, *rem;
 201
 202   rem = current_ir_graph;
 203
 204   for (i = 0; i < get_irp_n_irgs(); i++) {
 205     irg = get_irp_irg(i);
 206     current_ir_graph = irg;
 207     irg_walk(get_irg_end(irg), pre, post, env);
 208   }
 209   current_ir_graph = rem;
 210 }
 211
 212 /***************************************************************************/
 213
 214 /* Returns current_ir_graph and sets it to the irg of predecessor index
 215    of node n. */
 216 static INLINE ir_graph *
 217 switch_irg (ir_node *n, int index) {
 218   ir_graph *old_current = current_ir_graph;
 219
 220   if (interprocedural_view) {
 221     /* Only Filter and Block nodes can have predecessors in other graphs. */
 222     if (get_irn_op(n) == op_Filter)
 223       n = get_nodes_block(n);
 224     if (get_irn_op(n) == op_Block) {
 225       ir_node *cfop = skip_Proj(get_Block_cfgpred(n, index));
 226       if (is_ip_cfop(cfop)) {
 227     current_ir_graph = get_irn_irg(cfop);
 228       }
 229     }
 230   }
 231
 232   return old_current;
 233 }
 234
 235 static void
 236 cg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env)
 237 {
 238   int i;
 239   ir_graph *rem = NULL;
 240   assert(node);
 241
 242   if (get_irn_visited(node) < get_irg_visited(current_ir_graph)) {
 243     set_irn_visited(node, get_irg_visited(current_ir_graph));
 244
 245     if (pre) pre(node, env);
 246
 247     if (is_no_Block(node))
 248       cg_walk_2(get_nodes_block(node), pre, post, env);
 249     for (i = get_irn_arity(node) - 1; i >= 0; --i) {
 250       rem = switch_irg(node, i);  /* @@@ AS: Is this wrong? We do have to
 251                                              switch to the irg of the predecessor, don't we? */
 252       cg_walk_2(get_irn_n(node, i), pre, post, env);
 253       current_ir_graph = rem;
 254     }
 255
 256     if (post) post(node, env);
 257   }
 258   return;
 259 }
 260
 261
 262 /* Walks all irgs in interprocedural view.  Visits each node only once. */
 263 void cg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) {
 264   int i;
 265   ir_graph *rem = current_ir_graph;
 266   int rem_view = interprocedural_view;
 267
 268   interprocedural_view = true;
 269
 270   inc_max_irg_visited();
 271   /* Fix all irg_visited flags */
 272   for (i = 0; i < get_irp_n_irgs(); i++)
 273     set_irg_visited(get_irp_irg(i), get_max_irg_visited());
 274
 275   /* Walk starting at unreachable procedures. Only these
 276    * have End blocks visible in interprocedural view. */
 277   for (i = 0; i < get_irp_n_irgs(); i++) {
 278     ir_node *sb;
 279     current_ir_graph = get_irp_irg(i);
 280
 281     sb = get_irg_start_block(current_ir_graph);
 282
 283     if ((get_Block_n_cfgpreds(sb) > 1) ||
 284     (get_nodes_block(get_Block_cfgpred(sb, 0)) != sb)) continue;
 285
 286     cg_walk_2(get_irg_end(current_ir_graph), pre, post, env);
 287   }
 288
 289   /* Check whether we walked all procedures: there could be procedures
 290      with cyclic calls but no call from the outside. */
 291   for (i = 0; i < get_irp_n_irgs(); i++) {
 292     ir_node *sb;
 293     current_ir_graph = get_irp_irg(i);
 294
 295     /* Test start block: if inner procedure end and end block are not
 296      * visible and therefore not marked. */
 297     sb = get_irg_start_block(current_ir_graph);
 298     if (get_irn_visited(sb) < get_irg_visited(current_ir_graph)) {
 299       cg_walk_2(sb, pre, post, env);
 300     }
 301   }
 302
 303   /* Walk all endless loops in inner procedures.
 304    * We recognize an inner procedure if the End node is not visited. */
 305   for (i = 0; i < get_irp_n_irgs(); i++) {
 306     ir_node *e;
 307     current_ir_graph = get_irp_irg(i);
 308     e = get_irg_end(current_ir_graph);
 309     if (get_irn_visited(e) < get_irg_visited(current_ir_graph)) {
 310       int j;
 311       /* Don't visit the End node. */
 312       for (j = 0; j < get_End_n_keepalives(e); j++)
 313     cg_walk_2(get_End_keepalive(e, j), pre, post, env);
 314     }
 315   }
 316
 317   interprocedural_view = rem_view;
 318   current_ir_graph = rem;
 319 }
 320
 321
 322 /***************************************************************************/
 323
 324 /* Walks back from n until it finds a real cf op. */
 325 static ir_node *get_cf_op(ir_node *n) {
 326   ir_node *pred;
 327
 328   n = skip_nop(n);
 329   n = skip_Tuple(n);
 330   pred = skip_Proj(n);
 331   if (!(is_cfop(pred) || is_fragile_op(pred) ||
 332     (get_irn_op(pred) == op_Bad)))
 333     n = get_cf_op(n);
 334
 335   return skip_Proj(n);
 336 }
 337
 338 static void irg_block_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 339 {
 340   int i;
 341
 342   if(get_Block_block_visited(node) < get_irg_block_visited(current_ir_graph)) {
 343     set_Block_block_visited(node, get_irg_block_visited(current_ir_graph));
 344
 345     if(pre) pre(node, env);
 346
 347     for(i = get_Block_n_cfgpreds(node) - 1; i >= 0; --i) {
 348       /* find the corresponding predecessor block. */
 349       ir_node *pred = get_cf_op(get_Block_cfgpred(node, i));
 350       pred = get_nodes_block(pred);
 351       if(get_irn_opcode(pred) == iro_Block) {
 352     /* recursion */
 353     irg_block_walk_2(pred, pre, post, env);
 354       }
 355       else {
 356     assert(get_irn_opcode(pred) == iro_Bad);
 357       }
 358     }
 359
 360     if(post) post(node, env);
 361   }
 362   return;
 363 }
 364
 365
 366 /* walks only over Block nodes in the graph.  Has it's own visited
 367    flag, so that it can be interleaved with the other walker.         */
 368 void irg_block_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 369 {
 370   ir_node *block, *pred;
 371   int i;
 372
 373   stat_irg_block_walk(current_ir_graph, node, (void *)pre, (void *)post);
 374
 375   assert(node);
 376   assert(!interprocedural_view);   /* interprocedural_view not implemented, because it
 377                     * interleaves with irg_walk */
 378   inc_irg_block_visited(current_ir_graph);
 379   if (is_no_Block(node)) block = get_nodes_block(node); else block = node;
 380   assert(get_irn_opcode(block)  == iro_Block);
 381   irg_block_walk_2(block, pre, post, env);
 382   /* keepalive: the endless loops ... */
 383   if (get_irn_op(node) == op_End) {
 384     int arity = get_irn_arity(node);
 385     for (i = 0; i < arity; i++) {
 386       pred = get_irn_n(node, i);
 387       if (get_irn_op(pred) == op_Block)
 388     irg_block_walk_2(pred, pre, post, env);
 389     }
 390   }
 391
 392   return;
 393 }
 394
 395
 396 void irg_block_walk_graph(ir_graph *irg, irg_walk_func *pre,
 397               irg_walk_func *post, void *env) {
 398   ir_graph * rem = current_ir_graph;
 399   current_ir_graph = irg;
 400   irg_block_walk(get_irg_end(irg), pre, post, env);
 401   current_ir_graph = rem;
 402 }
 403
 404 /********************************************************************/
 405
 406 typedef struct walk_env {
 407   irg_walk_func *pre;
 408   irg_walk_func *post;
 409   void *env;
 410 } walk_env;
 411
 412 /* Walk to all constant expressions in this entity. */
 413 static void walk_entity(entity *ent, void *env)
 414 {
 415   walk_env *my_env = (walk_env *)env;
 416
 417   if (get_entity_variability(ent) != variability_uninitialized) {
 418     if (is_atomic_entity(ent)) {
 419       irg_walk(get_atomic_ent_value(ent), my_env->pre, my_env->post, my_env->env);
 420     }
 421     else {
 422       int i, n = get_compound_ent_n_values(ent);
 423
 424       for (i = 0; i < n; i++)
 425     irg_walk(get_compound_ent_value(ent, i), my_env->pre, my_env->post, my_env->env);
 426     }
 427   }
 428 }
 429
 430 /* Walks over all code in const_code_irg. */
 431 void walk_const_code(irg_walk_func *pre, irg_walk_func *post, void *env) {
 432   int i, j;
 433   walk_env my_env;
 434
 435   ir_graph *rem = current_ir_graph;
 436   current_ir_graph = get_const_code_irg();
 437   inc_irg_visited(current_ir_graph);
 438
 439   my_env.pre = pre;
 440   my_env.post = post;
 441   my_env.env = env;
 442
 443   /* Walk all types that can contain constant entities.  */
 444   walk_types_entities(get_glob_type(), &walk_entity, &my_env);
 445   for (i = 0; i < get_irp_n_types(); i++)
 446     walk_types_entities(get_irp_type(i), &walk_entity, &my_env);
 447   for (i = 0; i < get_irp_n_irgs(); i++)
 448     walk_types_entities(get_irg_frame_type(get_irp_irg(i)), &walk_entity, &my_env);
 449
 450   /* Walk constant array bounds. */
 451   for (i = 0; i < get_irp_n_types(); i++) {
 452     type *tp = get_irp_type(i);
 453     if (is_array_type(tp)) {
 454       for (j = 0; j < get_array_n_dimensions(tp); j++) {
 455     ir_node *n;
 456     n = get_array_lower_bound(tp, j);
 457     if (n) irg_walk(n, pre, post, env);
 458     n = get_array_upper_bound(tp, j);
 459     if (n) irg_walk(n, pre, post, env);
 460       }
 461     }
 462   }
 463
 464   current_ir_graph = rem;
 465 }
 466
 467
 468 /********************************************************************/
 469 /** Walking support for interprocedural analysis                   **/
 470 /**                                                                **/
 471 /** @@@ Don't use, not operational yet, doesn't grok recursions!!  **/
 472 /** @@@ Header for irgwalk.h, here until it works. **/
 473 /**                                                                **/
 474 /** Interprocedural walking should not walk all predecessors of    **/
 475 /** all nodes.  When leaving a procedure the walker should only    **/
 476 /** follow the edge corresponding to the most recent entry of the  **/
 477 /** procedure.  The following functions use an internal stack to   **/
 478 /** remember the current call site of a procedure.                 **/
 479 /** They also set current_ir_graph correctly.                      **/
 480 /**                                                                **/
 481 /** Usage example:                                                 **/
 482 /**                                                                **/
 483 /** void init_ip_walk ();                                          **/
 484 /** work_on_graph(some_end_node);                                  **/
 485 /** void finish_ip_walk();                                         **/
 486 /**                                                                **/
 487 /** work_on_graph(ir_node *n) {                                    **/
 488 /**   for (i = 0; i < get_irn_arity(n); i++) {                     **/
 489 /**     if (...) continue;                                         **/
 490 /**     ir_node *m = get_irn_ip_pred(n, i);                        **/
 491 /**     if !m continue;                                            **/
 492 /**     work_on_graph(m);                                          **/
 493 /**     return_recur(n, i);                                        **/
 494 /**   }                                                            **/
 495 /** }                                                              **/
 496 /********************************************************************/
 497
 498 /* Call for i in {0|-1 ... get_irn_arity(n)}.
 499    If n is a conventional node returns the same node as get_irn_n(n, i).
 500    If the predecessors of n are in the callee of the procedure n belongs
 501    to, returns get_irn_n(n, i) if this node is in the callee on the top
 502    of the stack, else returns NULL.
 503    If the predecessors of n are in a procedure called by the procedure n
 504    belongs to pushes the caller on the caller stack in the callee.
 505    Sets current_ir_graph to the graph the node returned is in. */
 506 ir_node *get_irn_ip_pred(ir_node *n, int pos);
 507
 508 /* If get_irn_ip_pred() returned a node (not NULL) this must be
 509    called to clear up the stacks.
 510    Sets current_ir_graph to the graph n is in. */
 511 void return_recur(ir_node *n, int pos);
 512
 513
 514 /********************************************************************/
 515 /** Walking support for interprocedural analysis                   **/
 516 /********************************************************************/
 517
 518 #define MIN_STACK_SIZE 40
 519
 520 typedef struct callsite_stack {
 521   int tos;
 522   ir_node **s;
 523 } callsite_stack;
 524
 525 /* Access the stack in the irg **************************************/
 526
 527 static INLINE void
 528 set_irg_callsite_stack(ir_graph *g, callsite_stack *s) {
 529   set_irg_link(g, s);
 530 }
 531
 532 static INLINE callsite_stack *
 533 get_irg_callsite_stack(ir_graph *g) {
 534   return (callsite_stack *) get_irg_link(g);
 535 }
 536
 537 /* A stack of callsites *********************************************/
 538
 539 /* @@@ eventually change the implementation so the new_ only sets the field
 540    to NULL, and the stack is only allocated if used.  Saves Memory! */
 541 static INLINE callsite_stack *
 542 new_callsite_stack(ir_graph *g) {
 543   callsite_stack *res = (callsite_stack *)malloc(sizeof(callsite_stack));
 544   res->tos = 0;
 545   res->s = NEW_ARR_F (ir_node *, MIN_STACK_SIZE);
 546   set_irg_callsite_stack(g, res);
 547   return(res);
 548 }
 549
 550 static INLINE void
 551 free_callsite_stack(ir_graph *g) {
 552   callsite_stack *s = get_irg_callsite_stack(g);
 553   DEL_ARR_F(s->s);
 554   free(s);
 555 }
 556
 557 static INLINE void
 558 push_callsite(ir_graph *callee, ir_node *callsite) {
 559   callsite_stack *s = get_irg_callsite_stack(callee);
 560   if (s->tos == ARR_LEN(s->s)) {
 561     int nlen = ARR_LEN (s->s) * 2;
 562     ARR_RESIZE (ir_node *, s->s, nlen);
 563   }
 564   s->s[s->tos] = callsite;
 565   s->tos++;
 566 }
 567
 568 static INLINE ir_node *
 569 get_top_of_callsite_stack(ir_graph *callee) {
 570   callsite_stack *s = get_irg_callsite_stack(callee);
 571   return (s->s[s->tos-1]);
 572 }
 573
 574 static INLINE
 575 ir_node * pop_callsite(ir_graph *callee) {
 576   callsite_stack *s = get_irg_callsite_stack(callee);
 577   s->tos--;
 578   return (s->s[s->tos]);
 579 }
 580
 581
 582 /* Initialization routines ******************************************/
 583
 584 void init_ip_walk (void) {
 585   int i;
 586   for (i = 0; i < get_irp_n_irgs(); i++)
 587     new_callsite_stack(get_irp_irg(i));
 588 }
 589
 590 void finish_ip_walk(void) {
 591   int i;
 592   for (i = 0; i < get_irp_n_irgs(); i++)
 593     free_callsite_stack(get_irp_irg(i));
 594   set_irg_link(get_irp_irg(i), NULL);
 595 }
 596
 597 /* walker routines **************************************************/
 598
 599 /* cf_pred is End* */
 600 static INLINE void
 601 enter_procedure(ir_node *block, ir_node *cf_pred, int pos) {
 602   ir_node *callbegin;
 603   ir_graph *irg = get_irn_irg(cf_pred);
 604
 605   assert(interprocedural_view);
 606
 607   interprocedural_view = 0;
 608   callbegin = skip_Proj(get_irn_n(block, 0));
 609   assert(get_irn_op(callbegin) == op_CallBegin);
 610   interprocedural_view = 1;
 611
 612   push_callsite(irg, callbegin);
 613   current_ir_graph = irg;
 614 }
 615
 616 /* cf_pred is CallBegin */
 617 static INLINE bool
 618 leave_procedure(ir_node *block, ir_node *cf_pred, int pos) {
 619   ir_node *tos = get_top_of_callsite_stack(current_ir_graph);
 620
 621   assert(get_irn_op(cf_pred) == op_CallBegin);
 622
 623   if (tos == cf_pred) {
 624     /* We entered this procedure by the call pred pos refers to. */
 625     pop_callsite(current_ir_graph);
 626     current_ir_graph = get_CallBegin_irg(cf_pred);
 627     return true;
 628   } else {
 629     /* We won't walk. */
 630     return false;
 631   }
 632 }
 633
 634 ir_node *get_irn_ip_pred(ir_node *n, int pos) {
 635
 636   if (interprocedural_view) {
 637
 638     /* Find the cf_pred refering to pos. */
 639     ir_node *block = n;
 640     ir_node *cf_pred;
 641     if (get_irn_opcode(n) == iro_Filter) block = get_nodes_block(n);
 642     cf_pred = skip_Proj(get_irn_n(block, pos));
 643
 644     /* Check whether we enter or leave a procedure and act according. */
 645     if ((get_irn_op(cf_pred) == op_EndReg) ||
 646     (get_irn_op(cf_pred) == op_EndExcept))
 647       enter_procedure(block, cf_pred, pos);
 648     if (get_irn_op(cf_pred) == op_CallBegin)
 649       if (!leave_procedure(block, cf_pred, pos)) return NULL;
 650   }
 651
 652   return get_irn_n(n, pos);
 653 }
 654
 655 static INLINE void
 656 re_enter_procedure(ir_node *block, ir_node *cf_pred, int pos) {
 657   ir_node *callbegin = pop_callsite(current_ir_graph);
 658   assert(interprocedural_view);
 659   current_ir_graph = get_CallBegin_irg(callbegin);
 660 }
 661
 662 static INLINE void
 663 re_leave_procedure(ir_node *block, ir_node *cf_pred, int pos) {
 664   ir_node *proj;
 665   ir_graph *callee;
 666
 667   assert(get_irn_op(cf_pred) == op_CallBegin);
 668
 669   /* Find the irg block is in. */
 670   proj = get_Block_cg_cfgpred(block, pos);
 671   assert(is_Proj(proj));
 672   callee = get_entity_irg(get_Call_callee(get_CallBegin_call(cf_pred),
 673                       get_Proj_proj(proj)));
 674   current_ir_graph = callee;
 675   push_callsite(callee, cf_pred);
 676 }
 677
 678 void
 679 return_recur(ir_node *n, int pos) {
 680   ir_node *block;
 681   ir_node *cf_pred;
 682
 683   if (!interprocedural_view) return;
 684
 685   /* Find the cf_pred refering to pos. */
 686   block = n;
 687   if (get_irn_opcode(n) == iro_Filter) block = get_nodes_block(n);
 688   cf_pred = skip_Proj(get_irn_n(block, pos));
 689
 690   /* Check whether we re_enter or re_leave a procedure and act according. */
 691   if ((get_irn_op(cf_pred) == op_EndReg) ||
 692       (get_irn_op(cf_pred) == op_EndExcept))
 693     re_enter_procedure(block, cf_pred, pos);
 694   if (get_irn_op(cf_pred) == op_CallBegin)
 695     re_leave_procedure(block, cf_pred, pos);
 696 }