/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
- *
* This file is part of libFirm.
- *
- * This file may be distributed and/or modified under the terms of the
- * GNU General Public License version 2 as published by the Free Software
- * Foundation and appearing in the file LICENSE.GPL included in the
- * packaging of this file.
- *
- * Licensees holding valid libFirm Professional Edition licenses may use
- * this file in accordance with the libFirm Commercial License.
- * Agreement provided with the Software.
- *
- * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
- * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE.
+ * Copyright (C) 2012 University of Karlsruhe.
*/
/**
* Chapter 5.2.1.2.
* @author Goetz Lindenmaier
* @date 7.2002
- * @version $Id$
*/
#include "config.h"
#include "irdump.h"
#include "array.h"
#include "pmap.h"
-
-/* A variant of the loop tree that avoids loops without head.
- This reduces the depth of the loop tree. */
-#define NO_LOOPS_WITHOUT_HEAD 1
+#include "ircons.h"
/** The outermost graph the scc is computed for. */
static ir_graph *outermost_ir_graph;
/** Counter to generate depth first numbering of visited nodes. */
static int current_dfn = 1;
-static int max_loop_depth = 0;
-
-void link_to_reg_end(ir_node *n, void *env);
-void set_projx_link(ir_node *cb_projx, ir_node *end_projx);
-ir_node *get_projx_link(ir_node *cb_projx);
-
-/**********************************************************************/
-/* Node attributes **/
-/**********************************************************************/
-
/**********************************************************************/
/* Node attributes needed for the construction. **/
/**********************************************************************/
int in_stack; /**< Marks whether node is on the stack. */
int dfn; /**< Depth first search number. */
int uplink; /**< dfn number of ancestor. */
- /* ir_loop *loop; *//* Refers to the containing loop. */
- /*
- struct section *section;
- xset def;
- xset use;
- */
} scc_info;
/**
*/
static inline void mark_irn_in_stack(ir_node *n)
{
- scc_info *scc = get_irn_link(n);
+ scc_info *scc = (scc_info*) get_irn_link(n);
assert(scc);
scc->in_stack = 1;
}
*/
static inline void mark_irn_not_in_stack(ir_node *n)
{
- scc_info *scc = get_irn_link(n);
+ scc_info *scc = (scc_info*) get_irn_link(n);
assert(scc);
scc->in_stack = 0;
}
*/
static inline int irn_is_in_stack(ir_node *n)
{
- scc_info *scc = get_irn_link(n);
+ scc_info *scc = (scc_info*) get_irn_link(n);
assert(scc);
return scc->in_stack;
}
*/
static inline void set_irn_uplink(ir_node *n, int uplink)
{
- scc_info *scc = get_irn_link(n);
+ scc_info *scc = (scc_info*) get_irn_link(n);
assert(scc);
scc->uplink = uplink;
}
*/
static int get_irn_uplink(ir_node *n)
{
- scc_info *scc = get_irn_link(n);
+ scc_info *scc = (scc_info*) get_irn_link(n);
assert(scc);
return scc->uplink;
}
*/
static inline void set_irn_dfn(ir_node *n, int dfn)
{
- scc_info *scc = get_irn_link(n);
+ scc_info *scc = (scc_info*) get_irn_link(n);
assert(scc);
scc->dfn = dfn;
}
*/
static int get_irn_dfn(ir_node *n)
{
- scc_info *scc = get_irn_link(n);
+ scc_info *scc = (scc_info*) get_irn_link(n);
assert(scc);
return scc->dfn;
}
-#if 0
-static ir_loop *find_nodes_loop(ir_node *n, ir_loop *l)
-{
- int i;
- ir_loop *res = NULL;
-
- /* Test whether n is contained in this loop. */
- for (i = 0; i < get_loop_n_nodes(l); i++)
- if (n == get_loop_node(l, i)) return l;
-
- /* Is this a leave in the loop tree? If so loop not found. */
- if (get_loop_n_sons(l) == 0) return NULL;
-
- /* Else descend in the loop tree. */
- for (i = 0; i < get_loop_n_sons(l); i++) {
- res = find_nodes_loop(n, get_loop_son(l, i));
- if (res) break;
- }
- return res;
-}
-
-/* @@@ temporary implementation, costly!!! */
-ir_loop * get_irn_loop(ir_node *n)
-{
- ir_loop *l = get_irg_loop(current_ir_graph);
- l = find_nodes_loop(n, l);
- return l;
-}
-#endif
-
/**********************************************************************/
/* A stack. **/
/**********************************************************************/
static ir_node **stack = NULL;
-static int tos = 0; /* top of stack */
+static size_t tos = 0; /* top of stack */
/**
* initializes the stack
static inline void push(ir_node *n)
{
if (tos == ARR_LEN(stack)) {
- int nlen = ARR_LEN(stack) * 2;
+ size_t nlen = ARR_LEN(stack) * 2;
ARR_RESIZE(ir_node *, stack, nlen);
}
- stack [tos++] = n;
+ stack[tos++] = n;
mark_irn_in_stack(n);
}
*/
static inline ir_node *pop(void)
{
- ir_node *n = stack[--tos];
+ ir_node *n;
+
+ assert(tos > 0);
+ n = stack[--tos];
mark_irn_not_in_stack(n);
return n;
}
can't they have two loops as sons? Does it never get that far? ) */
static void close_loop(ir_loop *l)
{
- int last = get_loop_n_elements(l) - 1;
+ size_t last = get_loop_n_elements(l) - 1;
loop_element lelement = get_loop_element(l, last);
ir_loop *last_son = lelement.son;
static ir_loop *new_loop(void)
{
ir_loop *father = current_loop;
- ir_loop *son = alloc_loop(father, outermost_ir_graph->obst);
+ ir_loop *son = alloc_loop(father, get_irg_obstack(outermost_ir_graph));
- if (son->depth > max_loop_depth) max_loop_depth = son->depth;
current_loop = son;
return father;
}
static inline void init_node(ir_node *n, void *env)
{
- struct obstack *obst = env;
+ struct obstack *obst = (struct obstack*) env;
set_irn_link(n, new_scc_info(obst));
clear_backedges(n);
}
{
init_scc_common();
irg_walk_graph(irg, init_node, NULL, obst);
- /*
- irg_walk (irg, link_to_reg_end, NULL, NULL);
- */
}
static inline void finish_scc(void)
}
/**
- * Check weather a given node represents the outer most Start
+ * Check whether a given node represents the outermost Start
* block. In intra-procedural view this is the start block of the
* current graph, in interprocedural view it is the start block
* of the outer most graph.
/* When to walk from nodes to blocks. Only for Control flow operations? */
static inline int get_start_index(ir_node *n)
{
-#undef BLOCK_BEFORE_NODE
-#define BLOCK_BEFORE_NODE 1
-
-#if BLOCK_BEFORE_NODE
-
/* This version assures, that all nodes are ordered absolutely. This allows
to undef all nodes in the heap analysis if the block is false, which
means not reachable.
I.e., with this code, the order on the loop tree is correct. But a
(single) test showed the loop tree is deeper. */
- if (get_irn_op(n) == op_Phi ||
- is_Block(n) ||
+ if (is_Phi(n) ||
+ is_Block(n) ||
(get_irg_pinned(get_irn_irg(n)) == op_pin_state_floats &&
get_irn_pinned(n) == op_pin_state_floats))
// Here we could test for backedge at -1 which is illegal
return 0;
else
return -1;
-
-#else
-
- /* This version causes deeper loop trees (at least we verified this
- for Polymor).
- But it guarantees that Blocks are analysed before nodes contained in the
- block. If so, we can set the value to undef if the block is not \
- executed. */
- if (is_cfop(n) || is_fragile_op(n) || is_Start(n))
- return -1;
- else
- return 0;
-
-#endif
}
/**
* Return non-zero if the given node is a legal loop header:
- * Block, Phi, Filter.
+ * Block, Phi
*
* @param n the node to check
*/
static inline int is_possible_loop_head(ir_node *n)
{
- ir_op *op = get_irn_op(n);
- return ((op == op_Block) ||
- (op == op_Phi));
+ return is_Block(n) || is_Phi(n);
}
/**
- * Returns non-zero if n is a loop header, i.e., it is a Block, Phi
- * or Filter node and has predecessors within the loop and out
- * of the loop.
+ * Returns non-zero if n is a loop header, i.e., it is a Block or Phi
+ * node and has predecessors within the loop and out of the loop.
*
* @param n the node to check
* @param root only needed for assertion.
/**
* Returns non-zero if n is possible loop head of an endless loop.
- * I.e., it is a Block, Phi or Filter node and has only predecessors
+ * I.e., it is a Block or Phi node and has only predecessors
* within the loop.
*
* @param n the node to check
ir_node *m;
int i, res_index = -2;
- /*
- if (!icfg && rm_cyclic_phis && remove_cyclic_phis (n)) return NULL;
- */
m = stack[tos-1]; /* tos = top of stack */
if (is_head(m, n)) {
res_index = smallest_dfn_pred(m, 0);
res_index = largest_dfn_pred (m);
break;
}
- if (m == n) { break; } /* It's not an unreachable loop, either. */
+ /* It's not an unreachable loop, either. */
+ if (m == n)
+ break;
}
//assert(0 && "no head found on stack");
}
/* It's a completely bad loop: without Phi/Block nodes that can
be a head. I.e., the code is "dying". We break the loop by
setting Bad nodes. */
- int arity = get_irn_arity(n);
- ir_node *bad = get_irg_bad(get_irn_irg(n));
+ ir_graph *irg = get_irn_irg(n);
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *bad = new_r_Bad(irg, mode);
+ int arity = get_irn_arity(n);
for (i = -1; i < arity; ++i) {
set_irn_n(n, i, bad);
}
return is_outermost_Start(n) ? NULL : get_irn_n(m, res_index);
}
-
-#if EXPERIMENTAL_LOOP_TREE
-
-/* ----------------------------------------------------------------
- AS: This is experimental code to build loop trees suitable for
- the heap analysis. Does not work correctly right now... :-(
-
-
- Search in stack for the corresponding first Call-End-ProjX that
- corresponds to one of the control flow predecessors of the given
- block, that is the possible callers.
- returns: the control predecessor to chose\
- or -1 if no corresponding Call-End-Node could be found
- on the stack.
- - -------------------------------------------------------------- */
-
-int search_endproj_in_stack(ir_node *start_block)
-{
- int i, j;
- assert(is_Block(start_block));
- for (i = tos - 1; i >= 0; --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));
- if (get_irn_n(start_block, j) == begin_projx)
- {
- printf("FOUND IT!!!!!!!!!!!!!!!!!!\n");
- return(j);
- }
- }
- }
- }
- return(-1);
-}
-
-
-static pmap *projx_link = NULL;
-
-void link_to_reg_end (ir_node *n, void *env)
-{
- if (get_irn_op(n) == op_Proj &&
- get_irn_mode(n) == mode_X &&
- get_irn_op(get_irn_n(n, 0)) == op_EndReg) {
- /* Reg End Projx -> Find the CallBegin Projx and hash it */
- ir_node *end_projx = n;
- ir_node *begin_projx = get_Block_cfgpred(get_irg_start_block(get_irn_irg(end_projx)),
- get_Proj_proj(end_projx));
- set_projx_link(begin_projx, end_projx);
- }
-}
-
-void set_projx_link(ir_node *cb_projx, ir_node *end_projx)
-{
- if (projx_link == NULL)
- projx_link = pmap_create();
- pmap_insert(projx_link, (void *)cb_projx, (void *)end_projx);
-}
-
-ir_node *get_projx_link(ir_node *cb_projx)
-{
- return((ir_node *) pmap_get(projx_link, (void *)cb_projx));
-}
-
-#endif
-
static inline int is_outermost_loop(ir_loop *l)
{
return l == get_loop_outer_loop(l);
}
-
/*-----------------------------------------------------------*
* The core algorithm. *
*-----------------------------------------------------------*/
Next actions: Open a new loop on the loop tree and
try to find inner loops */
-#if NO_LOOPS_WITHOUT_HEAD
/* This is an adaption of the algorithm from fiasco / optscc to
* avoid loops without Block or Phi as first node. This should
* severely reduce the number of evaluations of nodes to detect
l = current_loop;
close = 0;
}
-#else
- ir_loop *l = new_loop();
-#endif
/* Remove the loop from the stack ... */
pop_scc_unmark_visit(n);
scc(tail);
assert(irn_visited(n));
-#if NO_LOOPS_WITHOUT_HEAD
if (close)
-#endif
close_loop(l);
} else {
/* No loop head was found, that is we have straight line code.
}
}
-/* Constructs backedge information for irg. In interprocedural view constructs
- backedges for all methods called by irg, too. */
-int construct_backedges(ir_graph *irg)
+void construct_backedges(ir_graph *irg)
{
ir_graph *rem = current_ir_graph;
ir_loop *head_rem;
struct obstack temp;
- max_loop_depth = 0;
current_ir_graph = irg;
outermost_ir_graph = irg;
obstack_free(&temp, NULL);
assert(head_rem == current_loop);
- mature_loops(current_loop, irg->obst);
+ mature_loops(current_loop, get_irg_obstack(irg));
set_irg_loop(irg, current_loop);
- set_irg_loopinfo_state(irg, loopinfo_consistent);
+ add_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO);
assert(get_irg_loop(irg)->kind == k_ir_loop);
current_ir_graph = rem;
- return max_loop_depth;
}
static void reset_backedges(ir_node *n)
}
}
-/*
-static void loop_reset_backedges(ir_loop *l)
-{
- int i;
- reset_backedges(get_loop_node(l, 0));
- for (i = 0; i < get_loop_n_nodes(l); ++i)
- set_irn_loop(get_loop_node(l, i), NULL);
- for (i = 0; i < get_loop_n_sons(l); ++i) {
- loop_reset_backedges(get_loop_son(l, i));
- }
-}
-*/
-
static void loop_reset_node(ir_node *n, void *env)
{
(void) env;
reset_backedges(n);
}
-/** Removes all loop information.
- Resets all backedges */
void free_loop_information(ir_graph *irg)
{
- /* We can not use this recursion, as the loop might contain
- illegal nodes by now. Why else would we throw away the
- representation?
- if (get_irg_loop(irg)) loop_reset_backedges(get_irg_loop(irg));
- */
irg_walk_graph(irg, loop_reset_node, NULL, NULL);
set_irg_loop(irg, NULL);
- set_irg_loopinfo_state(current_ir_graph, loopinfo_none);
+ clear_irg_properties(current_ir_graph, IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO);
/* We cannot free the loop nodes, they are on the obstack. */
}
void free_all_loop_information(void)
{
- int i;
+ size_t i;
for (i = 0; i < get_irp_n_irgs(); i++) {
free_loop_information(get_irp_irg(i));
}
static int is_loop_variant(ir_loop *l, ir_loop *b)
{
- int i, n_elems;
+ size_t i, n_elems;
if (l == b) return 1;
return 0;
}
-/* 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 non-zero, 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(const ir_node *n, const ir_node *block)
{
ir_loop *l = get_irn_loop(block);
projects / libfirm / blobdiff