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