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

Remove expand_scalar_variables_ hack.

Browse Source 
2010-07-15  Sebastian Pop  <sebastian.pop@amd.com>

	* graphite-clast-to-gimple.c (debug_clast_name_index): Removed.
	(debug_clast_name_indexes_1): Removed.
	(debug_clast_name_indexes): Removed.
	(pbb_to_depth_to_oldiv): Removed.
	(build_iv_mapping): Replace the use of rename_map with iv_map.
	(translate_clast_user): Remove uses of rename_map.  Allocate and
	free iv_map.
	(translate_clast_for_loop): Remove uses of rename_map.
	(translate_clast_for): Same.
	(translate_clast_guard): Same.
	(translate_clast): Same.
	(gloog): Same.
	* graphite-clast-to-gimple.h (debug_clast_name_indexes): Removed.
	* graphite-sese-to-poly.c (scev_analyzable_p): Moved...
	* sese.c (set_rename): Now static.
	(rename_variables_in_stmt): Removed.
	(rename_uses): New.
	(is_parameter): Removed.
	(is_iv): Removed.
	(expand_scalar_variables_call): Removed.
	(expand_scalar_variables_ssa_name): Removed.
	(expand_scalar_variables_expr): Removed.
	(expand_scalar_variables_stmt): Removed.
	(expand_scalar_variables): Removed.
	(rename_variables): Removed.
	(remove_condition): Removed.
	(get_true_edge_from_guard_bb): Removed.
	(get_false_edge_from_guard_bb): Removed.
	(struct igp): Removed.
	(default_before_guard): Removed.
	(convert_for_phi_arg): Removed.
	(add_guard_exit_phis): Removed.
	(insert_guard_phis): Removed.
	(graphite_copy_stmts_from_block): Now also uses iv_map and a
	region.  Do not copy conditions.  Do not copy induction variables.
	Call rename_uses.
	(copy_bb_and_scalar_dependences): Allocate a local rename_map for
	the translated statement.  Use the iv_map for the induction
	variable renaming.
	* sese.h (copy_bb_and_scalar_dependences): Update declaration.
	(set_rename): Removed declaration.
	(scev_analyzable_p): ...here.
	* tree-chrec.c (chrec_apply_map): New.
	* tree-chrec.h (chrec_apply_map): Declared.

From-SVN: r163139
This commit is contained in:
Sebastian Pop 2010-08-11 20:27:19 +00:00 committed by Sebastian Pop
parent e11d25e019
commit 2e286fd2f9
9 changed files with 321 additions and 685 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
gcc/ChangeLog
View File

@ -1,3 +1,50 @@
2010-08-02 Sebastian Pop <sebastian.pop@amd.com>
* graphite-clast-to-gimple.c (debug_clast_name_index): Removed.
(debug_clast_name_indexes_1): Removed.
(debug_clast_name_indexes): Removed.
(pbb_to_depth_to_oldiv): Removed.
(build_iv_mapping): Replace the use of rename_map with iv_map.
(translate_clast_user): Remove uses of rename_map. Allocate and
free iv_map.
(translate_clast_for_loop): Remove uses of rename_map.
(translate_clast_for): Same.
(translate_clast_guard): Same.
(translate_clast): Same.
(gloog): Same.
* graphite-clast-to-gimple.h (debug_clast_name_indexes): Removed.
* graphite-sese-to-poly.c (scev_analyzable_p): Moved...
* sese.c (set_rename): Now static.
(rename_variables_in_stmt): Removed.
(rename_uses): New.
(is_parameter): Removed.
(is_iv): Removed.
(expand_scalar_variables_call): Removed.
(expand_scalar_variables_ssa_name): Removed.
(expand_scalar_variables_expr): Removed.
(expand_scalar_variables_stmt): Removed.
(expand_scalar_variables): Removed.
(rename_variables): Removed.
(remove_condition): Removed.
(get_true_edge_from_guard_bb): Removed.
(get_false_edge_from_guard_bb): Removed.
(struct igp): Removed.
(default_before_guard): Removed.
(convert_for_phi_arg): Removed.
(add_guard_exit_phis): Removed.
(insert_guard_phis): Removed.
(graphite_copy_stmts_from_block): Now also uses iv_map and a
region. Do not copy conditions. Do not copy induction variables.
Call rename_uses.
(copy_bb_and_scalar_dependences): Allocate a local rename_map for
the translated statement. Use the iv_map for the induction
variable renaming.
* sese.h (copy_bb_and_scalar_dependences): Update declaration.
(set_rename): Removed declaration.
(scev_analyzable_p): ...here.
* tree-chrec.c (chrec_apply_map): New.
* tree-chrec.h (chrec_apply_map): Declared.
2010-08-02 Sebastian Pop <sebastian.pop@amd.com>
* graphite-clast-to-gimple.c (translate_clast_for_loop): Do not call

47
gcc/ChangeLog.graphite
View File

@ -1,3 +1,50 @@
2010-07-15 Sebastian Pop <sebastian.pop@amd.com>
* graphite-clast-to-gimple.c (debug_clast_name_index): Removed.
(debug_clast_name_indexes_1): Removed.
(debug_clast_name_indexes): Removed.
(pbb_to_depth_to_oldiv): Removed.
(build_iv_mapping): Replace the use of rename_map with iv_map.
(translate_clast_user): Remove uses of rename_map. Allocate and
free iv_map.
(translate_clast_for_loop): Remove uses of rename_map.
(translate_clast_for): Same.
(translate_clast_guard): Same.
(translate_clast): Same.
(gloog): Same.
* graphite-clast-to-gimple.h (debug_clast_name_indexes): Removed.
* graphite-sese-to-poly.c (scev_analyzable_p): Moved...
* sese.c (set_rename): Now static.
(rename_variables_in_stmt): Removed.
(rename_uses): New.
(is_parameter): Removed.
(is_iv): Removed.
(expand_scalar_variables_call): Removed.
(expand_scalar_variables_ssa_name): Removed.
(expand_scalar_variables_expr): Removed.
(expand_scalar_variables_stmt): Removed.
(expand_scalar_variables): Removed.
(rename_variables): Removed.
(remove_condition): Removed.
(get_true_edge_from_guard_bb): Removed.
(get_false_edge_from_guard_bb): Removed.
(struct igp): Removed.
(default_before_guard): Removed.
(convert_for_phi_arg): Removed.
(add_guard_exit_phis): Removed.
(insert_guard_phis): Removed.
(graphite_copy_stmts_from_block): Now also uses iv_map and a
region. Do not copy conditions. Do not copy induction variables.
Call rename_uses.
(copy_bb_and_scalar_dependences): Allocate a local rename_map for
the translated statement. Use the iv_map for the induction
variable renaming.
* sese.h (copy_bb_and_scalar_dependences): Update declaration.
(set_rename): Removed declaration.
(scev_analyzable_p): ...here.
* tree-chrec.c (chrec_apply_map): New.
* tree-chrec.h (chrec_apply_map): Declared.
2010-07-15 Sebastian Pop <sebastian.pop@amd.com>
* graphite-clast-to-gimple.c (translate_clast_for_loop): Do not call

