-/**********************************************************************/
-
-
-/* Returns the amount of out edges for not yet visited successors. */
-static int count_outs(ir_node *n) {
- int start, i, res, irn_arity;
- ir_node *succ;
-
- set_irn_visited(n, get_irg_visited(current_ir_graph));
- n->out = (ir_node **) 1; /* Space for array size. */
-
- if ((get_irn_op(n) == op_Block)) start = 0; else start = -1;
- irn_arity = get_irn_arity(n);
- res = irn_arity - start +1; /* --1 or --0; 1 for array size. */
- for (i = start; i < irn_arity; i++) {
- /* Optimize Tuples. They annoy if walking the cfg. */
- succ = skip_Tuple(get_irn_n(n, i));
- set_irn_n(n, i, succ);
- /* count outs for successors */
- if (get_irn_visited(succ) < get_irg_visited(current_ir_graph))
- res += count_outs(succ);
- /* Count my outs */
- succ->out = (ir_node **)( (int)succ->out +1);
- }
- return res;
-}
-
-static ir_node **set_out_edges(ir_node *n, ir_node **free) {
- int n_outs, start, i, irn_arity;
- ir_node *succ;
-
- set_irn_visited(n, get_irg_visited(current_ir_graph));
-
- /* Allocate my array */
- n_outs = (int) n->out;
- n->out = free;
- free = &free[n_outs];
- /* We count the successors again, the space will be sufficient.
- We use this counter to remember the position for the next back
- edge. */
- n->out[0] = (ir_node *)0;
-
- if (get_irn_op(n) == op_Block) start = 0; else start = -1;
- irn_arity = get_irn_arity(n);
- for (i = start; i < irn_arity; i++) {
- succ = get_irn_n(n, i);
- /* Recursion */
- if (get_irn_visited(succ) < get_irg_visited(current_ir_graph))
- free = set_out_edges(succ, free);
- /* Remember our back edge */
- succ->out[get_irn_n_outs(succ)+1] = n;
- succ->out[0] = (ir_node *) (get_irn_n_outs(succ) + 1);
- }
- return free;
-}
-
-static INLINE void fix_start_proj(ir_graph *irg) {
- ir_node *proj = NULL, *startbl;
- int i;
- if (get_Block_n_cfg_outs(get_irg_start_block(irg))) {
- startbl = get_irg_start_block(irg);
- for (i = 0; i < get_irn_n_outs(startbl); i++)
- if (get_irn_mode(get_irn_out(startbl, i)) == mode_X)
- proj = get_irn_out(startbl, i);
- if (get_irn_out(proj, 0) == startbl) {
- assert(get_irn_n_outs(proj) == 2);
- set_irn_out(proj, 0, get_irn_out(proj, 1));
- set_irn_out(proj, 1, startbl);
- }
- }
-}
-
-void compute_outs(ir_graph *irg) {
- ir_graph *rem = current_ir_graph;
- int n_out_edges = 0;
-
- current_ir_graph = irg;
-
- /* Update graph state */
- assert(get_irg_phase_state(current_ir_graph) != phase_building);
- current_ir_graph->outs_state = outs_consistent;
-
- /* This first iteration counts the overall number of out edges and the
- number of out edges for each node. */
- inc_irg_visited(irg);
- n_out_edges = count_outs(get_irg_end(irg));
-
- /* allocate memory for all out edges. */
- irg->outs = (ir_node **) malloc (n_out_edges * sizeof(ir_node *));
-
- /* The second iteration splits the irg->outs array into smaller arrays
- for each node and writes the back edges into this array. */
- inc_irg_visited(irg);
- set_out_edges(get_irg_end(irg), irg->outs);
-
- /* We want that the out of ProjX from Start contains the next block at
- position 1, the Start block at position 2. This is necessary for
- the out block walker. */
- fix_start_proj(irg);
-
- current_ir_graph = rem;
-}
-
-
-
-
-/****************************************************************
- ** This computes the outedges for in interprocedural graph. **
- ** There is one quirk: **
- ** The number of the outedges for each node is saved in **
- ** the first member of the ir_node** array. Maybe we should **
- ** change this to make it more portable... **
- ****************************************************************/
-
-
-/* ------------------------------------------
- Inits the number of outedges for each node
- before counting.
- ------------------------------------------ */
-
-static void init_count(ir_node * node, void * env)
-{
- node->out = (ir_node **) 1; /* 1 for the array size */
+/*--------------------------------------------------------------------*/
+
+
+/** Returns the amount of out edges for not yet visited successors. */
+static int _count_outs(ir_node *n) {
+ int start, i, res, irn_arity;
+
+ mark_irn_visited(n);
+ n->out = INT_TO_PTR(1); /* Space for array size. */
+
+ start = is_Block(n) ? 0 : -1;
+ irn_arity = get_irn_arity(n);
+ res = irn_arity - start + 1; /* --1 or --0; 1 for array size. */
+
+ for (i = start; i < irn_arity; ++i) {
+ /* Optimize Tuples. They annoy if walking the cfg. */
+ ir_node *pred = get_irn_n(n, i);
+ ir_node *skipped_pred = skip_Tuple(pred);
+
+ if (skipped_pred != pred) {
+ set_irn_n(n, i, skipped_pred);
+ }
+
+ /* count Def-Use edges for predecessors */
+ if (!irn_visited(skipped_pred))
+ res += _count_outs(skipped_pred);
+
+ /*count my Def-Use edges */
+ skipped_pred->out = INT_TO_PTR(PTR_TO_INT(skipped_pred->out) + 1);
+ }
+ return res;