-/* Copyright (C) 2002 by Universitaet Karlsruhe
-* All rights reserved.
-*
-* Authors: Goetz Lindenmaier
-*
-* irscc.c Computing the strongly connected regions and building
-* backedge/loop datastructures.
-*
-*/
-
-/* $Id$ */
+/*
+ * Project: libFIRM
+ * File name: ir/ana/irscc.c
+ * Purpose: Compute the strongly connected regions and build
+ * backedge/loop datastructures.
+ * Author: Goetz Lindenmaier
+ * Modified by:
+ * Created: 7.2002
+ * CVS-ID: $Id$
+ * Copyright: (c) 2002-2003 Universität Karlsruhe
+ * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
+ */
#include <string.h>
#include "irnode.h"
#include "irgraph_t.h"
#include "array.h"
-#include "xprintf.h"
#include "irgwalk.h"
#include "irprog.h"
static INLINE void
push (ir_node *n)
{
- //DDMN(n);
+ /*DDMN(n);*/
if (tos == ARR_LEN (stack)) {
int nlen = ARR_LEN (stack) * 2;
int child_nr = 0, loop_nr = -1;
assert(loop && loop->kind == k_ir_loop);
- while(child_nr < ARR_LEN(loop->children));
+ while(child_nr < ARR_LEN(loop->children))
{
if(*(loop -> children[child_nr].kind) == k_ir_loop)
loop_nr++;
static INLINE void
add_loop_son(ir_loop *loop, ir_loop *son) {
+ loop_element lson;
+ lson.son = son;
assert(loop && loop->kind == k_ir_loop);
- ARR_APP1 (loop_element, loop->children, (loop_element) son);
+ assert(get_kind(son) == k_ir_loop);
+ ARR_APP1 (loop_element, loop->children, lson);
loop -> n_sons++;
}
* TODO: This method isn`t very efficient ! *
* Returns NULL if there isnt`t a pos`th ir_node */
ir_node *get_loop_node (ir_loop *loop, int pos) {
- int child_nr = 0, node_nr = -1;
+ int child_nr, node_nr = -1;
assert(loop && loop->kind == k_ir_loop);
- while(child_nr < ARR_LEN(loop->children));
- {
+ assert(pos < get_loop_n_nodes(loop));
+
+ for (child_nr = 0; child_nr < ARR_LEN(loop->children); child_nr++) {
if(*(loop -> children[child_nr].kind) == k_ir_node)
node_nr++;
if(node_nr == pos)
return(loop -> children[child_nr].node);
- child_nr++;
- }
+ }
+ assert(0 && "no child at pos found");
return NULL;
}
static INLINE void
add_loop_node(ir_loop *loop, ir_node *n) {
+ loop_element ln;
+ ln.node=n;
assert(loop && loop->kind == k_ir_loop);
- ARR_APP1 (loop_element, loop->children, (loop_element) n);
+ assert(get_kind(n) == k_ir_node);
+ ARR_APP1 (loop_element, loop->children, ln);
loop->n_nodes++;
}
-/* The outermost loop is remarked in the surrounding graph. */
-void set_irg_loop(ir_graph *irg, ir_loop *loop) {
- assert(irg);
- irg->loop = loop;
-}
-ir_loop *get_irg_loop(ir_graph *irg) {
- assert(irg);
- return irg->loop;
-}
-
/** Returns the number of elements contained in loop. */
-int get_loop_n_elements (ir_loop *loop)
- {
+int get_loop_n_elements (ir_loop *loop) {
assert(loop && loop->kind == k_ir_loop);
return(ARR_LEN(loop->children));
- }
+}
/*
Returns the pos`th loop element.
This may be a loop_node or a ir_node. The caller of this function has
to check the *(loop_element.kind) field for "k_ir_node" or "k_ir_loop"
- and then select the apropriate "loop_element.ir_node" or "loop_element.ir_son".
+ and then select the apropriate "loop_element.node" or "loop_element.son".
*/
-loop_element get_loop_element (ir_loop *loop, int pos)
- {
+loop_element get_loop_element (ir_loop *loop, int pos) {
assert(loop && loop->kind == k_ir_loop && pos < ARR_LEN(loop->children));
return(loop -> children[pos]);
- }
+}
+
+/* The outermost loop is remarked in the surrounding graph. */
+void set_irg_loop(ir_graph *irg, ir_loop *loop) {
+ assert(irg);
+ irg->loop = loop;
+}
+ir_loop *get_irg_loop(ir_graph *irg) {
+ assert(irg);
+ return irg->loop;
+}
/**********************************************************************/
/* Constructing and destructing the loop/backedge information. **/
}
if (i < 0) i = tos;
- //printf(" Here\n");
-
assert (i >= 0);
for (; i >= 0; i--) {
m = stack[i];
- //printf(" Visiting %d ", i); DDMN(m);
+ /*printf(" Visiting %d ", i); DDMN(m);*/
if (is_ip_cfop(m)) {
current_ir_graph = get_irn_irg(m);
break;
if (irn_visited(n)) return;
mark_irn_visited(n);
- //printf("mark: %d ", get_irn_visited(n)); DDMN(n);
- //DDME(get_irg_ent(current_ir_graph));
+ /*printf("mark: %d ", get_irn_visited(n)); DDMN(n);
+ DDME(get_irg_ent(current_ir_graph));*/
/* Initialize the node */
set_irn_dfn(n, current_dfn); /* Depth first number for this node */
ir_node *m;
if (is_backedge(n, i)) continue;
- m = get_irn_n(n, i); //get_irn_ip_pred(n, i);
+ m = get_irn_n(n, i); /*get_irn_ip_pred(n, i);*/
if ((!m) || (get_irn_op(m) == op_Unknown)) continue;
scc (m);
- //return_recur(n, i);
+ /*return_recur(n, i);*/
if (irn_is_in_stack(m)) {
/* Uplink of m is smaller if n->m is a backedge.
for (i = 0; i < get_irp_n_irgs(); i++) {
ir_node *sb;
current_ir_graph = get_irp_irg(i);
- //DDME(get_irg_ent(current_ir_graph));
+ /*DDME(get_irg_ent(current_ir_graph));*/
/* Find real entry points */
sb = get_irg_start_block(current_ir_graph);
if ((get_Block_n_cfgpreds(sb) > 1) ||
(get_nodes_Block(get_Block_cfgpred(sb, 0)) != sb)) continue;
- // printf("running scc for "); DDME(get_irg_ent(current_ir_graph));
+ /* printf("running scc for "); DDME(get_irg_ent(current_ir_graph)); */
/* Compute scc for this graph */
outermost_ir_graph = current_ir_graph;
set_irg_visited(outermost_ir_graph, get_max_irg_visited());
projects / libfirm / blobdiff