#include "config.h"
#endif
+#ifdef HAVE_STRING_H
#include <string.h>
+#endif
+
+#include <stdlib.h>
#include "irloop_t.h"
This reduces the depth of the loop tree. */
#define NO_LOOPS_WITHOUT_HEAD 1
-
-INLINE void add_loop_son(ir_loop *loop, ir_loop *son);
-
-INLINE void add_loop_node(ir_loop *loop, ir_node *n);
-
static ir_graph *outermost_ir_graph; /* The outermost graph the scc is computed
for */
static ir_loop *current_loop; /* Current loop construction is working
static INLINE void
mark_irn_in_stack (ir_node *n) {
- assert(get_irn_link(n));
- /* to slow */
- /* ((scc_info *)get_irn_link(n))->in_stack = true; */
- ((scc_info *)n->link)->in_stack = true;
+ scc_info *scc = get_irn_link(n);
+ assert(scc);
+ scc->in_stack = true;
}
static INLINE void
mark_irn_not_in_stack (ir_node *n) {
- assert(get_irn_link(n));
- /* to slow */
- /* ((scc_info *)get_irn_link(n))->in_stack = false; */
- ((scc_info *)n->link)->in_stack = false;
+ scc_info *scc = get_irn_link(n);
+ assert(scc);
+ scc->in_stack = false;
}
static INLINE bool
irn_is_in_stack (ir_node *n) {
- assert(get_irn_link(n));
- /* to slow */
- /* return ((scc_info *)get_irn_link(n))->in_stack; */
- return ((scc_info *)n->link)->in_stack;
+ scc_info *scc = get_irn_link(n);
+ assert(scc);
+ return scc->in_stack;
}
static INLINE void
set_irn_uplink (ir_node *n, int uplink) {
- assert(get_irn_link(n));
- /* to slow */
- /* ((scc_info *)get_irn_link(n))->uplink = uplink; */
- ((scc_info *)n->link)->uplink = uplink;
+ scc_info *scc = get_irn_link(n);
+ assert(scc);
+ scc->uplink = uplink;
}
-INLINE int
+int
get_irn_uplink (ir_node *n) {
- assert(get_irn_link(n));
- /* from fast to slow */
- /* return ((scc_info *)get_irn_link(n))->uplink; */
- return ((scc_info *)n->link)->uplink;
+ scc_info *scc = get_irn_link(n);
+ assert(scc);
+ return scc->uplink;
}
static INLINE void
set_irn_dfn (ir_node *n, int dfn) {
- assert(get_irn_link(n));
- /* to slow */
- /* ((scc_info *)get_irn_link(n))->dfn = dfn; */
- ((scc_info *)n->link)->dfn = dfn;
+ scc_info *scc = get_irn_link(n);
+ assert(scc);
+ scc->dfn = dfn;
}
-INLINE int
+int
get_irn_dfn (ir_node *n) {
- assert(get_irn_link(n));
- /* to slow */
- /* return ((scc_info *)get_irn_link(n))->dfn; */
- return ((scc_info *)n->link)->dfn;
+ scc_info *scc = get_irn_link(n);
+ assert(scc);
+ return scc->dfn;
}
-INLINE void
-set_irn_loop (ir_node *n, ir_loop* loop) {
+void
+set_irn_loop (ir_node *n, ir_loop *loop) {
n->loop = loop;
}
/* Uses temporary information to get the loop */
-INLINE ir_loop *
+ir_loop *
get_irn_loop (ir_node *n) {
return n->loop;
}
static ir_node **stack = NULL;
static int tos = 0; /* top of stack */
+/**
+ * initializes the stack
+ */
static INLINE void init_stack(void) {
if (stack) {
ARR_RESIZE (ir_node *, stack, 1000);
}
#endif
+/**
+ * push a node onto the stack
+ *
+ * @param n The node to push
+ */
static INLINE void
push (ir_node *n)
{
mark_irn_in_stack(n);
}
+/**
+ * pop a node from the stack
+ *
+ * @return The topmost node
+ */
static INLINE ir_node *
pop (void)
{
return n;
}
-/* The nodes up to n belong to the current loop.
- Removes them from the stack and adds them to the current loop. */
+/**
+ * The nodes up to n belong to the current loop.
+ * Removes them from the stack and adds them to the current loop.
+ */
static INLINE void
pop_scc_to_loop (ir_node *n)
{
add_loop_node(current_loop, m);
set_irn_loop(m, current_loop);
i++;
+
/* if (m==n) break;*/
} while(m != n);
ir_loop *last_son = lelement.son;
if (get_kind(last_son) == k_ir_loop &&
- get_loop_n_elements(last_son) == 1)
- {
- ir_loop *gson;
-
- lelement = get_loop_element(last_son, 0);
- gson = lelement.son;
- if(get_kind(gson) == k_ir_loop)
- {
- loop_element new_last_son;
-
- gson -> outer_loop = l;
- new_last_son.son = gson;
- l -> children[last] = new_last_son;
- }
+ get_loop_n_elements(last_son) == 1) {
+ ir_loop *gson;
+
+ lelement = get_loop_element(last_son, 0);
+ gson = lelement.son;
+
+ if (get_kind(gson) == k_ir_loop) {
+ loop_element new_last_son;
+
+ gson->outer_loop = l;
+ new_last_son.son = gson;
+ l->children[last] = new_last_son;
}
+ }
current_loop = l;
}
/* Returns the pos`th loop_node-child *
* TODO: This method isn`t very efficient ! *
- * Returns NULL if there isnt`t a pos`th loop_node */
+ * Returns NULL if there isn`t a pos`th loop_node */
ir_loop *get_loop_son (ir_loop *loop, int pos) {
int child_nr = 0, loop_nr = -1;
/* Use EXCLUSIVELY this function to add sons, otherwise the loop->n_sons
is invalid! */
-INLINE void
+void
add_loop_son(ir_loop *loop, ir_loop *son) {
loop_element lson;
lson.son = son;
/* Returns the pos`th ir_node-child *
* TODO: This method isn`t very efficient ! *
- * Returns NULL if there isnt`t a pos`th ir_node */
+ * Returns NULL if there isn`t a pos`th ir_node */
ir_node *get_loop_node (ir_loop *loop, int pos) {
int child_nr, node_nr = -1;
/* Use EXCLUSIVELY this function to add nodes, otherwise the loop->n_nodes
is invalid! */
-INLINE void
+void
add_loop_node(ir_loop *loop, ir_node *n) {
loop_element ln;
ln.node = n;
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.node" or "loop_element.son".
+ and then select the appropriate "loop_element.node" or "loop_element.son".
*/
loop_element get_loop_element (ir_loop *loop, int pos) {
#endif
}
-int is_ir_loop(const void *thing) {
- return (get_kind(thing) == k_ir_loop);
+int (is_ir_loop)(const void *thing) {
+ return _is_ir_loop(thing);
}
/* The outermost loop is remarked in the surrounding graph. */
-void set_irg_loop(ir_graph *irg, ir_loop *loop) {
- assert(irg);
- irg->loop = loop;
+void (set_irg_loop)(ir_graph *irg, ir_loop *loop) {
+ _set_irg_loop(irg, loop);
}
-ir_loop *get_irg_loop(ir_graph *irg) {
- assert(irg);
- return irg->loop;
+
+/* Returns the root loop info (if exists) for an irg. */
+ir_loop *(get_irg_loop)(ir_graph *irg) {
+ return _get_irg_loop(irg);
}
init_node (ir_node *n, void *env) {
set_irn_link (n, new_scc_info());
clear_backedges(n);
-#if 0
- /* Also init nodes not visible in intraproc_view. */
- /* @@@ init_node is called for too many nodes -- this wastes memory!.
- The mem is not lost as its on the obstack. */
- if (get_irn_op(n) == op_Filter) {
- for (i = 0; i < get_Filter_n_cg_preds(n); i++)
- init_node(get_Filter_cg_pred(n, i), NULL);
- }
- if (get_irn_op(n) == op_Block) {
- for (i = 0; i < get_Block_cg_n_cfgpreds(n); i++) {
- init_node(get_Block_cg_cfgpred(n, i), NULL);
- }
- }
- /* The following pattern matches only after a call from above pattern. */
- if ((get_irn_op(n) == op_Proj) /*&& (get_Proj_proj(n) == 0)*/) {
- /* @@@ init_node is called for every proj -- this wastes memory!.
- The mem is not lost as its on the obstack. */
- ir_node *cb = get_Proj_pred(n);
- if ((get_irn_op(cb) == op_CallBegin) ||
- (get_irn_op(cb) == op_EndReg) ||
- (get_irn_op(cb) == op_EndExcept)) {
- init_node(cb, NULL);
- init_node(get_nodes_block(cb), NULL);
- }
- }
-#endif
}
static INLINE void
#endif
/* Test for legal loop header: Block, Phi, ... */
-INLINE static bool is_possible_loop_head(ir_node *n) {
+static INLINE bool is_possible_loop_head(ir_node *n) {
ir_op *op = get_irn_op(n);
return ((op == op_Block) ||
(op == op_Phi) ||
assert(pred);
if (is_backedge(n, i) || !irn_is_in_stack(pred)) continue;
if (get_irn_dfn(pred) >= limit && (min == -1 || get_irn_dfn(pred) < min)) {
- index = i;
- min = get_irn_dfn(pred);
+ index = i;
+ min = get_irn_dfn(pred);
}
}
}
ir_node *pred = get_irn_n(n, i);
if (is_backedge (n, i) || !irn_is_in_stack(pred)) continue;
if (get_irn_dfn(pred) > max) {
- index = i;
- max = get_irn_dfn(pred);
+ index = i;
+ max = get_irn_dfn(pred);
}
}
}
m = stack[i];
if (is_head (m, n)) {
- res_index = smallest_dfn_pred (m, get_irn_dfn(m) + 1);
- if (res_index == -2) /* no smallest dfn pred found. */
- res_index = largest_dfn_pred (m);
-
- if ((m == n) && (res_index == -2)) { /* dont walk past loop head. */
- i = -1;
- }
- break;
+ res_index = smallest_dfn_pred (m, get_irn_dfn(m) + 1);
+ if (res_index == -2) /* no smallest dfn pred found. */
+ res_index = largest_dfn_pred (m);
+
+ if ((m == n) && (res_index == -2)) { /* dont walk past loop head. */
+ i = -1;
+ }
+ break;
}
/* We should not walk past our selves on the stack: The upcoming nodes
- are not in this loop. We assume a loop not reachable from Start. */
- if (m == n) {
- i = -1;
- break;
+ are not in this loop. We assume a loop not reachable from Start. */
+ if (m == n) {
+ i = -1;
+ break;
}
}
if (i < 0) {
/* A dead loop not reachable from Start. */
for (i = tos-2; i >= 0; --i) {
- m = stack[i];
- if (is_endless_head (m, n)) {
- res_index = smallest_dfn_pred (m, get_irn_dfn(m) + 1);
- if (res_index == -2) /* no smallest dfn pred found. */
- res_index = largest_dfn_pred (m);
- break;
- }
- if (m == n) { break; } /* It's not an unreachable loop, either. */
+ m = stack[i];
+ if (is_endless_head (m, n)) {
+ res_index = smallest_dfn_pred (m, get_irn_dfn(m) + 1);
+ if (res_index == -2) /* no smallest dfn pred found. */
+ res_index = largest_dfn_pred (m);
+ break;
+ }
+ if (m == n) { break; } /* It's not an unreachable loop, either. */
}
//assert(0 && "no head found on stack");
}
#if EXPERIMENTAL_LOOP_TREE
/* ----------------------------------------------------------------
- AS: This is experimantal code to build loop trees suitable for
+ AS: This is experimental code to build loop trees suitable for
the heap analysis. Does not work correctly right now... :-(
int i, j;
assert(is_Block(start_block));
for(i = tos - 1; i >= 0; --i)
- {
- DDMN(stack[i]);
- if(get_irn_op(stack[i]) == op_Proj && get_irn_mode(stack[i]) == mode_X &&
- get_irn_op(get_irn_n(stack[i], 0)) == op_EndReg)
- {
- printf("FOUND PROJ!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
- ir_node *end_projx = stack[i];
-
- int arity = get_irn_arity(start_block);
- for(j = 0; j < arity; j++)
+ {
+ DDMN(stack[i]);
+ if(get_irn_op(stack[i]) == op_Proj && get_irn_mode(stack[i]) == mode_X &&
+ get_irn_op(get_irn_n(stack[i], 0)) == op_EndReg)
+ {
+ printf("FOUND PROJ!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+ ir_node *end_projx = stack[i];
+
+ int arity = get_irn_arity(start_block);
+ for(j = 0; j < arity; j++)
{
ir_node *begin_projx = get_Block_cfgpred(get_irg_start_block(get_irn_irg(end_projx)),
get_Proj_proj(end_projx));
DDMN(begin_projx);
if(get_irn_n(start_block, j) == begin_projx)
- {
- printf("FOUND IT!!!!!!!!!!!!!!!!!!\n");
- return(j);
- }
+ {
+ printf("FOUND IT!!!!!!!!!!!!!!!!!!\n");
+ return(j);
+ }
}
- }
- }
+ }
+ }
return(-1);
}
#endif
-INLINE static int
+static INLINE int
is_outermost_loop(ir_loop *l) {
return l == get_loop_outer_loop(l);
}
* The core algorithm. *
*-----------------------------------------------------------*/
-
static void scc (ir_node *n) {
int i;
if (irn_visited(n)) return;
/* if ((!m) || (get_irn_op(m) == op_Unknown)) continue; */
scc (m);
if (irn_is_in_stack(m)) {
- /* Uplink of m is smaller if n->m is a backedge.
- Propagate the uplink to mark the loop. */
- if (get_irn_uplink(m) < get_irn_uplink(n))
- set_irn_uplink(n, get_irn_uplink(m));
+ /* Uplink of m is smaller if n->m is a backedge.
+ Propagate the uplink to mark the loop. */
+ if (get_irn_uplink(m) < get_irn_uplink(n))
+ set_irn_uplink(n, get_irn_uplink(m));
}
}
}
ir_loop *l;
int close;
if ((get_loop_n_elements(current_loop) > 0) || (is_outermost_loop(current_loop))) {
- l = new_loop();
- close = 1;
+ l = new_loop();
+ close = 1;
} else {
- l = current_loop;
- close = 0;
+ l = current_loop;
+ close = 0;
}
#else
ir_loop *l = new_loop();
/* The current backedge has been marked, that is temporarily eliminated,
by find tail. Start the scc algorithm
- anew on the subgraph thats left (the current loop without the backedge)
+ anew on the subgraph that is left (the current loop without the backedge)
in order to find more inner loops. */
scc (tail);
/* if ((!m) || (get_irn_op(m) == op_Unknown)) continue; */
my_scc (m);
if (irn_is_in_stack(m)) {
- /* Uplink of m is smaller if n->m is a backedge.
- Propagate the uplink to mark the loop. */
- if (get_irn_uplink(m) < get_irn_uplink(n))
- set_irn_uplink(n, get_irn_uplink(m));
+ /* Uplink of m is smaller if n->m is a backedge.
+ Propagate the uplink to mark the loop. */
+ if (get_irn_uplink(m) < get_irn_uplink(n))
+ set_irn_uplink(n, get_irn_uplink(m));
}
}
}
ir_loop *l;
int close;
if ((get_loop_n_elements(current_loop) > 0) || (is_outermost_loop(current_loop))) {
- l = new_loop();
- close = 1;
+ l = new_loop();
+ close = 1;
} else {
- l = current_loop;
- close = 0;
+ l = current_loop;
+ close = 0;
}
#else
ir_loop *l = new_loop();
/* The current backedge has been marked, that is temporarily eliminated,
by find tail. Start the scc algorithm
- anew on the subgraph thats left (the current loop without the backedge)
+ anew on the subgraph that is left (the current loop without the backedge)
in order to find more inner loops. */
my_scc (tail);
dump_loop(l, "-ha");
}
- if (get_loop_loop_nr(l) == 11819)
- dump_loop(l, "-ha-debug");
-
return found_problem;
}
if (found_problem) exit(0);
}
+
+/* ------------------------------------------------------------------- */
+/* Simple analyses based on the loop information */
+/* ------------------------------------------------------------------- */
+
+int is_loop_variant(ir_loop *l, ir_loop *b) {
+ int i, n_elems;
+
+ if (l == b) return true;
+
+ n_elems = get_loop_n_elements(l);
+ for (i = 0; i < n_elems; ++i) {
+ loop_element e = get_loop_element(l, i);
+ if (is_ir_loop(e.kind))
+ if (is_loop_variant(e.son, b))
+ return true;
+ }
+
+ return false;
+}
+
+/* Test whether a value is loop invariant.
+ *
+ * @param n The node to be tested.
+ * @param block A block node. We pass the block, not the loop as we must
+ * start off with a block loop to find all proper uses.
+ *
+ * Returns true, if the node n is not changed in the loop block
+ * belongs to or in inner loops of this blocks loop. */
+int is_loop_invariant(ir_node *n, ir_node *block) {
+ ir_loop *l = get_irn_loop(block);
+ ir_node *b = (is_Block(n)) ? n : get_nodes_block(n);
+ return !is_loop_variant(l, get_irn_loop(b));
+}
projects / libfirm / blobdiff