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

   1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
   2 ** All rights reserved.
   3 **
   4 ** Author: Boris Boesler
   5 **
   6 ** traverse an ir graph
   7 ** - execute the pre function before recursion
   8 ** - execute the post function after recursion
   9 */
  10
  11 /* $Id$ */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include <config.h>
  15 #endif
  16
  17 # include "irnode.h"
  18 # include "irgraph.h" /* visited flag */
  19
  20
  21 void irg_walk_2(ir_node *node,
  22               void (pre)(ir_node*, void*), void (post)(ir_node*, void*),
  23               void *env)
  24 {
  25   int i;
  26
  27
  28   assert(node);
  29   /*      printf(" - "); DDMSG2(node);  */
  30
  31   if (get_irn_visited(node) < get_irg_visited(current_ir_graph)) {
  32
  33 /*      printf(" -> "); DDMSG2(node);  */
  34     set_irn_visited(node, get_irg_visited(current_ir_graph));
  35
  36     if (pre) {
  37       pre(node, env);
  38     }
  39
  40     if (is_no_Block(node)) {
  41       irg_walk_2(get_nodes_Block(node), pre, post, env);
  42     }
  43     for (i = get_irn_arity(node) - 1; i >= 0; --i) {
  44 /*        printf("   "); DDMSG2(node); */
  45 /*        printf("   "); DDMSG2(get_irn_n(node, i)); */
  46
  47       irg_walk_2(get_irn_n(node, i), pre, post, env);
  48     }
  49
  50 /*      printf(" <- "); DDMSG2(node);  */
  51     if (post)
  52       post(node, env);
  53   }
  54   return;
  55 }
  56
  57
  58 void irg_walk(ir_node *node,
  59               void (pre)(ir_node*, void*), void (post)(ir_node*, void*),
  60               void *env)
  61 {
  62   assert(node);
  63   inc_irg_visited (current_ir_graph);
  64   irg_walk_2(node, pre, post, env);
  65   return;
  66 }
  67
  68 /***************************************************************************/
  69
  70 /* Walks back from n until it finds a real cf op. */
  71 ir_node *get_cf_op(ir_node *n) {
  72   ir_node *pred;
  73
  74   n = skip_nop(n);
  75   n = skip_Tuple(n);
  76   pred = skip_Proj(n);
  77   if (!(is_cfop(pred) || is_fragile_op(pred) ||
  78         (get_irn_op(pred) == op_Bad)))
  79     n = get_cf_op(n);
  80
  81   return skip_Proj(n);
  82 }
  83
  84 void irg_block_walk_2(ir_node *node, void (pre)(ir_node*, void*),
  85                       void (post)(ir_node*, void*), void *env)
  86 {
  87   int i;
  88
  89   assert(get_irn_opcode(node) == iro_Block);
  90
  91   if(get_Block_block_visited(node) < get_irg_block_visited(current_ir_graph)) {
  92     set_Block_block_visited(node, get_irg_block_visited(current_ir_graph));
  93
  94     if(pre)
  95       pre(node, env);
  96
  97     for(i = get_Block_n_cfgpreds(node) - 1; i >= 0; --i) {
  98
  99       /* find the corresponding predecessor block. */
 100       ir_node *pred = get_cf_op(get_Block_cfgpred(node, i));
 101       /* GL: I'm not sure whether this assert must go through.  There
 102          could be Id chains?? Tuple/Proj .... */
 103
 104       assert(is_cfop(pred) || is_fragile_op(pred) ||
 105              (get_irn_op(pred) == op_Bad));
 106       pred = get_nodes_Block(pred);
 107       if(get_irn_opcode(pred) == iro_Block) {
 108         /* recursion */
 109         irg_block_walk_2(pred, pre, post, env);
 110       }
 111       else {
 112         assert(get_irn_opcode(pred) == iro_Bad);
 113       }
 114     }
 115
 116     if(post)
 117       post(node, env);
 118   }
 119   return;
 120 }
 121
 122
 123 /* walks only over Block nodes in the graph.  Has it's own visited
 124    flag, so that it can be interleaved with the other walker.         */
 125 void irg_block_walk(ir_node *node,
 126                     void (pre)(ir_node*, void*), void (post)(ir_node*, void*),
 127                     void *env)
 128 {
 129   assert(node);
 130   inc_irg_block_visited(current_ir_graph);
 131   if (is_no_Block(node)) node = get_nodes_Block(node);
 132   assert(get_irn_opcode(node)  == iro_Block);
 133   irg_block_walk_2(node, pre, post, env);
 134   return;
 135 }