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