OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

re PR middle-end/54146 (Very slow compile with attribute((flatten)))

Browse Source 
2012-08-14  Richard Guenther  <rguenther@suse.de>

	PR tree-optimization/54146
	* tree-ssa-pre.c (do_regular_insertion): Use a VEC
	indexed by pred edge index for avail.
	(do_partial_partial_insertion): Likewise.
	(insert_into_preds_of_block): Adjust.

From-SVN: r190382
This commit is contained in:
Richard Guenther 2012-08-14 12:38:32 +00:00 committed by Richard Biener
parent 2ad728d272
commit 1c8f737738
2 changed files with 38 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gcc/ChangeLog
View File

@ -1,3 +1,11 @@
2012-08-14 Richard Guenther <rguenther@suse.de>
PR tree-optimization/54146
* tree-ssa-pre.c (do_regular_insertion): Use a VEC
indexed by pred edge index for avail.
(do_partial_partial_insertion): Likewise.
(insert_into_preds_of_block): Adjust.
2012-08-14 Richard Guenther <rguenther@suse.de>
* gimplify.c (create_tmp_from_val): Mark temporary with

59
gcc/tree-ssa-pre.c
View File

@ -3188,7 +3188,7 @@ inhibit_phi_insertion (basic_block bb, pre_expr expr)
static bool
insert_into_preds_of_block (basic_block block, unsigned int exprnum,
pre_expr *avail)
VEC(pre_expr, heap) *avail)
{
pre_expr expr = expression_for_id (exprnum);
pre_expr newphi;
@ -3229,7 +3229,7 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
gimple_seq stmts = NULL;
tree builtexpr;
bprime = pred->src;
eprime = avail[bprime->index];
eprime = VEC_index (pre_expr, avail, pred->dest_idx);
if (eprime->kind != NAME && eprime->kind != CONSTANT)
{
@ -3239,14 +3239,14 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
type);
gcc_assert (!(pred->flags & EDGE_ABNORMAL));
gsi_insert_seq_on_edge (pred, stmts);
avail[bprime->index] = get_or_alloc_expr_for_name (builtexpr);
VEC_replace (pre_expr, avail, pred->dest_idx,
get_or_alloc_expr_for_name (builtexpr));
insertions = true;
}
else if (eprime->kind == CONSTANT)
{
/* Constants may not have the right type, fold_convert
should give us back a constant with the right type.
*/
should give us back a constant with the right type. */
tree constant = PRE_EXPR_CONSTANT (eprime);
if (!useless_type_conversion_p (type, TREE_TYPE (constant)))
{
@ -3278,11 +3278,13 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
}
gsi_insert_seq_on_edge (pred, stmts);
}
avail[bprime->index] = get_or_alloc_expr_for_name (forcedexpr);
VEC_replace (pre_expr, avail, pred->dest_idx,
get_or_alloc_expr_for_name (forcedexpr));
}
}
else
avail[bprime->index] = get_or_alloc_expr_for_constant (builtexpr);
VEC_replace (pre_expr, avail, pred->dest_idx,
get_or_alloc_expr_for_constant (builtexpr));
}
}
else if (eprime->kind == NAME)
@ -3321,7 +3323,8 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
}
gsi_insert_seq_on_edge (pred, stmts);
}
avail[bprime->index] = get_or_alloc_expr_for_name (forcedexpr);
VEC_replace (pre_expr, avail, pred->dest_idx,
get_or_alloc_expr_for_name (forcedexpr));
}
}
}
@ -3344,14 +3347,13 @@ insert_into_preds_of_block (basic_block block, unsigned int exprnum,
bitmap_set_bit (inserted_exprs, SSA_NAME_VERSION (gimple_phi_result (phi)));
FOR_EACH_EDGE (pred, ei, block->preds)
{
pre_expr ae = avail[pred->src->index];
pre_expr ae = VEC_index (pre_expr, avail, pred->dest_idx);
gcc_assert (get_expr_type (ae) == type
|| useless_type_conversion_p (type, get_expr_type (ae)));
if (ae->kind == CONSTANT)
add_phi_arg (phi, PRE_EXPR_CONSTANT (ae), pred, UNKNOWN_LOCATION);
else
add_phi_arg (phi, PRE_EXPR_NAME (avail[pred->src->index]), pred,
UNKNOWN_LOCATION);
add_phi_arg (phi, PRE_EXPR_NAME (ae), pred, UNKNOWN_LOCATION);
}
newphi = get_or_alloc_expr_for_name (gimple_phi_result (phi));
@ -3411,15 +3413,18 @@ static bool
do_regular_insertion (basic_block block, basic_block dom)
{
bool new_stuff = false;
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (ANTIC_IN (block));
VEC (pre_expr, heap) *exprs;
pre_expr expr;
VEC (pre_expr, heap) *avail = NULL;
int i;
exprs = sorted_array_from_bitmap_set (ANTIC_IN (block));
VEC_safe_grow (pre_expr, heap, avail, EDGE_COUNT (block->preds));
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
{
if (expr->kind != NAME)
{
pre_expr *avail;
unsigned int val;
bool by_some = false;
bool cant_insert = false;
@ -3442,10 +3447,6 @@ do_regular_insertion (basic_block block, basic_block dom)
continue;
}
/* FIXME: This costs N_EXPR*N_BASIC_BLOCKS. Should use
a less costly data structure for avail (e.g. a VEC
indexed by edge index). */
avail = XCNEWVEC (pre_expr, last_basic_block);
FOR_EACH_EDGE (pred, ei, block->preds)
{
unsigned int vprime;
@ -3468,6 +3469,7 @@ do_regular_insertion (basic_block block, basic_block dom)
rest of the results are. */
if (eprime == NULL)
{
VEC_replace (pre_expr, avail, pred->dest_idx, NULL);
cant_insert = true;
break;
}
@ -3478,12 +3480,12 @@ do_regular_insertion (basic_block block, basic_block dom)
vprime, NULL);
if (edoubleprime == NULL)
{
avail[bprime->index] = eprime;
VEC_replace (pre_expr, avail, pred->dest_idx, eprime);
all_same = false;
}
else
{
avail[bprime->index] = edoubleprime;
VEC_replace (pre_expr, avail, pred->dest_idx, edoubleprime);
by_some = true;
/* We want to perform insertions to remove a redundancy on
a path in the CFG we want to optimize for speed. */
@ -3562,11 +3564,11 @@ do_regular_insertion (basic_block block, basic_block dom)
}
}
}
free (avail);
}
}
VEC_free (pre_expr, heap, exprs);
VEC_free (pre_expr, heap, avail);
return new_stuff;
}
@ -3582,15 +3584,18 @@ static bool
do_partial_partial_insertion (basic_block block, basic_block dom)
{
bool new_stuff = false;
VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (PA_IN (block));
VEC (pre_expr, heap) *exprs;
pre_expr expr;
VEC (pre_expr, heap) *avail = NULL;
int i;
exprs = sorted_array_from_bitmap_set (PA_IN (block));
VEC_safe_grow (pre_expr, heap, avail, EDGE_COUNT (block->preds));
FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
{
if (expr->kind != NAME)
{
pre_expr *avail;
unsigned int val;
bool by_all = true;
bool cant_insert = false;
@ -3605,10 +3610,6 @@ do_partial_partial_insertion (basic_block block, basic_block dom)
if (bitmap_set_contains_value (AVAIL_OUT (dom), val))
continue;
/* FIXME: This costs N_EXPR*N_BASIC_BLOCKS. Should use
a less costly data structure for avail (e.g. a VEC
indexed by edge index). */
avail = XCNEWVEC (pre_expr, last_basic_block);
FOR_EACH_EDGE (pred, ei, block->preds)
{
unsigned int vprime;
@ -3633,6 +3634,7 @@ do_partial_partial_insertion (basic_block block, basic_block dom)
rest of the results are. */
if (eprime == NULL)
{
VEC_replace (pre_expr, avail, pred->dest_idx, NULL);
cant_insert = true;
break;
}
@ -3641,13 +3643,12 @@ do_partial_partial_insertion (basic_block block, basic_block dom)
vprime = get_expr_value_id (eprime);
edoubleprime = bitmap_find_leader (AVAIL_OUT (bprime),
vprime, NULL);
VEC_replace (pre_expr, avail, pred->dest_idx, edoubleprime);
if (edoubleprime == NULL)
{
by_all = false;
break;
}
else
avail[bprime->index] = edoubleprime;
}
/* If we can insert it, it's not the same value
@ -3701,11 +3702,11 @@ do_partial_partial_insertion (basic_block block, basic_block dom)
new_stuff = true;
}
}
free (avail);
}
}
VEC_free (pre_expr, heap, exprs);
VEC_free (pre_expr, heap, avail);
return new_stuff;
}