projects
/
libfirm
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
- fixed off-by-one error after phase refactoring
[libfirm]
/
ir
/
opt
/
loop.c
diff --git
a/ir/opt/loop.c
b/ir/opt/loop.c
index
74ac01b
..
39df5e5
100644
(file)
--- a/
ir/opt/loop.c
+++ b/
ir/opt/loop.c
@@
-26,6
+26,8
@@
*/
#include "config.h"
*/
#include "config.h"
+#include "iroptimize.h"
+#include "opt_init.h"
#include "irnode.h"
#include "debug.h"
#include "irnode.h"
#include "debug.h"
@@
-36,16
+38,11
@@
#include "irouts.h"
#include "iredges.h"
#include "irtools.h"
#include "irouts.h"
#include "iredges.h"
#include "irtools.h"
-#include "array_t.h"
/* automatic array */
-#include "beutil.h"
/* get_block */
-#include "irloop_t.h"
/* set_irn_loop*/
+#include "array_t.h"
+#include "beutil.h"
+#include "irloop_t.h"
#include "irpass.h"
#include "irpass.h"
-#if 0
- #include "irdump_t.h"
-#endif
-
-
DEBUG_ONLY(static firm_dbg_module_t *dbg);
/**
DEBUG_ONLY(static firm_dbg_module_t *dbg);
/**
@@
-135,7
+132,8
@@
static unsigned enable_unrolling;
/**
* Creates object on the heap, and adds it to a linked list to free it later.
*/
/**
* Creates object on the heap, and adds it to a linked list to free it later.
*/
-static node_info *new_node_info(void) {
+static node_info *new_node_info(void)
+{
node_info *l = XMALLOCZ(node_info);
l->freelistnext = link_node_state_list;
link_node_state_list = l;
node_info *l = XMALLOCZ(node_info);
l->freelistnext = link_node_state_list;
link_node_state_list = l;
@@
-163,7
+161,7
@@
static void free_node_info(void)
int a = 0;
node_info *n;
n = link_node_state_list;
int a = 0;
node_info *n;
n = link_node_state_list;
- while(n) {
+ while
(n) {
node_info *next = n->freelistnext;
++a;
xfree(n);
node_info *next = n->freelistnext;
++a;
xfree(n);
@@
-180,7
+178,7
@@
static void reset_node_infos(void)
{
node_info *next;
next = link_node_state_list;
{
node_info *next;
next = link_node_state_list;
- while(next->freelistnext) {
+ while
(next->freelistnext) {
node_info *cur = next;
next = cur->freelistnext;
cur->copy = NULL;
node_info *cur = next;
next = cur->freelistnext;
cur->copy = NULL;
@@
-257,14
+255,15
@@
static unsigned is_nodesblock_marked(ir_node* node)
}
/* Returns the number of blocks in a loop. */
}
/* Returns the number of blocks in a loop. */
-int get_loop_n_blocks(ir_loop *loop) {
+static int get_loop_n_blocks(ir_loop *loop)
+{
int elements, e;
int blocks = 0;
elements = get_loop_n_elements(loop);
int elements, e;
int blocks = 0;
elements = get_loop_n_elements(loop);
- for(e=0; e<elements; e++) {
+ for
(e=0; e<elements; e++) {
loop_element elem = get_loop_element(loop, e);
loop_element elem = get_loop_element(loop, e);
- if
(is_ir_node(elem.kind) && is_Block(elem.node))
+ if (is_ir_node(elem.kind) && is_Block(elem.node))
++blocks;
}
return blocks;
++blocks;
}
return blocks;
@@
-274,7
+273,7
@@
int get_loop_n_blocks(ir_loop *loop) {
* Add newpred at position pos to node and also add the corresponding value to the phis.
* Requires block phi list.
*/
* Add newpred at position pos to node and also add the corresponding value to the phis.
* Requires block phi list.
*/
-static int duplicate_preds(ir_node*
node
, unsigned pos, ir_node* newpred)
+static int duplicate_preds(ir_node*
block
, unsigned pos, ir_node* newpred)
{
ir_node **ins;
/*int *is_be;*/
{
ir_node **ins;
/*int *is_be;*/
@@
-282,34
+281,36
@@
static int duplicate_preds(ir_node* node, unsigned pos, ir_node* newpred)
int block_arity;
int i;
int block_arity;
int i;
- assert(is_Block(
node) && "duplicate_preds is only allowed for blocks
");
+ assert(is_Block(
block) && "duplicate_preds may be called for blocks only
");
- DB((dbg, LEVEL_5, "duplicate_preds(node %ld, pos %d, newpred %ld)\n",
- get_irn_node_nr(node), pos, get_irn_node_nr(newpred)));
+ DB((dbg, LEVEL_5, "duplicate_preds(node %N, pos %d, newpred %N)\n", block, pos, newpred));
- block_arity = get_irn_arity(
node
);
+ block_arity = get_irn_arity(
block
);
NEW_ARR_A(ir_node*, ins, block_arity + 1);
for (i = 0; i < block_arity; ++i) {
NEW_ARR_A(ir_node*, ins, block_arity + 1);
for (i = 0; i < block_arity; ++i) {
- ins[i] = get_irn_n(
node
, i);
+ ins[i] = get_irn_n(
block
, i);
}
ins[block_arity] = newpred;
}
ins[block_arity] = newpred;
- set_irn_in(
node
, block_arity + 1, ins);
+ set_irn_in(
block
, block_arity + 1, ins);
- for_each_phi(node, phi) {
+ /* LDBG 1 */
+#if 1
+ for_each_phi(block, phi) {
int phi_arity = get_irn_arity(phi);
int phi_arity = get_irn_arity(phi);
- DB((dbg, LEVEL_5, "duplicate_preds: fixing phi %
ld\n", get_irn_node_nr(phi)
));
+ DB((dbg, LEVEL_5, "duplicate_preds: fixing phi %
N\n", phi
));
NEW_ARR_A(ir_node *, ins, block_arity + 1);
NEW_ARR_A(ir_node *, ins, block_arity + 1);
- for (i
=
0; i < phi_arity; ++i) {
- DB((dbg, LEVEL_5, "
in %ld\n", get_irn_node_nr(get_irn_n(phi, i)
)));
+ for (i
=
0; i < phi_arity; ++i) {
+ DB((dbg, LEVEL_5, "
pos %N\n", get_irn_n(phi, i
)));
ins[i] = get_irn_n(phi, i);
}
ins[i] = get_irn_n(phi, i);
}
- ins[block_arity] = get_
irn_n(phi, pos
);
+ ins[block_arity] = get_
copy(get_irn_n(phi, pos)
);
set_irn_in(phi, block_arity + 1, ins);
}
set_irn_in(phi, block_arity + 1, ins);
}
+#endif
return block_arity;
}
return block_arity;
}
@@
-360,7
+361,7
@@
static void get_loop_outs(ir_node *node, void *env)
(void) env;
arity = get_irn_arity(node);
(void) env;
arity = get_irn_arity(node);
- for (i = 0; i < arity;
i++
) {
+ for (i = 0; i < arity;
++i
) {
ir_node *pred = get_irn_n(node, i);
pred_in_loop = is_in_loop(pred);
ir_node *pred = get_irn_n(node, i);
pred_in_loop = is_in_loop(pred);
@@
-389,7
+390,7
@@
static ir_node *search_def_and_create_phis(ir_node *block, ir_mode *mode)
ir_node *phi;
ir_node **in;
ir_node *phi;
ir_node **in;
- DB((dbg, LEVEL_5, "ssa search_def_and_create_phis: block %
ld\n", get_irn_node_nr(block)
));
+ DB((dbg, LEVEL_5, "ssa search_def_and_create_phis: block %
N\n", block
));
/* Prevents creation of phi that would be bad anyway.
* Dead and bad blocks. */
/* Prevents creation of phi that would be bad anyway.
* Dead and bad blocks. */
@@
-397,14
+398,14
@@
static ir_node *search_def_and_create_phis(ir_node *block, ir_mode *mode)
return new_Bad();
if (block == ssa_second_def_block) {
return new_Bad();
if (block == ssa_second_def_block) {
- DB((dbg, LEVEL_5, "ssa found second definition: use second def %
ld\n", get_irn_node_nr(ssa_second_def)
));
+ DB((dbg, LEVEL_5, "ssa found second definition: use second def %
N\n", ssa_second_def
));
return ssa_second_def;
}
/* already processed this block? */
if (irn_visited(block)) {
ir_node *value = get_link(block);
return ssa_second_def;
}
/* already processed this block? */
if (irn_visited(block)) {
ir_node *value = get_link(block);
- DB((dbg, LEVEL_5, "ssa already visited: use linked %
ld\n", get_irn_node_nr(value)
));
+ DB((dbg, LEVEL_5, "ssa already visited: use linked %
N\n", value
));
return value;
}
return value;
}
@@
-417,7
+418,7
@@
static ir_node *search_def_and_create_phis(ir_node *block, ir_mode *mode)
ir_node *pred_block = get_Block_cfgpred_block(block, 0);
ir_node *value;
ir_node *pred_block = get_Block_cfgpred_block(block, 0);
ir_node *value;
- DB((dbg, LEVEL_5, "ssa 1 pred: walk pred %
ld\n", get_irn_node_nr(pred_block)
));
+ DB((dbg, LEVEL_5, "ssa 1 pred: walk pred %
N\n", pred_block
));
value = search_def_and_create_phis(pred_block, mode);
set_link(block, value);
value = search_def_and_create_phis(pred_block, mode);
set_link(block, value);
@@
-428,7
+429,7
@@
static ir_node *search_def_and_create_phis(ir_node *block, ir_mode *mode)
/* create a new Phi */
NEW_ARR_A(ir_node*, in, n_cfgpreds);
/* create a new Phi */
NEW_ARR_A(ir_node*, in, n_cfgpreds);
- for(i = 0; i < n_cfgpreds; ++i)
+ for
(i = 0; i < n_cfgpreds; ++i)
in[i] = new_Unknown(mode);
phi = new_r_Phi(block, n_cfgpreds, in, mode);
in[i] = new_Unknown(mode);
phi = new_r_Phi(block, n_cfgpreds, in, mode);
@@
-438,20
+439,20
@@
static ir_node *search_def_and_create_phis(ir_node *block, ir_mode *mode)
/* EVERY node is assumed to have a node_info linked. */
alloc_node_info(phi, NULL);
/* EVERY node is assumed to have a node_info linked. */
alloc_node_info(phi, NULL);
- DB((dbg, LEVEL_5, "ssa phi creation: link new phi %
ld to block %ld\n", get_irn_node_nr(phi), get_irn_node_nr(block)
));
+ DB((dbg, LEVEL_5, "ssa phi creation: link new phi %
N to block %N\n", phi, block
));
set_link(block, phi);
mark_irn_visited(block);
/* set Phi predecessors */
set_link(block, phi);
mark_irn_visited(block);
/* set Phi predecessors */
- for(i = 0; i < n_cfgpreds; ++i) {
+ for
(i = 0; i < n_cfgpreds; ++i) {
ir_node *pred_val;
ir_node *pred_block = get_Block_cfgpred_block(block, i);
assert(pred_block != NULL);
pred_val = search_def_and_create_phis(pred_block, mode);
assert(pred_val != NULL);
ir_node *pred_val;
ir_node *pred_block = get_Block_cfgpred_block(block, i);
assert(pred_block != NULL);
pred_val = search_def_and_create_phis(pred_block, mode);
assert(pred_val != NULL);
- DB((dbg, LEVEL_5, "ssa phi pred:phi %
ld, pred %ld\n", get_irn_node_nr(phi), get_irn_node_nr(pred_val)
));
+ DB((dbg, LEVEL_5, "ssa phi pred:phi %
N, pred %N\n", phi, pred_val
));
set_irn_n(phi, i, pred_val);
}
return phi;
set_irn_n(phi, i, pred_val);
}
return phi;
@@
-500,7
+501,7
@@
static void construct_ssa(ir_node *orig_block, ir_node *orig_val,
if (is_End(user))
continue;
if (is_End(user))
continue;
- DB((dbg, LEVEL_5, "original user %
ld\n", get_irn_node_nr(user)
));
+ DB((dbg, LEVEL_5, "original user %
N\n", user
));
if (is_Phi(user)) {
ir_node *pred_block = get_Block_cfgpred_block(user_block, j);
if (is_Phi(user)) {
ir_node *pred_block = get_Block_cfgpred_block(user_block, j);
@@
-538,8
+539,8
@@
static void construct_ssa_n(ir_node *def, ir_node *user)
set_link(get_nodes_block(iter), iter);
mark_irn_visited(get_nodes_block(iter));
set_link(get_nodes_block(iter), iter);
mark_irn_visited(get_nodes_block(iter));
- DB((dbg, LEVEL_5, "ssa_n: Link def %
ld to block %ld
\n",
-
get_irn_node_nr(iter), get_irn_node_nr(get_nodes_block(iter)
)));
+ DB((dbg, LEVEL_5, "ssa_n: Link def %
N to block %N
\n",
+
iter, get_nodes_block(iter
)));
}
/* Need to search the outs, because we need the in-pos on the user node. */
}
/* Need to search the outs, because we need the in-pos on the user node. */
@@
-569,10
+570,10
@@
static void construct_ssa_n(ir_node *def, ir_node *user)
/**
* Construct SSA for all definitions in arr.
*/
/**
* Construct SSA for all definitions in arr.
*/
-void construct_ssa_foreach(ir_node **arr, int arr_n)
+
static
void construct_ssa_foreach(ir_node **arr, int arr_n)
{
int i;
{
int i;
- for
(i = 0; i < arr_n
; ++i) {
+ for
(i = 0; i < arr_n
; ++i) {
ir_node *cppred, *block, *cpblock, *pred;
pred = arr[i];
ir_node *cppred, *block, *cpblock, *pred;
pred = arr[i];
@@
-708,19
+709,21
@@
static ir_node *rawcopy_node(ir_node *node)
cpstate = new_node_info();
set_irn_link(cp, cpstate);
cpstate = new_node_info();
set_irn_link(cp, cpstate);
+
if (is_Block(cp)) {
/* TODO
* exact_copy already sets Macroblock.
if (is_Block(cp)) {
/* TODO
* exact_copy already sets Macroblock.
- * Why
do we need to
do this anyway? */
+ * Why
should we
do this anyway? */
set_Block_MacroBlock(cp, cp);
}
set_Block_MacroBlock(cp, cp);
}
+
return cp;
}
/**
* This walker copies all walked nodes.
* If the walk_condition is true for a node, it is walked.
return cp;
}
/**
* This walker copies all walked nodes.
* If the walk_condition is true for a node, it is walked.
- * All nodes node_info->copy attributes ha
s to be NULL prior to every
to every walk.
+ * All nodes node_info->copy attributes ha
ve to be NULL prior
to every walk.
*/
static void copy_walk(ir_node *node, walker_condition *walk_condition, ir_loop *set_loop)
{
*/
static void copy_walk(ir_node *node, walker_condition *walk_condition, ir_loop *set_loop)
{
@@
-736,10
+739,10
@@
static void copy_walk(ir_node *node, walker_condition *walk_condition, ir_loop *
*/
if (get_irn_visited(node) >= get_irg_visited(irg)) {
/* Here we rely on nodestate's copy being initialized with NULL */
*/
if (get_irn_visited(node) >= get_irg_visited(irg)) {
/* Here we rely on nodestate's copy being initialized with NULL */
- DB((dbg, LEVEL_5, "copy_walk: We have already visited %
ld\n", get_irn_node_nr(node)
));
+ DB((dbg, LEVEL_5, "copy_walk: We have already visited %
N\n", node
));
if (node_info->copy == NULL) {
cp = rawcopy_node(node);
if (node_info->copy == NULL) {
cp = rawcopy_node(node);
- DB((dbg, LEVEL_5, "The TEMP copy of %
ld is created %ld\n", get_irn_node_nr(node), get_irn_node_nr(cp)
));
+ DB((dbg, LEVEL_5, "The TEMP copy of %
N is created %N\n", node, cp
));
}
return;
}
}
return;
}
@@
-750,7
+753,7
@@
static void copy_walk(ir_node *node, walker_condition *walk_condition, ir_loop *
if (!is_Block(node)) {
ir_node *pred = get_nodes_block(node);
if (walk_condition(pred))
if (!is_Block(node)) {
ir_node *pred = get_nodes_block(node);
if (walk_condition(pred))
- DB((dbg, LEVEL_5, "walk block %
ld\n", get_irn_node_nr(pred)
));
+ DB((dbg, LEVEL_5, "walk block %
N\n", pred
));
copy_walk(pred, walk_condition, set_loop);
}
copy_walk(pred, walk_condition, set_loop);
}
@@
-758,15
+761,15
@@
static void copy_walk(ir_node *node, walker_condition *walk_condition, ir_loop *
NEW_ARR_A(ir_node *, cpin, arity);
NEW_ARR_A(ir_node *, cpin, arity);
- for (i =
get_irn_arity(node) - 1; i >= 0; --
i) {
+ for (i =
0; i < arity; ++
i) {
ir_node *pred = get_irn_n(node, i);
if (walk_condition(pred)) {
ir_node *pred = get_irn_n(node, i);
if (walk_condition(pred)) {
- DB((dbg, LEVEL_5, "walk node %
ld\n", get_irn_node_nr(pred)
));
+ DB((dbg, LEVEL_5, "walk node %
N\n", pred
));
copy_walk(pred, walk_condition, set_loop);
cpin[i] = get_copy(pred);
copy_walk(pred, walk_condition, set_loop);
cpin[i] = get_copy(pred);
- DB((dbg, LEVEL_5, "copy of %
ld gets new in %ld which is copy of %ld
\n",
-
get_irn_node_nr(node), get_irn_node_nr(get_copy(pred)), get_irn_node_nr(pred)
));
+ DB((dbg, LEVEL_5, "copy of %
N gets new in %N which is copy of %N
\n",
+
node, get_copy(pred), pred
));
} else {
cpin[i] = pred;
}
} else {
cpin[i] = pred;
}
@@
-776,19
+779,18
@@
static void copy_walk(ir_node *node, walker_condition *walk_condition, ir_loop *
if (node_info->copy == NULL) {
/* No temporary copy existent */
cp = rawcopy_node(node);
if (node_info->copy == NULL) {
/* No temporary copy existent */
cp = rawcopy_node(node);
- DB((dbg, LEVEL_5, "The FINAL copy of %
ld is CREATED %ld\n", get_irn_node_nr(node), get_irn_node_nr(cp)
));
+ DB((dbg, LEVEL_5, "The FINAL copy of %
N is CREATED %N\n", node, cp
));
} else {
/* temporary copy is existent but without correct ins */
cp = get_copy(node);
} else {
/* temporary copy is existent but without correct ins */
cp = get_copy(node);
- DB((dbg, LEVEL_5, "The FINAL copy of %
ld is EXISTENT %ld\n", get_irn_node_nr(node), get_irn_node_nr(cp)
));
+ DB((dbg, LEVEL_5, "The FINAL copy of %
N is EXISTENT %N\n", node, cp
));
}
if (!is_Block(node)) {
ir_node *cpblock = get_copy(get_nodes_block(node));
set_nodes_block(cp, cpblock );
}
if (!is_Block(node)) {
ir_node *cpblock = get_copy(get_nodes_block(node));
set_nodes_block(cp, cpblock );
- /* fix the phi information in attr.phis */
- if( is_Phi(cp) )
+ if (is_Phi(cp))
add_Block_phi(cpblock, cp);
}
add_Block_phi(cpblock, cp);
}
@@
-812,7
+814,7
@@
static void peel(out_edge *loop_outs)
/* duplicate loop walk */
inc_irg_visited(current_ir_graph);
/* duplicate loop walk */
inc_irg_visited(current_ir_graph);
- for(i = 0; i < ARR_LEN(loop_outs); i++) {
+ for
(i = 0; i < ARR_LEN(loop_outs); i++) {
out_edge entry = loop_outs[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
out_edge entry = loop_outs[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
@@
-823,11
+825,13
@@
static void peel(out_edge *loop_outs)
} else {
copy_walk(pred, is_in_loop, NULL);
/* leave out keepalives */
} else {
copy_walk(pred, is_in_loop, NULL);
/* leave out keepalives */
- if (!is_End(node))
+ if (!is_End(node))
{
/* Node is user of a value defined inside the loop.
* We'll need a phi since we duplicated the loop. */
/* Cannot construct_ssa here, because it needs another walker. */
/* Node is user of a value defined inside the loop.
* We'll need a phi since we duplicated the loop. */
/* Cannot construct_ssa here, because it needs another walker. */
- entry_buffer[entry_c++] = pred;
+ entry_buffer[entry_c] = pred;
+ ++entry_c;
+ }
}
}
}
}
@@
-838,7
+842,7
@@
static void peel(out_edge *loop_outs)
/* Generate phis for values from peeled code and original loop */
construct_ssa_foreach(entry_buffer, entry_c);
/* Generate phis for values from peeled code and original loop */
construct_ssa_foreach(entry_buffer, entry_c);
- /*for(i = 0; i < entry_c; i++)
+ /*for
(i = 0; i < entry_c; i++)
{
ir_node *cppred, *block, *cpblock, *pred;
{
ir_node *cppred, *block, *cpblock, *pred;
@@
-861,14
+865,14
@@
static void get_head_outs(ir_node *node, void *env)
int arity = get_irn_arity(node);
(void) env;
int arity = get_irn_arity(node);
(void) env;
- DB((dbg, LEVEL_5, "get head entries %
ld \n", get_irn_node_nr(node)
));
+ DB((dbg, LEVEL_5, "get head entries %
N \n", node
));
- for(i = 0; i < arity; ++i) {
+ for
(i = 0; i < arity; ++i) {
/* node is not in the head, but the predecessor is.
* (head or loop chain nodes are marked) */
DB((dbg, LEVEL_5, "... "));
/* node is not in the head, but the predecessor is.
* (head or loop chain nodes are marked) */
DB((dbg, LEVEL_5, "... "));
- DB((dbg, LEVEL_5, "node %
ld
marked %d (0) pred %d marked %d (1) \n",
+ DB((dbg, LEVEL_5, "node %
N
marked %d (0) pred %d marked %d (1) \n",
node->node_nr, is_nodesblock_marked(node),i, is_nodesblock_marked(get_irn_n(node, i))));
if (!is_nodesblock_marked(node) && is_nodesblock_marked(get_irn_n(node, i))) {
node->node_nr, is_nodesblock_marked(node),i, is_nodesblock_marked(get_irn_n(node, i))));
if (!is_nodesblock_marked(node) && is_nodesblock_marked(get_irn_n(node, i))) {
@@
-876,8
+880,8
@@
static void get_head_outs(ir_node *node, void *env)
entry.node = node;
entry.pred_irn_n = i;
DB((dbg, LEVEL_5,
entry.node = node;
entry.pred_irn_n = i;
DB((dbg, LEVEL_5,
- "Found head chain entry %
ld @%d because !inloop %ld and inloop %ld
\n",
-
get_irn_node_nr(node), i, get_irn_node_nr(node), get_irn_node_nr(get_irn_n(node, i)
)));
+ "Found head chain entry %
N @%d because !inloop %N and inloop %N
\n",
+
node, i, node, get_irn_n(node, i
)));
ARR_APP1(out_edge, cur_head_outs, entry);
}
}
ARR_APP1(out_edge, cur_head_outs, entry);
}
}
@@
-888,12
+892,13
@@
static void get_head_outs(ir_node *node, void *env)
* A block belongs to the chain if a condition branches out of the loop.
* Returns 1 if the given block belongs to the condition chain.
*/
* A block belongs to the chain if a condition branches out of the loop.
* Returns 1 if the given block belongs to the condition chain.
*/
-static unsigned find_condition_chains(ir_node *block) {
+static unsigned find_condition_chains(ir_node *block)
+{
const ir_edge_t *edge;
unsigned mark = 0;
int nodes_n = 0;
const ir_edge_t *edge;
unsigned mark = 0;
int nodes_n = 0;
- DB((dbg, LEVEL_5, "condition_chains for block %
ld\n", get_irn_node_nr(block)
));
+ DB((dbg, LEVEL_5, "condition_chains for block %
N\n", block
));
/* Collect all outs, including keeps.
* (TODO firm function for number of out edges?) */
/* Collect all outs, including keeps.
* (TODO firm function for number of out edges?) */
@@
-935,7
+940,7
@@
static unsigned find_condition_chains(ir_node *block) {
} else {
set_Block_mark(block, 1);
++head_inversion_block_count;
} else {
set_Block_mark(block, 1);
++head_inversion_block_count;
- DB((dbg, LEVEL_5, "block %
ld is part of condition chain\n", get_irn_node_nr(block)
));
+ DB((dbg, LEVEL_5, "block %
N is part of condition chain\n", block
));
head_inversion_node_count += nodes_n;
}
head_inversion_node_count += nodes_n;
}
@@
-951,7
+956,7
@@
static unsigned find_condition_chains(ir_node *block) {
}
mark_irn_visited(src);
}
mark_irn_visited(src);
- DB((dbg, LEVEL_5, "condition chain walk %
ld\n", get_irn_node_nr(src)
));
+ DB((dbg, LEVEL_5, "condition chain walk %
N\n", src
));
inchain = find_condition_chains(src);
/* if successor is not part of chain we need to collect its outs */
inchain = find_condition_chains(src);
/* if successor is not part of chain we need to collect its outs */
@@
-1050,9
+1055,11
@@
static void inversion_walk(out_edge *head_entries)
head_phi_assign = NEW_ARR_F(ir_node *, 0);
head_phi_assign = NEW_ARR_F(ir_node *, 0);
- /* Find assignments in the condition chain, to construct_ssa for them after the loop inversion. */
+ /* Find assignments in the condition chain,
+ * to construct_ssa for them after the loop inversion. */
for_each_phi(loop_cf_head , phi) {
for_each_phi(loop_cf_head , phi) {
- for(i=0; i<get_irn_arity(phi); ++i) {
+ int arity = get_irn_arity(phi);
+ for (i = 0; i < arity; ++i) {
ir_node *def = get_irn_n(phi, i);
if (is_nodesblock_marked(def)) {
ARR_APP1(ir_node *, head_phi_assign, def);
ir_node *def = get_irn_n(phi, i);
if (is_nodesblock_marked(def)) {
ARR_APP1(ir_node *, head_phi_assign, def);
@@
-1067,24
+1074,28
@@
static void inversion_walk(out_edge *head_entries)
**/
inc_irg_visited(current_ir_graph);
**/
inc_irg_visited(current_ir_graph);
- for(i = 0; i < ARR_LEN(head_entries); ++i) {
+ for
(i = 0; i < ARR_LEN(head_entries); ++i) {
out_edge entry = head_entries[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
if (is_Block(node)) {
out_edge entry = head_entries[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
if (is_Block(node)) {
- DB((dbg, LEVEL_5, "\nInit walk block %ld\n", get_irn_node_nr(pred)));
+ DB((dbg, LEVEL_5, "\nInit walk block %N\n", pred));
+
copy_walk(pred, is_nodesblock_marked, cur_loop);
duplicate_preds(node, entry.pred_irn_n, get_copy(pred) );
} else {
copy_walk(pred, is_nodesblock_marked, cur_loop);
duplicate_preds(node, entry.pred_irn_n, get_copy(pred) );
} else {
- DB((dbg, LEVEL_5, "\nInit walk node %ld\n", get_irn_node_nr(pred)));
+ DB((dbg, LEVEL_5, "\nInit walk node %N\n", pred));
+
copy_walk(pred, is_nodesblock_marked, cur_loop);
/* ignore keepalives */
copy_walk(pred, is_nodesblock_marked, cur_loop);
/* ignore keepalives */
- if (!is_End(node))
+ if (!is_End(node))
{
/* Node is user of a value assigned inside the loop.
* We will need a phi since we duplicated the head. */
/* Node is user of a value assigned inside the loop.
* We will need a phi since we duplicated the head. */
- entry_buffer[entry_c++] = pred;
+ entry_buffer[entry_c] = pred;
+ ++entry_c;
+ }
}
}
}
}
@@
-1104,7
+1115,7
@@
static void inversion_walk(out_edge *head_entries)
}
/* Loop peeling */
}
/* Loop peeling */
-void loop_peeling(void)
+
static
void loop_peeling(void)
{
cur_loop_outs = NEW_ARR_F(out_edge, 0);
irg_walk_graph( current_ir_graph, get_loop_outs, NULL, NULL );
{
cur_loop_outs = NEW_ARR_F(out_edge, 0);
irg_walk_graph( current_ir_graph, get_loop_outs, NULL, NULL );
@@
-1122,7
+1133,7
@@
void loop_peeling(void)
}
/* Loop inversion */
}
/* Loop inversion */
-void loop_inversion(void)
+
static
void loop_inversion(void)
{
unsigned do_inversion = 1;
{
unsigned do_inversion = 1;
@@
-1181,7
+1192,7
@@
void loop_inversion(void)
* Returns last element of linked list of copies by
* walking the linked list.
*/
* Returns last element of linked list of copies by
* walking the linked list.
*/
-ir_node *get_last_copy(ir_node *node)
+
static
ir_node *get_last_copy(ir_node *node)
{
ir_node *copy, *cur;
cur = node;
{
ir_node *copy, *cur;
cur = node;
@@
-1194,7
+1205,7
@@
ir_node *get_last_copy(ir_node *node)
/**
* Rewire floating copies of the current loop.
*/
/**
* Rewire floating copies of the current loop.
*/
-void unrolling_fix_cf(void)
+
static
void unrolling_fix_cf(void)
{
ir_node *loophead = loop_cf_head;
int headarity = get_irn_arity(loophead);
{
ir_node *loophead = loop_cf_head;
int headarity = get_irn_arity(loophead);
@@
-1274,7
+1285,7
@@
static ir_node *add_phi(ir_node *node, int phi_pos)
/* create a new Phi */
NEW_ARR_A(ir_node*, in, n_cfgpreds);
/* create a new Phi */
NEW_ARR_A(ir_node*, in, n_cfgpreds);
- for(i = 0; i < n_cfgpreds; ++i)
+ for
(i = 0; i < n_cfgpreds; ++i)
in[i] = new_Unknown(mode); /*pred;*/
phi = new_r_Phi(block, n_cfgpreds, in, mode);
in[i] = new_Unknown(mode); /*pred;*/
phi = new_r_Phi(block, n_cfgpreds, in, mode);
@@
-1297,11
+1308,11
@@
static ir_node *add_phi(ir_node *node, int phi_pos)
* Loop unrolling
* Could be improved with variable range informations.
*/
* Loop unrolling
* Could be improved with variable range informations.
*/
-void loop_unrolling(void)
+
static
void loop_unrolling(void)
{
int i, j;
{
int i, j;
- unroll_times =
8
;
+ unroll_times =
7
;
cur_loop_outs = NEW_ARR_F(out_edge, 0);
irg_walk_graph( current_ir_graph, get_loop_outs, NULL, NULL );
cur_loop_outs = NEW_ARR_F(out_edge, 0);
irg_walk_graph( current_ir_graph, get_loop_outs, NULL, NULL );
@@
-1311,29
+1322,25
@@
void loop_unrolling(void)
/* duplicate whole loop content */
inc_irg_visited(current_ir_graph);
/* duplicate whole loop content */
inc_irg_visited(current_ir_graph);
- for
(i = 0; i < ARR_LEN(cur_loop_outs); i++
) {
+ for
(i = 0; i < ARR_LEN(cur_loop_outs); ++i
) {
out_edge entry = cur_loop_outs[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
out_edge entry = cur_loop_outs[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
-
if (!is_Block(node)) {
if (!is_Block(node)) {
-
- for (j = 0; j < unroll_times-1; ++j) {
+ for (j = 0; j < unroll_times - 1; ++j) {
copy_walk(pred, is_in_loop, cur_loop);
copy_walk(pred, is_in_loop, cur_loop);
-
pred = get_copy(pred);
}
}
}
pred = get_copy(pred);
}
}
}
- for
(i = 0; i < ARR_LEN(cur_loop_outs); i++
) {
+ for
(i = 0; i < ARR_LEN(cur_loop_outs); ++i
) {
out_edge entry = cur_loop_outs[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
out_edge entry = cur_loop_outs[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
- /* build linked list of copied nodes/blocks */
if (is_Block(node)) {
if (is_Block(node)) {
- for (j = 0; j < unroll_times
-
1; ++j) {
+ for (j = 0; j < unroll_times
-
1; ++j) {
copy_walk(pred, is_in_loop, cur_loop);
duplicate_preds(node, entry.pred_irn_n, get_copy(pred));
copy_walk(pred, is_in_loop, cur_loop);
duplicate_preds(node, entry.pred_irn_n, get_copy(pred));
@@
-1344,21
+1351,26
@@
void loop_unrolling(void)
ir_free_resources(current_ir_graph, IR_RESOURCE_IRN_VISITED);
ir_free_resources(current_ir_graph, IR_RESOURCE_IRN_VISITED);
+ /*dump_ir_graph(current_ir_graph, "-raw");*/
+
+ /* LDBG 2 */
+#if 1
/* Line up the floating copies. */
unrolling_fix_cf();
/* Generate phis for all loop outs */
/* Line up the floating copies. */
unrolling_fix_cf();
/* Generate phis for all loop outs */
- for
(i = 0; i < ARR_LEN(cur_loop_outs); i++
) {
+ for
(i = 0; i < ARR_LEN(cur_loop_outs); ++i
) {
out_edge entry = cur_loop_outs[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
if (!is_Block(node) && !is_End(node)) {
out_edge entry = cur_loop_outs[i];
ir_node *node = entry.node;
ir_node *pred = get_irn_n(entry.node, entry.pred_irn_n);
if (!is_Block(node) && !is_End(node)) {
- DB((dbg, LEVEL_
1, " construct_ssa_n def %ld node %ld
pos %d\n",
-
get_irn_node_nr(pred), get_irn_node_nr(node)
, entry.pred_irn_n));
+ DB((dbg, LEVEL_
5, " construct_ssa_n def %N node %N
pos %d\n",
+
pred, node
, entry.pred_irn_n));
construct_ssa_n(pred, node);
}
}
construct_ssa_n(pred, node);
}
}
+#endif
DEL_ARR_F(cur_loop_outs);
DEL_ARR_F(cur_loop_outs);
@@
-1383,7
+1395,7
@@
static void init_analyze(ir_loop *loop)
loop_info.loads = 0;
loop_info.blocks = 0;
loop_info.loads = 0;
loop_info.blocks = 0;
- DB((dbg, LEVEL_2, " >>>> current loop includes node %
ld <<<\n", get_irn_node_nr(get_loop_node(loop, 0)
)));
+ DB((dbg, LEVEL_2, " >>>> current loop includes node %
N <<<\n", get_loop_node(loop, 0
)));
irg_walk_graph(current_ir_graph, get_loop_info, NULL, NULL);
irg_walk_graph(current_ir_graph, get_loop_info, NULL, NULL);
@@
-1407,7
+1419,7
@@
static void init_analyze(ir_loop *loop)
return;
#endif
return;
#endif
- DB((dbg, LEVEL_2, " <<<< end of loop with node %
ld >>>>\n", get_irn_node_nr(get_loop_node(loop, 0)
)));
+ DB((dbg, LEVEL_2, " <<<< end of loop with node %
N >>>>\n", get_loop_node(loop, 0
)));
}
/* Find most inner loops and send them to analyze_loop */
}
/* Find most inner loops and send them to analyze_loop */
@@
-1434,7
+1446,7
@@
static void find_most_inner_loop(ir_loop *loop)
}
} else {
int s;
}
} else {
int s;
- for(s=0; s<sons; s++) {
+ for
(s=0; s<sons; s++) {
find_most_inner_loop(get_loop_son(loop, s));
}
}
find_most_inner_loop(get_loop_son(loop, s));
}
}
@@
-1542,13
+1554,13
@@
void do_loop_unrolling(ir_graph *irg)
enable_peeling = 0;
enable_inversion = 0;
enable_peeling = 0;
enable_inversion = 0;
- DB((dbg, LEVEL_2, " >>> unrolling (Startnode %
ld
) <<<\n",
- get_ir
n_node_nr(get_irg_start(irg)
)));
+ DB((dbg, LEVEL_2, " >>> unrolling (Startnode %
N
) <<<\n",
+ get_ir
g_start(irg
)));
loop_optimization(irg);
loop_optimization(irg);
- DB((dbg, LEVEL_2, " >>> unrolling done (Startnode %
ld
) <<<\n",
- get_ir
n_node_nr(get_irg_start(irg)
)));
+ DB((dbg, LEVEL_2, " >>> unrolling done (Startnode %
N
) <<<\n",
+ get_ir
g_start(irg
)));
}
void do_loop_inversion(ir_graph *irg)
}
void do_loop_inversion(ir_graph *irg)
@@
-1557,13
+1569,13
@@
void do_loop_inversion(ir_graph *irg)
enable_peeling = 0;
enable_inversion = 1;
enable_peeling = 0;
enable_inversion = 1;
- DB((dbg, LEVEL_2, " >>> inversion (Startnode %
ld
) <<<\n",
- get_ir
n_node_nr(get_irg_start(irg)
)));
+ DB((dbg, LEVEL_2, " >>> inversion (Startnode %
N
) <<<\n",
+ get_ir
g_start(irg
)));
loop_optimization(irg);
loop_optimization(irg);
- DB((dbg, LEVEL_2, " >>> inversion done (Startnode %
ld
) <<<\n",
- get_ir
n_node_nr(get_irg_start(irg)
)));
+ DB((dbg, LEVEL_2, " >>> inversion done (Startnode %
N
) <<<\n",
+ get_ir
g_start(irg
)));
}
void do_loop_peeling(ir_graph *irg)
}
void do_loop_peeling(ir_graph *irg)
@@
-1572,25
+1584,28
@@
void do_loop_peeling(ir_graph *irg)
enable_peeling = 1;
enable_inversion = 0;
enable_peeling = 1;
enable_inversion = 0;
- DB((dbg, LEVEL_2, " >>> peeling (Startnode %
ld
) <<<\n",
- get_ir
n_node_nr(get_irg_start(irg)
)));
+ DB((dbg, LEVEL_2, " >>> peeling (Startnode %
N
) <<<\n",
+ get_ir
g_start(irg
)));
loop_optimization(irg);
loop_optimization(irg);
- DB((dbg, LEVEL_2, " >>> peeling done (Startnode %
ld
) <<<\n",
- get_ir
n_node_nr(get_irg_start(irg)
)));
+ DB((dbg, LEVEL_2, " >>> peeling done (Startnode %
N
) <<<\n",
+ get_ir
g_start(irg
)));
}
}
-ir_graph_pass_t *loop_inversion_pass(const char *name) {
+ir_graph_pass_t *loop_inversion_pass(const char *name)
+{
return def_graph_pass(name ? name : "loop_inversion", do_loop_inversion);
}
return def_graph_pass(name ? name : "loop_inversion", do_loop_inversion);
}
-ir_graph_pass_t *loop_unroll_pass(const char *name) {
+ir_graph_pass_t *loop_unroll_pass(const char *name)
+{
return def_graph_pass(name ? name : "loop_unroll", do_loop_unrolling);
}
return def_graph_pass(name ? name : "loop_unroll", do_loop_unrolling);
}
-ir_graph_pass_t *loop_peeling_pass(const char *name) {
+ir_graph_pass_t *loop_peeling_pass(const char *name)
+{
return def_graph_pass(name ? name : "loop_peeling", do_loop_peeling);
}
return def_graph_pass(name ? name : "loop_peeling", do_loop_peeling);
}