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