129
gcc/graphite-clast-to-gimple.c
View File

@ -130,32 +130,6 @@ save_clast_name_index (htab_t index_table, const char *name, int index)
}
}
/* Print to stderr the element ELT. */
static inline void
debug_clast_name_index (clast_name_index_p elt)
{
fprintf (stderr, "(index = %d, name = %s)\n", elt->index, elt->name);
}
/* Helper function for debug_rename_map. */
static inline int
debug_clast_name_indexes_1 (void **slot, void *s ATTRIBUTE_UNUSED)
{
struct clast_name_index *entry = (struct clast_name_index *) *slot;
debug_clast_name_index (entry);
return 1;
}
/* Print to stderr all the elements of MAP. */
DEBUG_FUNCTION void
debug_clast_name_indexes (htab_t map)
{
htab_traverse (map, debug_clast_name_indexes_1, NULL);
}
/* Computes a hash function for database element ELT. */
static inline hashval_t
@ -175,20 +149,6 @@ eq_clast_name_indexes (const void *e1, const void *e2)
return (elt1->name == elt2->name);
}
/* For a given loop DEPTH in the loop nest of the original black box
PBB, return the old induction variable associated to that loop. */
static inline tree
pbb_to_depth_to_oldiv (poly_bb_p pbb, int depth)
{
gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
sese region = SCOP_REGION (PBB_SCOP (pbb));
loop_p loop = gbb_loop_at_index (gbb, region, depth);
return loop->single_iv;
}
/* For a given scattering dimension, return the new induction variable
associated to it. */
@ -820,34 +780,36 @@ graphite_create_new_loop (sese region, edge entry_edge,
return loop;
}
/* Inserts in RENAME_MAP a tuple (OLD_NAME, NEW_NAME) for the induction
variables of the loops around GBB in SESE. */
/* Inserts in iv_map a tuple (OLD_LOOP->num, NEW_NAME) for the
induction variables of the loops around GBB in SESE. */
static void
build_iv_mapping (htab_t rename_map, sese region,
build_iv_mapping (VEC (tree, heap) *iv_map, sese region,
VEC (tree, heap) *newivs, htab_t newivs_index,
struct clast_user_stmt *user_stmt,
htab_t params_index)
{
struct clast_stmt *t;
int index = 0;
int depth = 0;
CloogStatement *cs = user_stmt->statement;
poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (cs);
gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
for (t = user_stmt->substitutions; t; t = t->next, index++)
for (t = user_stmt->substitutions; t; t = t->next, depth++)
{
struct clast_expr *expr = (struct clast_expr *)
((struct clast_assignment *)t)->RHS;
tree type = gcc_type_for_clast_expr (expr, region, newivs,
newivs_index, params_index);
tree old_name = pbb_to_depth_to_oldiv (pbb, index);
tree e = clast_to_gcc_expression (type, expr, region, newivs,
newivs_index, params_index);
set_rename (rename_map, old_name, e);
tree new_name = clast_to_gcc_expression (type, expr, region, newivs,
newivs_index, params_index);
loop_p old_loop = gbb_loop_at_index (gbb, region, depth);
VEC_replace (tree, iv_map, old_loop->num, new_name);
}
}
/* Construct bb_pbb_def with BB and PBB. */
/* Construct bb_pbb_def with BB and PBB. */
static bb_pbb_def *
new_bb_pbb_def (basic_block bb, poly_bb_p pbb)
@ -930,38 +892,39 @@ dependency_in_loop_p (loop_p loop, htab_t bb_pbb_mapping, int level)
return false;
}
static edge
translate_clast (sese, loop_p, struct clast_stmt *, edge, htab_t,
VEC (tree, heap) **, htab_t, htab_t, int, htab_t);
/* Translates a clast user statement STMT to gimple.
- REGION is the sese region we used to generate the scop.
- NEXT_E is the edge where new generated code should be attached.
- CONTEXT_LOOP is the loop in which the generated code will be placed
- RENAME_MAP contains a set of tuples of new names associated to
the original variables names.
- BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.
- PARAMS_INDEX connects the cloog parameters with the gimple parameters in
the sese region. */
static edge
translate_clast_user (sese region, struct clast_user_stmt *stmt, edge next_e,
htab_t rename_map, VEC (tree, heap) **newivs,
VEC (tree, heap) **newivs,
htab_t newivs_index, htab_t bb_pbb_mapping,
htab_t params_index)
{
gimple_bb_p gbb;
int i, nb_loops;
basic_block new_bb;
poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (stmt->statement);
gbb = PBB_BLACK_BOX (pbb);
gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
VEC (tree, heap) *iv_map;
if (GBB_BB (gbb) == ENTRY_BLOCK_PTR)
return next_e;
build_iv_mapping (rename_map, region, *newivs, newivs_index, stmt,
params_index);
nb_loops = number_of_loops ();
iv_map = VEC_alloc (tree, heap, nb_loops);
for (i = 0; i < nb_loops; i++)
VEC_quick_push (tree, iv_map, NULL_TREE);
build_iv_mapping (iv_map, region, *newivs, newivs_index, stmt, params_index);
next_e = copy_bb_and_scalar_dependences (GBB_BB (gbb), region,
next_e, rename_map);
next_e, iv_map);
VEC_free (tree, heap, iv_map);
new_bb = next_e->src;
mark_bb_with_pbb (pbb, new_bb, bb_pbb_mapping);
update_ssa (TODO_update_ssa);
@ -1009,20 +972,21 @@ graphite_create_new_loop_guard (sese region, edge entry_edge,
return exit_edge;
}
static edge
translate_clast (sese, loop_p, struct clast_stmt *, edge,
VEC (tree, heap) **, htab_t, htab_t, int, htab_t);
/* Create the loop for a clast for statement.
- REGION is the sese region we used to generate the scop.
- NEXT_E is the edge where new generated code should be attached.
- RENAME_MAP contains a set of tuples of new names associated to
the original variables names.
- BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.
- PARAMS_INDEX connects the cloog parameters with the gimple parameters in
the sese region. */
static edge
translate_clast_for_loop (sese region, loop_p context_loop,
struct clast_for *stmt, edge next_e,
htab_t rename_map, VEC (tree, heap) **newivs,
VEC (tree, heap) **newivs,
htab_t newivs_index, htab_t bb_pbb_mapping,
int level, htab_t params_index)
{
@ -1038,7 +1002,7 @@ translate_clast_for_loop (sese region, loop_p context_loop,
last_e = single_succ_edge (split_edge (last_e));
/* Translate the body of the loop. */
next_e = translate_clast (region, loop, stmt->body, to_body, rename_map,
next_e = translate_clast (region, loop, stmt->body, to_body,
newivs, newivs_index, bb_pbb_mapping, level + 1,
params_index);
redirect_edge_succ_nodup (next_e, after);
@ -1058,14 +1022,12 @@ translate_clast_for_loop (sese region, loop_p context_loop,
- REGION is the sese region we used to generate the scop.
- NEXT_E is the edge where new generated code should be attached.
- RENAME_MAP contains a set of tuples of new names associated to
the original variables names.
- BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.
- PARAMS_INDEX connects the cloog parameters with the gimple parameters in
the sese region. */
static edge
translate_clast_for (sese region, loop_p context_loop, struct clast_for *stmt,
edge next_e, htab_t rename_map, VEC (tree, heap) **newivs,
edge next_e, VEC (tree, heap) **newivs,
htab_t newivs_index, htab_t bb_pbb_mapping, int level,
htab_t params_index)
{
@ -1073,8 +1035,7 @@ translate_clast_for (sese region, loop_p context_loop, struct clast_for *stmt,
newivs_index, params_index);
edge true_e = get_true_edge_from_guard_bb (next_e->dest);
translate_clast_for_loop (region, context_loop, stmt, true_e,
rename_map, newivs,
translate_clast_for_loop (region, context_loop, stmt, true_e, newivs,
newivs_index, bb_pbb_mapping, level,
params_index);
return last_e;
@ -1085,15 +1046,13 @@ translate_clast_for (sese region, loop_p context_loop, struct clast_for *stmt,
- REGION is the sese region we used to generate the scop.
- NEXT_E is the edge where new generated code should be attached.
- CONTEXT_LOOP is the loop in which the generated code will be placed
- RENAME_MAP contains a set of tuples of new names associated to
the original variables names.
- BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping.
- PARAMS_INDEX connects the cloog parameters with the gimple parameters in
the sese region. */
static edge
translate_clast_guard (sese region, loop_p context_loop,
struct clast_guard *stmt, edge next_e,
htab_t rename_map, VEC (tree, heap) **newivs,
VEC (tree, heap) **newivs,
htab_t newivs_index, htab_t bb_pbb_mapping, int level,
htab_t params_index)
{
@ -1102,7 +1061,7 @@ translate_clast_guard (sese region, loop_p context_loop,
edge true_e = get_true_edge_from_guard_bb (next_e->dest);
translate_clast (region, context_loop, stmt->then, true_e,
rename_map, newivs, newivs_index, bb_pbb_mapping,
newivs, newivs_index, bb_pbb_mapping,
level, params_index);
return last_e;
}
@ -1112,12 +1071,10 @@ translate_clast_guard (sese region, loop_p context_loop,
- NEXT_E is the edge where new generated code should be attached.
- CONTEXT_LOOP is the loop in which the generated code will be placed
- RENAME_MAP contains a set of tuples of new names associated to
the original variables names.
- BB_PBB_MAPPING is is a basic_block and it's related poly_bb_p mapping. */
static edge
translate_clast (sese region, loop_p context_loop, struct clast_stmt *stmt,
edge next_e, htab_t rename_map, VEC (tree, heap) **newivs,
edge next_e, VEC (tree, heap) **newivs,
htab_t newivs_index, htab_t bb_pbb_mapping, int level,
htab_t params_index)
{
@ -1129,25 +1086,25 @@ translate_clast (sese region, loop_p context_loop, struct clast_stmt *stmt,
else if (CLAST_STMT_IS_A (stmt, stmt_user))
next_e = translate_clast_user (region, (struct clast_user_stmt *) stmt,
next_e, rename_map, newivs, newivs_index,
next_e, newivs, newivs_index,
bb_pbb_mapping, params_index);
else if (CLAST_STMT_IS_A (stmt, stmt_for))
next_e = translate_clast_for (region, context_loop,
(struct clast_for *) stmt, next_e,
rename_map, newivs, newivs_index,
newivs, newivs_index,
bb_pbb_mapping, level, params_index);
else if (CLAST_STMT_IS_A (stmt, stmt_guard))
next_e = translate_clast_guard (region, context_loop,
(struct clast_guard *) stmt, next_e,
rename_map, newivs, newivs_index,
newivs, newivs_index,
bb_pbb_mapping, level, params_index);
else if (CLAST_STMT_IS_A (stmt, stmt_block))
next_e = translate_clast (region, context_loop,
((struct clast_block *) stmt)->body,
next_e, rename_map, newivs, newivs_index,
next_e, newivs, newivs_index,
bb_pbb_mapping, level, params_index);
else
gcc_unreachable();
@ -1156,7 +1113,7 @@ translate_clast (sese region, loop_p context_loop, struct clast_stmt *stmt,
graphite_verify ();
return translate_clast (region, context_loop, stmt->next, next_e,
rename_map, newivs, newivs_index,
newivs, newivs_index,
bb_pbb_mapping, level, params_index);
}
@ -1483,7 +1440,7 @@ gloog (scop_p scop, htab_t bb_pbb_mapping)
loop_p context_loop;
sese region = SCOP_REGION (scop);
ifsese if_region = NULL;
htab_t rename_map, newivs_index, params_index;
htab_t newivs_index, params_index;
cloog_prog_clast pc;
timevar_push (TV_GRAPHITE_CODE_GEN);
@ -1510,7 +1467,6 @@ gloog (scop_p scop, htab_t bb_pbb_mapping)
graphite_verify ();
context_loop = SESE_ENTRY (region)->src->loop_father;
rename_map = htab_create (10, rename_map_elt_info, eq_rename_map_elts, free);
newivs_index = htab_create (10, clast_name_index_elt_info,
eq_clast_name_indexes, free);
params_index = htab_create (10, clast_name_index_elt_info,
@ -1520,7 +1476,7 @@ gloog (scop_p scop, htab_t bb_pbb_mapping)
translate_clast (region, context_loop, pc.stmt,
if_region->true_region->entry,
rename_map, &newivs, newivs_index,
&newivs, newivs_index,
bb_pbb_mapping, 1, params_index);
graphite_verify ();
scev_reset_htab ();
@ -1534,7 +1490,6 @@ gloog (scop_p scop, htab_t bb_pbb_mapping)
free (if_region->region);
free (if_region);
htab_delete (rename_map);
htab_delete (newivs_index);
htab_delete (params_index);
VEC_free (tree, heap, newivs);

1
gcc/graphite-clast-to-gimple.h
View File

@ -40,7 +40,6 @@ extern bool gloog (scop_p, htab_t);
extern cloog_prog_clast scop_to_clast (scop_p);
extern void debug_clast_stmt (struct clast_stmt *);
extern void print_clast_stmt (FILE *, struct clast_stmt *);
extern void debug_clast_name_indexes (htab_t);
/* Hash function for data base element BB_PBB. */

14
gcc/graphite-sese-to-poly.c
View File

@ -2333,20 +2333,6 @@ rewrite_reductions_out_of_ssa (scop_p scop)
#endif
}
/* Return true when DEF can be analyzed in REGION by the scalar
evolution analyzer. */
static bool
scev_analyzable_p (tree def, sese region)
{
gimple stmt = SSA_NAME_DEF_STMT (def);
loop_p loop = loop_containing_stmt (stmt);
tree scev = scalar_evolution_in_region (region, loop, def);
return !chrec_contains_undetermined (scev)
&& TREE_CODE (scev) != SSA_NAME;
}
/* Rewrite the scalar dependence of DEF used in USE_STMT with a memory
read from ZERO_DIM_ARRAY. */

731
gcc/sese.c
View File

@ -394,468 +394,6 @@ sese_insert_phis_for_liveouts (sese region, basic_block bb,
update_ssa (TODO_update_ssa);
}
/* Returns the expression associated to OLD_NAME in RENAME_MAP. */
static tree
get_rename (htab_t rename_map, tree old_name)
{
struct rename_map_elt_s tmp;
PTR *slot;
gcc_assert (TREE_CODE (old_name) == SSA_NAME);
tmp.old_name = old_name;
slot = htab_find_slot (rename_map, &tmp, NO_INSERT);
if (slot && *slot)
return ((rename_map_elt) *slot)->expr;
return old_name;
}
/* Register in RENAME_MAP the rename tuple (OLD_NAME, EXPR). */
void
set_rename (htab_t rename_map, tree old_name, tree expr)
{
struct rename_map_elt_s tmp;
PTR *slot;
if (old_name == expr)
return;
tmp.old_name = old_name;
slot = htab_find_slot (rename_map, &tmp, INSERT);
if (!slot)
return;
if (*slot)
free (*slot);
*slot = new_rename_map_elt (old_name, expr);
}
/* Rename the SSA_NAMEs used in STMT and that appear in RENAME_MAP. */
static void
rename_variables_in_stmt (gimple stmt, htab_t rename_map, gimple_stmt_iterator *insert_gsi)
{
ssa_op_iter iter;
use_operand_p use_p;
FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
{
tree use = USE_FROM_PTR (use_p);
tree expr, type_use, type_expr;
gimple_seq stmts;
if (TREE_CODE (use) != SSA_NAME)
continue;
expr = get_rename (rename_map, use);
if (use == expr)
continue;
type_use = TREE_TYPE (use);
type_expr = TREE_TYPE (expr);
if (type_use != type_expr
|| (TREE_CODE (expr) != SSA_NAME
&& is_gimple_reg (use)))
{
tree var;
if (is_gimple_debug (stmt))
{
if (gimple_debug_bind_p (stmt))
gimple_debug_bind_reset_value (stmt);
else
gcc_unreachable ();
break;
}
var = create_tmp_var (type_use, "var");
if (type_use != type_expr)
expr = fold_convert (type_use, expr);
expr = build2 (MODIFY_EXPR, type_use, var, expr);
expr = force_gimple_operand (expr, &stmts, true, NULL);
gsi_insert_seq_before (insert_gsi, stmts, GSI_SAME_STMT);
}
replace_exp (use_p, expr);
}
update_stmt (stmt);
}
/* Returns true if NAME is a parameter of SESE. */
static bool
is_parameter (sese region, tree name)
{
int i;
tree p;
for (i = 0; VEC_iterate (tree, SESE_PARAMS (region), i, p); i++)
if (p == name)
return true;
return false;
}
/* Returns true if NAME is an induction variable. */
static bool
is_iv (tree name)
{
return gimple_code (SSA_NAME_DEF_STMT (name)) == GIMPLE_PHI;
}
static void expand_scalar_variables_stmt (gimple, basic_block, sese,
htab_t, gimple_stmt_iterator *);
static tree
expand_scalar_variables_expr (tree, tree, enum tree_code, tree, basic_block,
sese, htab_t, gimple_stmt_iterator *);
static tree
expand_scalar_variables_call (gimple stmt, basic_block bb, sese region,
htab_t rename_map, gimple_stmt_iterator *gsi)
{
int i, nargs = gimple_call_num_args (stmt);
VEC (tree, gc) *args = VEC_alloc (tree, gc, nargs);
tree fn_type = TREE_TYPE (gimple_call_fn (stmt));
tree fn = gimple_call_fndecl (stmt);
tree call_expr, var, lhs;
gimple call;
for (i = 0; i < nargs; i++)
{
tree arg = gimple_call_arg (stmt, i);
tree t = TREE_TYPE (arg);
var = create_tmp_var (t, "var");
arg = expand_scalar_variables_expr (t, arg, TREE_CODE (arg), NULL,
bb, region, rename_map, gsi);
arg = build2 (MODIFY_EXPR, t, var, arg);
arg = force_gimple_operand_gsi (gsi, arg, true, NULL,
true, GSI_SAME_STMT);
VEC_quick_push (tree, args, arg);
}
lhs = gimple_call_lhs (stmt);
var = create_tmp_var (TREE_TYPE (lhs), "var");
call_expr = build_call_vec (fn_type, fn, args);
call = gimple_build_call_from_tree (call_expr);
var = make_ssa_name (var, call);
gimple_call_set_lhs (call, var);
gsi_insert_before (gsi, call, GSI_SAME_STMT);
return var;
}
/* Copies at GSI all the scalar computations on which the ssa_name OP0
depends on in the SESE: these are all the scalar variables used in
the definition of OP0, that are defined outside BB and still in the
SESE, i.e. not a parameter of the SESE. The expression that is
returned contains only induction variables from the generated code:
RENAME_MAP contains the induction variables renaming mapping, and is used
to translate the names of induction variables. */
static tree
expand_scalar_variables_ssa_name (tree type, tree op0, basic_block bb,
sese region, htab_t rename_map,
gimple_stmt_iterator *gsi)
{
gimple def_stmt;
tree new_op;
if (is_parameter (region, op0)
|| is_iv (op0))
return fold_convert (type, get_rename (rename_map, op0));
def_stmt = SSA_NAME_DEF_STMT (op0);
/* Check whether we already have a rename for OP0. */
new_op = get_rename (rename_map, op0);
if (new_op != op0
&& gimple_bb (SSA_NAME_DEF_STMT (new_op)) == bb)
return fold_convert (type, new_op);
if (gimple_bb (def_stmt) == bb)
{
/* If the defining statement is in the basic block already
we do not need to create a new expression for it, we
only need to ensure its operands are expanded. */
expand_scalar_variables_stmt (def_stmt, bb, region, rename_map, gsi);
return fold_convert (type, new_op);
}
else
{
if (!gimple_bb (def_stmt)
|| !bb_in_sese_p (gimple_bb (def_stmt), region))
return fold_convert (type, new_op);
switch (gimple_code (def_stmt))
{
case GIMPLE_ASSIGN:
{
tree var0 = gimple_assign_rhs1 (def_stmt);
enum tree_code subcode = gimple_assign_rhs_code (def_stmt);
tree var1 = gimple_assign_rhs2 (def_stmt);
tree type = gimple_expr_type (def_stmt);
return expand_scalar_variables_expr (type, var0, subcode, var1, bb,
region, rename_map, gsi);
}
case GIMPLE_CALL:
return expand_scalar_variables_call (def_stmt, bb, region, rename_map, gsi);
default:
gcc_unreachable ();
return new_op;
}
}
}
/* Copies at GSI all the scalar computations on which the expression
OP0 CODE OP1 depends on in the SESE: these are all the scalar
variables used in OP0 and OP1, defined outside BB and still defined
in the SESE, i.e. not a parameter of the SESE. The expression that
is returned contains only induction variables from the generated
code: RENAME_MAP contains the induction variables renaming mapping, and is
used to translate the names of induction variables. */
static tree
expand_scalar_variables_expr (tree type, tree op0, enum tree_code code,
tree op1, basic_block bb, sese region,
htab_t rename_map, gimple_stmt_iterator *gsi)
{
if (TREE_CODE_CLASS (code) == tcc_constant
|| TREE_CODE_CLASS (code) == tcc_declaration)
return op0;
/* For data references we have to duplicate also its memory
indexing. */
if (TREE_CODE_CLASS (code) == tcc_reference)
{
switch (code)
{
case REALPART_EXPR:
case IMAGPART_EXPR:
{
tree op = TREE_OPERAND (op0, 0);
tree res = expand_scalar_variables_expr
(type, op, TREE_CODE (op), NULL, bb, region, rename_map, gsi);
return build1 (code, type, res);
}
case INDIRECT_REF:
{
tree old_name = TREE_OPERAND (op0, 0);
tree expr = expand_scalar_variables_ssa_name
(type, old_name, bb, region, rename_map, gsi);
if (TREE_CODE (expr) != SSA_NAME
&& is_gimple_reg (old_name))
{
tree type = TREE_TYPE (old_name);
tree var = create_tmp_var (type, "var");
expr = build2 (MODIFY_EXPR, type, var, expr);
expr = force_gimple_operand_gsi (gsi, expr, true, NULL,
true, GSI_SAME_STMT);
}
return fold_build1 (code, type, expr);
}
case ARRAY_REF:
{
tree op00 = TREE_OPERAND (op0, 0);
tree op01 = TREE_OPERAND (op0, 1);
tree op02 = TREE_OPERAND (op0, 2);
tree op03 = TREE_OPERAND (op0, 3);
tree base = expand_scalar_variables_expr
(TREE_TYPE (op00), op00, TREE_CODE (op00), NULL, bb, region,
rename_map, gsi);
tree subscript = expand_scalar_variables_expr
(TREE_TYPE (op01), op01, TREE_CODE (op01), NULL, bb, region,
rename_map, gsi);
return build4 (ARRAY_REF, type, base, subscript, op02, op03);
}
case COMPONENT_REF:
return op0;
default:
/* The above cases should catch everything. */
gcc_unreachable ();
}
}
if (TREE_CODE_CLASS (code) == tcc_unary)
{
tree op0_type = TREE_TYPE (op0);
enum tree_code op0_code = TREE_CODE (op0);
tree op0_expr = expand_scalar_variables_expr (op0_type, op0, op0_code,
NULL, bb, region, rename_map, gsi);
return fold_build1 (code, type, op0_expr);
}
if (TREE_CODE_CLASS (code) == tcc_binary
|| TREE_CODE_CLASS (code) == tcc_comparison)
{
tree op0_type = TREE_TYPE (op0);
enum tree_code op0_code = TREE_CODE (op0);
tree op0_expr = expand_scalar_variables_expr (op0_type, op0, op0_code,
NULL, bb, region, rename_map, gsi);
tree op1_type = TREE_TYPE (op1);
enum tree_code op1_code = TREE_CODE (op1);
tree op1_expr = expand_scalar_variables_expr (op1_type, op1, op1_code,
NULL, bb, region, rename_map, gsi);
return fold_build2 (code, type, op0_expr, op1_expr);
}
if (code == SSA_NAME)
return expand_scalar_variables_ssa_name (type, op0, bb, region, rename_map, gsi);
if (code == ADDR_EXPR)
{
tree op00 = TREE_OPERAND (op0, 0);
if (handled_component_p (op00)
&& TREE_CODE (op00) == ARRAY_REF)
{
tree e = expand_scalar_variables_expr (TREE_TYPE (op00), op00,
TREE_CODE (op00),
NULL, bb, region, rename_map, gsi);
return fold_build1 (code, TREE_TYPE (op0), e);
}
return op0;
}
gcc_unreachable ();
return NULL;
}
/* Copies at the beginning of BB all the scalar computations on which
STMT depends on in the SESE: these are all the scalar variables used
in STMT, defined outside BB and still defined in the SESE, i.e. not a
parameter of the SESE. The expression that is returned contains
only induction variables from the generated code: RENAME_MAP contains the
induction variables renaming mapping, and is used to translate the
names of induction variables. */
static void
expand_scalar_variables_stmt (gimple stmt, basic_block bb, sese region,
htab_t rename_map, gimple_stmt_iterator *gsi)
{
ssa_op_iter iter;
use_operand_p use_p;
FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
{
tree use = USE_FROM_PTR (use_p);
tree type = TREE_TYPE (use);
enum tree_code code = TREE_CODE (use);
tree use_expr;
if (!is_gimple_reg (use))
continue;
/* Don't expand USE if we already have a rename for it. */
use_expr = get_rename (rename_map, use);
if (use_expr != use)
continue;
use_expr = expand_scalar_variables_expr (type, use, code, NULL, bb,
region, rename_map, gsi);
use_expr = fold_convert (type, use_expr);
if (use_expr == use)
continue;
if (is_gimple_debug (stmt))
{
if (gimple_debug_bind_p (stmt))
gimple_debug_bind_reset_value (stmt);
else
gcc_unreachable ();
break;
}
if (TREE_CODE (use_expr) != SSA_NAME)
{
tree var = create_tmp_var (type, "var");
use_expr = build2 (MODIFY_EXPR, type, var, use_expr);
use_expr = force_gimple_operand_gsi (gsi, use_expr, true, NULL,
true, GSI_SAME_STMT);
}
replace_exp (use_p, use_expr);
}
update_stmt (stmt);
}
/* Copies at the beginning of BB all the scalar computations on which
BB depends on in the SESE: these are all the scalar variables used
in BB, defined outside BB and still defined in the SESE, i.e. not a
parameter of the SESE. The expression that is returned contains
only induction variables from the generated code: RENAME_MAP contains the
induction variables renaming mapping, and is used to translate the
names of induction variables. */
static void
expand_scalar_variables (basic_block bb, sese region, htab_t rename_map)
{
gimple_stmt_iterator gsi;
for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi);)
{
gimple stmt = gsi_stmt (gsi);
expand_scalar_variables_stmt (stmt, bb, region, rename_map, &gsi);
gsi_next (&gsi);
}
}
/* Rename all the SSA_NAMEs from block BB according to the RENAME_MAP. */
static void
rename_variables (basic_block bb, htab_t rename_map)
{
gimple_stmt_iterator gsi;
gimple_stmt_iterator insert_gsi = gsi_start_bb (bb);
for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi); gsi_next (&gsi))
rename_variables_in_stmt (gsi_stmt (gsi), rename_map, &insert_gsi);
}
/* Remove condition from BB. */
static void
remove_condition (basic_block bb)
{
gimple last = last_stmt (bb);
if (last && gimple_code (last) == GIMPLE_COND)
{
gimple_stmt_iterator gsi = gsi_last_bb (bb);
gsi_remove (&gsi, true);
}
}
/* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set. */
edge
@ -888,126 +426,142 @@ get_false_edge_from_guard_bb (basic_block bb)
return NULL;
}
/* Helper structure for htab_traverse in insert_guard_phis. */
struct igp {
basic_block bb;
edge true_edge, false_edge;
htab_t before_guard;
};
/* Return the default name that is before the guard. */
/* Returns the expression associated to OLD_NAME in RENAME_MAP. */
static tree
default_before_guard (htab_t before_guard, tree old_name)
get_rename (htab_t rename_map, tree old_name)
{
tree res = get_rename (before_guard, old_name);
struct rename_map_elt_s tmp;
PTR *slot;
if (res == old_name)
{
if (is_gimple_reg (res))
return fold_convert (TREE_TYPE (res), integer_zero_node);
return gimple_default_def (cfun, SSA_NAME_VAR (res));
}
gcc_assert (TREE_CODE (old_name) == SSA_NAME);
tmp.old_name = old_name;
slot = htab_find_slot (rename_map, &tmp, NO_INSERT);
return res;
if (slot && *slot)
return ((rename_map_elt) *slot)->expr;
return NULL_TREE;
}
/* Prepares EXPR to be a good phi argument when the phi result is
RES. Insert needed statements on edge E. */
static tree
convert_for_phi_arg (tree expr, tree res, edge e)
{
tree type = TREE_TYPE (res);
if (TREE_TYPE (expr) != type)
expr = fold_convert (type, expr);
if (TREE_CODE (expr) != SSA_NAME
&& !is_gimple_min_invariant (expr))
{
tree var = create_tmp_var (type, "var");
gimple_seq stmts;
expr = build2 (MODIFY_EXPR, type, var, expr);
expr = force_gimple_operand (expr, &stmts, true, NULL);
gsi_insert_seq_on_edge_immediate (e, stmts);
}
return expr;
}
/* Helper function for htab_traverse in insert_guard_phis. */
static int
add_guard_exit_phis (void **slot, void *s)
{
struct rename_map_elt_s *entry = (struct rename_map_elt_s *) *slot;
struct igp *i = (struct igp *) s;
basic_block bb = i->bb;
edge true_edge = i->true_edge;
edge false_edge = i->false_edge;
tree res = entry->old_name;
tree name1 = entry->expr;
tree name2 = default_before_guard (i->before_guard, res);
gimple phi;
/* Nothing to be merged if the name before the guard is the same as
the one after. */
if (name1 == name2)
return 1;
name1 = convert_for_phi_arg (name1, res, true_edge);
name2 = convert_for_phi_arg (name2, res, false_edge);
phi = create_phi_node (res, bb);
res = create_new_def_for (gimple_phi_result (phi), phi,
gimple_phi_result_ptr (phi));
add_phi_arg (phi, name1, true_edge, UNKNOWN_LOCATION);
add_phi_arg (phi, name2, false_edge, UNKNOWN_LOCATION);
entry->expr = res;
*slot = entry;
return 1;
}
/* Iterate over RENAME_MAP and get tuples of the form (OLD, NAME1).
If there is a correspondent tuple (OLD, NAME2) in BEFORE_GUARD,
with NAME1 different than NAME2, then insert in BB the phi node:
| RES = phi (NAME1 (on TRUE_EDGE), NAME2 (on FALSE_EDGE))"
if there is no tuple for OLD in BEFORE_GUARD, insert
| RES = phi (NAME1 (on TRUE_EDGE),
| DEFAULT_DEFINITION of NAME1 (on FALSE_EDGE))".
Finally register in RENAME_MAP the tuple (OLD, RES). */
void
insert_guard_phis (basic_block bb, edge true_edge, edge false_edge,
htab_t before_guard, htab_t rename_map)
{
struct igp i;
i.bb = bb;
i.true_edge = true_edge;
i.false_edge = false_edge;
i.before_guard = before_guard;
update_ssa (TODO_update_ssa);
htab_traverse (rename_map, add_guard_exit_phis, &i);
update_ssa (TODO_update_ssa);
}
/* Create a duplicate of the basic block BB. NOTE: This does not
preserve SSA form. */
/* Register in RENAME_MAP the rename tuple (OLD_NAME, EXPR). */
static void
graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, htab_t rename_map)
set_rename (htab_t rename_map, tree old_name, tree expr)
{
struct rename_map_elt_s tmp;
PTR *slot;
if (old_name == expr)
return;
tmp.old_name = old_name;
slot = htab_find_slot (rename_map, &tmp, INSERT);
if (!slot)
return;
if (*slot)
free (*slot);
*slot = new_rename_map_elt (old_name, expr);
}
/* Renames the scalar uses of the statement COPY, using the
substitution map RENAME_MAP, inserting the gimplification code at
GSI_TGT, for the translation REGION, with the original copied
statement in LOOP, and using the induction variable renaming map
IV_MAP. */
static void
rename_uses (gimple copy, htab_t rename_map, gimple_stmt_iterator *gsi_tgt,
sese region, loop_p loop, VEC (tree, heap) *iv_map)
{
use_operand_p use_p;
ssa_op_iter op_iter;
FOR_EACH_SSA_USE_OPERAND (use_p, copy, op_iter, SSA_OP_ALL_USES)
{
tree old_name = USE_FROM_PTR (use_p);
tree new_expr, scev;
gimple_seq stmts;
if (TREE_CODE (old_name) != SSA_NAME
|| !is_gimple_reg (old_name)
|| SSA_NAME_IS_DEFAULT_DEF (old_name))
continue;
new_expr = get_rename (rename_map, old_name);
if (new_expr)
{
tree type_old_name = TREE_TYPE (old_name);
tree type_new_expr = TREE_TYPE (new_expr);
if (type_old_name != type_new_expr
|| (TREE_CODE (new_expr) != SSA_NAME
&& is_gimple_reg (old_name)))
{
tree var;
if (is_gimple_debug (copy))
{
if (gimple_debug_bind_p (copy))
gimple_debug_bind_reset_value (copy);
else
gcc_unreachable ();
break;
}
var = create_tmp_var (type_old_name, "var");
if (type_old_name != type_new_expr)
new_expr = fold_convert (type_old_name, new_expr);
new_expr = build2 (MODIFY_EXPR, type_old_name, var, new_expr);
new_expr = force_gimple_operand (new_expr, &stmts, true, NULL);
gsi_insert_seq_before (gsi_tgt, stmts, GSI_SAME_STMT);
}
replace_exp (use_p, new_expr);
continue;
}
scev = scalar_evolution_in_region (region, loop, old_name);
/* At this point we should know the exact scev for each
scalar SSA_NAME used in the scop: all the other scalar
SSA_NAMEs should have been translated out of SSA using
arrays with one element. */
gcc_assert (!chrec_contains_undetermined (scev));
new_expr = chrec_apply_map (scev, iv_map);
/* The apply should produce an expression tree containing
the uses of the new induction variables. We should be
able to use new_expr instead of the old_name in the newly
generated loop nest. */
gcc_assert (!chrec_contains_undetermined (new_expr)
&& !tree_contains_chrecs (new_expr, NULL));
/* Replace the old_name with the new_expr. */
new_expr = force_gimple_operand (new_expr, &stmts, true, NULL);
gsi_insert_seq_before (gsi_tgt, stmts, GSI_SAME_STMT);
replace_exp (use_p, new_expr);
set_rename (rename_map, old_name, new_expr);
}
}
/* Duplicates the statements of basic block BB into basic block NEW_BB
and compute the new induction variables according to the IV_MAP. */
static void
graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb,
htab_t rename_map,
VEC (tree, heap) *iv_map, sese region)
{
gimple_stmt_iterator gsi, gsi_tgt;
loop_p loop = bb->loop_father;
gsi_tgt = gsi_start_bb (new_bb);
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
@ -1016,8 +570,19 @@ graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, htab_t renam
ssa_op_iter op_iter;
gimple stmt = gsi_stmt (gsi);
gimple copy;
tree lhs;
if (gimple_code (stmt) == GIMPLE_LABEL)
/* Do not copy labels or conditions. */
if (gimple_code (stmt) == GIMPLE_LABEL
|| gimple_code (stmt) == GIMPLE_COND)
continue;
/* Do not copy induction variables. */
if (is_gimple_assign (stmt)
&& (lhs = gimple_assign_lhs (stmt))
&& TREE_CODE (lhs) == SSA_NAME
&& is_gimple_reg (lhs)
&& scev_analyzable_p (lhs, region))
continue;
/* Create a new copy of STMT and duplicate STMT's virtual
@ -1032,11 +597,15 @@ graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, htab_t renam
/* Create new names for all the definitions created by COPY and
add replacement mappings for each new name. */
FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
{
tree old_name = DEF_FROM_PTR (def_p);
tree new_name = create_new_def_for (old_name, copy, def_p);
{
tree old_name = DEF_FROM_PTR (def_p);
tree new_name = create_new_def_for (old_name, copy, def_p);
set_rename (rename_map, old_name, new_name);
}
}
rename_uses (copy, rename_map, &gsi_tgt, region, loop, iv_map);
update_stmt (copy);
}
}
@ -1046,16 +615,16 @@ graphite_copy_stmts_from_block (basic_block bb, basic_block new_bb, htab_t renam
edge
copy_bb_and_scalar_dependences (basic_block bb, sese region,
edge next_e, htab_t rename_map)
edge next_e, VEC (tree, heap) *iv_map)
{
basic_block new_bb = split_edge (next_e);
htab_t rename_map = htab_create (10, rename_map_elt_info,
eq_rename_map_elts, free);
next_e = single_succ_edge (new_bb);
graphite_copy_stmts_from_block (bb, new_bb, rename_map);
remove_condition (new_bb);
graphite_copy_stmts_from_block (bb, new_bb, rename_map, iv_map, region);
remove_phi_nodes (new_bb);
expand_scalar_variables (new_bb, region, rename_map);
rename_variables (new_bb, rename_map);
htab_delete (rename_map);
return next_e;
}

19
gcc/sese.h
View File

@ -56,7 +56,8 @@ extern sese new_sese (edge, edge);
extern void free_sese (sese);
extern void sese_insert_phis_for_liveouts (sese, basic_block, edge, edge);
extern void build_sese_loop_nests (sese);
extern edge copy_bb_and_scalar_dependences (basic_block, sese, edge, htab_t);
extern edge copy_bb_and_scalar_dependences (basic_block, sese, edge,
VEC (tree, heap) *);
extern struct loop *outermost_loop_in_sese (sese, basic_block);
extern void insert_loop_close_phis (htab_t, loop_p);
extern void insert_guard_phis (basic_block, edge, edge, htab_t, htab_t);
@ -261,7 +262,6 @@ DEF_VEC_ALLOC_P (rename_map_elt, heap);
extern void debug_rename_map (htab_t);
extern hashval_t rename_map_elt_info (const void *);
extern int eq_rename_map_elts (const void *, const void *);
extern void set_rename (htab_t, tree, tree);
/* Constructs a new SCEV_INFO_STR structure for VAR and INSTANTIATED_BELOW. */
@ -386,4 +386,19 @@ nb_common_loops (sese region, gimple_bb_p gbb1, gimple_bb_p gbb2)
return sese_loop_depth (region, common);
}
/* Return true when DEF can be analyzed in REGION by the scalar
evolution analyzer. */
static inline bool
scev_analyzable_p (tree def, sese region)
{
gimple stmt = SSA_NAME_DEF_STMT (def);
loop_p loop = loop_containing_stmt (stmt);
tree scev = scalar_evolution_in_region (region, loop, def);
return !chrec_contains_undetermined (scev)
&& TREE_CODE (scev) != SSA_NAME
&& evolution_function_is_affine_p (scev);
}
#endif

17
gcc/tree-chrec.c
View File

@ -632,6 +632,23 @@ chrec_apply (unsigned var,
return res;
}
/* For a given CHREC and an induction variable map IV_MAP that maps
(loop->num, expr) for every loop number of the current_loops an
expression, calls chrec_apply when the expression is not NULL. */
tree
chrec_apply_map (tree chrec, VEC (tree, heap) *iv_map)
{
int i;
tree expr;
for (i = 0; VEC_iterate (tree, iv_map, i, expr); i++)
if (expr)
chrec = chrec_apply (i, chrec, expr);
return chrec;
}
/* Replaces the initial condition in CHREC with INIT_COND. */
tree

1
gcc/tree-chrec.h
View File

@ -64,6 +64,7 @@ extern tree chrec_convert_aggressive (tree, tree);
/* Operations. */
extern tree chrec_apply (unsigned, tree, tree);
extern tree chrec_apply_map (tree, VEC (tree, heap) *);
extern tree chrec_replace_initial_condition (tree, tree);
extern tree initial_condition (tree);
extern tree initial_condition_in_loop_num (tree, unsigned);