From bd32f344edf8c50779ab8822236f1577a7649a1d Mon Sep 17 00:00:00 2001 From: Sebastian Pop Date: Tue, 6 Apr 2010 21:01:16 +0000 Subject: [PATCH] Compute min and max bounds for IVs and infer types. 2010-04-04 Sebastian Pop PR middle-end/43519 * Makefile.in (graphite-clast-to-gimple.o): Depends on langhooks.h. * graphite-clast-to-gimple.c: Include langhooks.h. (max_signed_precision_type): New. (max_precision_type): Takes two types as arguments. (precision_for_value): New. (precision_for_interval): New. (gcc_type_for_interval): New. (gcc_type_for_value): New. (gcc_type_for_clast_term): New. (gcc_type_for_clast_red): New. (gcc_type_for_clast_bin): New. (gcc_type_for_clast_expr): Split up into several functions. (gcc_type_for_clast_eq): Rewritten. (compute_bounds_for_level): New. (compute_type_for_level_1): New. (compute_type_for_level): New. (gcc_type_for_cloog_iv): Removed. (gcc_type_for_iv_of_clast_loop): Rewritten. (graphite_create_new_loop): Compute the lower and upper bound types with gcc_type_for_clast_expr. (graphite_create_new_loop_guard): Same. (find_cloog_iv_in_expr): Removed. (compute_cloog_iv_types_1): Removed. (compute_cloog_iv_types): Removed. (gloog): Do not call compute_cloog_iv_types. * graphite-sese-to-poly.c (new_gimple_bb): Do not initialize GBB_CLOOG_IV_TYPES. (free_data_refs_aux): Do not free GBB_CLOOG_IV_TYPES. * sese.h (struct gimple_bb): Removed field cloog_iv_types. (GBB_CLOOG_IV_TYPES): Removed. * gcc.dg/graphite/run-id-pr42644.c: Call abort. From-SVN: r158026 --- gcc/ChangeLog.graphite | 36 ++ gcc/Makefile.in | 2 +- gcc/graphite-clast-to-gimple.c | 530 ++++++++++-------- gcc/graphite-sese-to-poly.c | 4 - gcc/sese.h | 2 - .../gcc.dg/graphite/run-id-pr42644.c | 7 +- 6 files changed, 340 insertions(+), 241 deletions(-) diff --git a/gcc/ChangeLog.graphite b/gcc/ChangeLog.graphite index 09c9f9dc81f..a24f4995789 100644 --- a/gcc/ChangeLog.graphite +++ b/gcc/ChangeLog.graphite @@ -1,3 +1,39 @@ +2010-04-04 Sebastian Pop + + PR middle-end/43519 + * Makefile.in (graphite-clast-to-gimple.o): Depends on langhooks.h. + * graphite-clast-to-gimple.c: Include langhooks.h. + (max_signed_precision_type): New. + (max_precision_type): Takes two types as arguments. + (precision_for_value): New. + (precision_for_interval): New. + (gcc_type_for_interval): New. + (gcc_type_for_value): New. + (gcc_type_for_clast_term): New. + (gcc_type_for_clast_red): New. + (gcc_type_for_clast_bin): New. + (gcc_type_for_clast_expr): Split up into several functions. + (gcc_type_for_clast_eq): Rewritten. + (compute_bounds_for_level): New. + (compute_type_for_level_1): New. + (compute_type_for_level): New. + (gcc_type_for_cloog_iv): Removed. + (gcc_type_for_iv_of_clast_loop): Rewritten. + (graphite_create_new_loop): Compute the lower and upper bound types + with gcc_type_for_clast_expr. + (graphite_create_new_loop_guard): Same. + (find_cloog_iv_in_expr): Removed. + (compute_cloog_iv_types_1): Removed. + (compute_cloog_iv_types): Removed. + (gloog): Do not call compute_cloog_iv_types. + * graphite-sese-to-poly.c (new_gimple_bb): Do not initialize + GBB_CLOOG_IV_TYPES. + (free_data_refs_aux): Do not free GBB_CLOOG_IV_TYPES. + * sese.h (struct gimple_bb): Removed field cloog_iv_types. + (GBB_CLOOG_IV_TYPES): Removed. + + * gcc.dg/graphite/run-id-pr42644.c: Call abort. + 2010-04-02 Sebastian Pop Reverted this commit: as at this point the loop closed SSA form diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 1dab9a5630f..a1ad1d4a368 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -2577,7 +2577,7 @@ graphite-blocking.o: graphite-blocking.c $(CONFIG_H) $(SYSTEM_H) \ $(GIMPLE_H) $(TREE_DATA_REF_H) tree-pass.h domwalk.h value-prof.h \ graphite.h graphite-poly.h graphite-ppl.h graphite-clast-to-gimple.o: graphite-clast-to-gimple.c $(CONFIG_H) \ - $(SYSTEM_H) coretypes.h $(TM_H) \ + $(SYSTEM_H) coretypes.h $(TM_H) langhooks.h \ $(GGC_H) $(TREE_H) $(RTL_H) $(BASIC_BLOCK_H) $(DIAGNOSTIC_H) $(TOPLEV_H) \ $(TREE_FLOW_H) $(TREE_DUMP_H) $(TIMEVAR_H) $(CFGLOOP_H) $(GIMPLE_H) \ $(TREE_DATA_REF_H) tree-pass.h domwalk.h graphite.h \ diff --git a/gcc/graphite-clast-to-gimple.c b/gcc/graphite-clast-to-gimple.c index 819b9247533..6aab2a5521c 100644 --- a/gcc/graphite-clast-to-gimple.c +++ b/gcc/graphite-clast-to-gimple.c @@ -40,6 +40,7 @@ along with GCC; see the file COPYING3. If not see #include "value-prof.h" #include "pointer-set.h" #include "gimple.h" +#include "langhooks.h" #include "sese.h" #ifdef HAVE_cloog @@ -223,13 +224,40 @@ clast_name_to_gcc (const char *name, sese region, VEC (tree, heap) *newivs, return newivs_to_depth_to_newiv (newivs, index); } -/* Returns the maximal precision type for expressions E1 and E2. */ +/* Returns the signed maximal precision type for expressions TYPE1 and TYPE2. */ -static inline tree -max_precision_type (tree e1, tree e2) +static tree +max_signed_precision_type (tree type1, tree type2) +{ + int p1 = TYPE_PRECISION (type1); + int p2 = TYPE_PRECISION (type2); + int precision = p1 > p2 ? p1 : p2; + tree type = lang_hooks.types.type_for_size (precision, false); + + if (!type) + { + gloog_error = true; + return integer_type_node; + } + return type; +} + +/* Returns the maximal precision type for expressions TYPE1 and TYPE2. */ + +static tree +max_precision_type (tree type1, tree type2) { - tree type1 = TREE_TYPE (e1); - tree type2 = TREE_TYPE (e2); + + if (POINTER_TYPE_P (type1)) + return type1; + + if (POINTER_TYPE_P (type2)) + return type2; + + if (!TYPE_UNSIGNED (type1) + || !TYPE_UNSIGNED (type2)) + return max_signed_precision_type (type1, type2); + return TYPE_PRECISION (type1) > TYPE_PRECISION (type2) ? type1 : type2; } @@ -384,7 +412,168 @@ clast_to_gcc_expression (tree type, struct clast_expr *e, return NULL_TREE; } -/* Returns the type for the expression E. */ +/* Return the precision needed to represent the value VAL. */ + +static int +precision_for_value (Value val) +{ + Value x, y, two; + int precision; + + value_init (x); + value_init (y); + value_init (two); + value_set_si (x, 2); + value_assign (y, val); + value_set_si (two, 2); + precision = 1; + + if (value_neg_p (y)) + value_oppose (y, y); + + while (value_gt (y, x)) + { + value_multiply (x, x, two); + precision++; + } + + value_clear (x); + value_clear (y); + value_clear (two); + + return precision; +} + +/* Return the precision needed to represent the values between LOW and + UP. */ + +static int +precision_for_interval (Value low, Value up) +{ + Value diff; + int precision; + + gcc_assert (value_le (low, up)); + + value_init (diff); + value_subtract (diff, up, low); + precision = precision_for_value (diff); + value_clear (diff); + + return precision; +} + +/* Return a type that could represent the integer value VAL, or + otherwise return NULL_TREE. */ + +static tree +gcc_type_for_interval (Value low, Value up, tree old_type) +{ + bool unsigned_p = true; + int precision, prec_up, prec_int; + tree type; + + gcc_assert (value_le (low, up)); + + /* Preserve the signedness of the old IV. */ + if ((old_type && !TYPE_UNSIGNED (old_type)) + || value_neg_p (low)) + unsigned_p = false; + + prec_up = precision_for_value (up); + prec_int = precision_for_interval (low, up); + precision = prec_up > prec_int ? prec_up : prec_int; + + type = lang_hooks.types.type_for_size (precision, unsigned_p); + if (!type) + { + gloog_error = true; + return integer_type_node; + } + + return type; +} + +/* Return a type that could represent the integer value VAL, or + otherwise return NULL_TREE. */ + +static tree +gcc_type_for_value (Value val) +{ + return gcc_type_for_interval (val, val, NULL_TREE); +} + +/* Return the type for the clast_term T used in STMT. */ + +static tree +gcc_type_for_clast_term (struct clast_term *t, + sese region, VEC (tree, heap) *newivs, + htab_t newivs_index, htab_t params_index) +{ + gcc_assert (t->expr.type == expr_term); + + if (!t->var) + return gcc_type_for_value (t->val); + + return TREE_TYPE (clast_name_to_gcc (t->var, region, newivs, + newivs_index, params_index)); +} + +static tree +gcc_type_for_clast_expr (struct clast_expr *, sese, + VEC (tree, heap) *, htab_t, htab_t); + +/* Return the type for the clast_reduction R used in STMT. */ + +static tree +gcc_type_for_clast_red (struct clast_reduction *r, sese region, + VEC (tree, heap) *newivs, + htab_t newivs_index, htab_t params_index) +{ + int i; + tree type = NULL_TREE; + + if (r->n == 1) + return gcc_type_for_clast_expr (r->elts[0], region, newivs, + newivs_index, params_index); + + switch (r->type) + { + case clast_red_sum: + case clast_red_min: + case clast_red_max: + type = gcc_type_for_clast_expr (r->elts[0], region, newivs, + newivs_index, params_index); + for (i = 1; i < r->n; i++) + type = max_precision_type (type, gcc_type_for_clast_expr + (r->elts[i], region, newivs, + newivs_index, params_index)); + + return type; + + default: + break; + } + + gcc_unreachable (); + return NULL_TREE; +} + +/* Return the type for the clast_binary B used in STMT. */ + +static tree +gcc_type_for_clast_bin (struct clast_binary *b, + sese region, VEC (tree, heap) *newivs, + htab_t newivs_index, htab_t params_index) +{ + tree l = gcc_type_for_clast_expr ((struct clast_expr *) b->LHS, region, + newivs, newivs_index, params_index); + tree r = gcc_type_for_value (b->RHS); + return max_signed_precision_type (l, r); +} + +/* Returns the type for the CLAST expression E when used in statement + STMT. */ static tree gcc_type_for_clast_expr (struct clast_expr *e, @@ -394,45 +583,16 @@ gcc_type_for_clast_expr (struct clast_expr *e, switch (e->type) { case expr_term: - { - struct clast_term *t = (struct clast_term *) e; - - if (t->var) - return TREE_TYPE (clast_name_to_gcc (t->var, region, newivs, - newivs_index, params_index)); - else - return NULL_TREE; - } + return gcc_type_for_clast_term ((struct clast_term *) e, region, + newivs, newivs_index, params_index); case expr_red: - { - struct clast_reduction *r = (struct clast_reduction *) e; - - if (r->n == 1) - return gcc_type_for_clast_expr (r->elts[0], region, newivs, - newivs_index, params_index); - else - { - int i; - for (i = 0; i < r->n; i++) - { - tree type = gcc_type_for_clast_expr (r->elts[i], region, - newivs, newivs_index, - params_index); - if (type) - return type; - } - return NULL_TREE; - } - } + return gcc_type_for_clast_red ((struct clast_reduction *) e, region, + newivs, newivs_index, params_index); case expr_bin: - { - struct clast_binary *b = (struct clast_binary *) e; - struct clast_expr *lhs = (struct clast_expr *) b->LHS; - return gcc_type_for_clast_expr (lhs, region, newivs, - newivs_index, params_index); - } + return gcc_type_for_clast_bin ((struct clast_binary *) e, region, + newivs, newivs_index, params_index); default: gcc_unreachable (); @@ -448,13 +608,11 @@ gcc_type_for_clast_eq (struct clast_equation *cleq, sese region, VEC (tree, heap) *newivs, htab_t newivs_index, htab_t params_index) { - tree type = gcc_type_for_clast_expr (cleq->LHS, region, newivs, - newivs_index, params_index); - if (type) - return type; - - return gcc_type_for_clast_expr (cleq->RHS, region, newivs, newivs_index, - params_index); + tree l = gcc_type_for_clast_expr (cleq->LHS, region, newivs, + newivs_index, params_index); + tree r = gcc_type_for_clast_expr (cleq->RHS, region, newivs, + newivs_index, params_index); + return max_precision_type (l, r); } /* Translates a clast equation CLEQ to a tree. */ @@ -524,103 +682,117 @@ graphite_create_new_guard (sese region, edge entry_edge, return exit_edge; } -/* Walks a CLAST and returns the first statement in the body of a - loop. */ +/* Compute the lower bound LOW and upper bound UP for the induction + variable at LEVEL for the statement PBB, based on the transformed + scattering of PBB: T|I|G|Cst, with T the scattering transform, I + the iteration domain, and G the context parameters. */ -static struct clast_user_stmt * -clast_get_body_of_loop (struct clast_stmt *stmt) +static void +compute_bounds_for_level (poly_bb_p pbb, int level, Value low, Value up) { - if (!stmt - || CLAST_STMT_IS_A (stmt, stmt_user)) - return (struct clast_user_stmt *) stmt; + ppl_Pointset_Powerset_C_Polyhedron_t ps; + ppl_Linear_Expression_t le; - if (CLAST_STMT_IS_A (stmt, stmt_for)) - return clast_get_body_of_loop (((struct clast_for *) stmt)->body); + combine_context_id_scat (&ps, pbb, false); - if (CLAST_STMT_IS_A (stmt, stmt_guard)) - return clast_get_body_of_loop (((struct clast_guard *) stmt)->then); + /* Prepare the linear expression corresponding to the level that we + want to maximize/minimize. */ + { + ppl_dimension_type dim = pbb_nb_scattering_transform (pbb) + + pbb_dim_iter_domain (pbb) + pbb_nb_params (pbb); - if (CLAST_STMT_IS_A (stmt, stmt_block)) - return clast_get_body_of_loop (((struct clast_block *) stmt)->body); + ppl_new_Linear_Expression_with_dimension (&le, dim); + ppl_set_coef (le, 2 * level + 1, 1); + } - gcc_unreachable (); + ppl_max_for_le_pointset (ps, le, up); + ppl_min_for_le_pointset (ps, le, low); } -/* Java does not initialize long_long_integer_type_node. */ -#define my_long_long (long_long_integer_type_node ? long_long_integer_type_node : ssizetype) +/* Compute the type for the induction variable at LEVEL for the + statement PBB, based on the transformed schedule of PBB. OLD_TYPE + is the type of the old induction variable for that loop. */ -/* Given a CLOOG_IV, return the type that CLOOG_IV should have in GCC - land. The selected type is big enough to include the original loop - iteration variable, but signed to work with the subtractions CLooG - may have introduced. If such a type is not available, we fail. +static tree +compute_type_for_level_1 (poly_bb_p pbb, int level, tree old_type) +{ + Value low, up; + tree type; - TODO: Do not always return long_long, but the smallest possible - type, that still holds the original type. + value_init (low); + value_init (up); - TODO: Get the types using CLooG instead. This enables further - optimizations, but needs CLooG support. */ + compute_bounds_for_level (pbb, level, low, up); + type = gcc_type_for_interval (low, up, old_type); + + value_clear (low); + value_clear (up); + return type; +} + +/* Compute the type for the induction variable at LEVEL for the + statement PBB, based on the transformed schedule of PBB. */ static tree -gcc_type_for_cloog_iv (const char *cloog_iv, gimple_bb_p gbb) +compute_type_for_level (poly_bb_p pbb, int level) { - struct ivtype_map_elt_s tmp; - PTR *slot; - - tmp.cloog_iv = cloog_iv; - slot = htab_find_slot (GBB_CLOOG_IV_TYPES (gbb), &tmp, NO_INSERT); + tree oldiv = pbb_to_depth_to_oldiv (pbb, level); + tree type = TREE_TYPE (oldiv); - if (slot && *slot) + if (type && POINTER_TYPE_P (type)) { - tree type = ((ivtype_map_elt) *slot)->type; - int type_precision = TYPE_PRECISION (type); - - /* Find the smallest signed type possible. */ - if (!TYPE_UNSIGNED (type)) - { - if (type_precision <= TYPE_PRECISION (integer_type_node)) - return integer_type_node; +#ifdef ENABLE_CHECKING + tree ctype = compute_type_for_level_1 (pbb, level, type); - if (type_precision <= TYPE_PRECISION (long_integer_type_node)) - return long_integer_type_node; + /* In the case of a pointer type, check that after the loop + transform, the lower and the upper bounds of the type fit the + oldiv pointer type. */ + gcc_assert (TYPE_PRECISION (type) >= TYPE_PRECISION (ctype) + && integer_zerop (lower_bound_in_type (ctype, ctype))); +#endif + return type; + } - if (type_precision <= TYPE_PRECISION (my_long_long)) - return my_long_long; + return compute_type_for_level_1 (pbb, level, type); +} - gcc_unreachable (); - } +/* Walks a CLAST and returns the first statement in the body of a + loop. */ - if (type_precision < TYPE_PRECISION (integer_type_node)) - return integer_type_node; +static struct clast_user_stmt * +clast_get_body_of_loop (struct clast_stmt *stmt) +{ + if (!stmt + || CLAST_STMT_IS_A (stmt, stmt_user)) + return (struct clast_user_stmt *) stmt; - if (type_precision < TYPE_PRECISION (long_integer_type_node)) - return long_integer_type_node; + if (CLAST_STMT_IS_A (stmt, stmt_for)) + return clast_get_body_of_loop (((struct clast_for *) stmt)->body); - if (type_precision < TYPE_PRECISION (my_long_long)) - return my_long_long; + if (CLAST_STMT_IS_A (stmt, stmt_guard)) + return clast_get_body_of_loop (((struct clast_guard *) stmt)->then); - /* There is no signed type available, that is large enough to hold the - original value. */ - gcc_unreachable (); - } + if (CLAST_STMT_IS_A (stmt, stmt_block)) + return clast_get_body_of_loop (((struct clast_block *) stmt)->body); - return my_long_long; + gcc_unreachable (); } -#undef my_long_long - -/* Returns the induction variable for the loop that gets translated to - STMT. */ +/* Returns the type for the induction variable for the loop translated + from STMT_FOR. */ static tree -gcc_type_for_iv_of_clast_loop (struct clast_for *stmt_for) +gcc_type_for_iv_of_clast_loop (struct clast_for *stmt_for, int level, + tree lb_type, tree ub_type) { struct clast_stmt *stmt = (struct clast_stmt *) stmt_for; struct clast_user_stmt *body = clast_get_body_of_loop (stmt); - const char *cloog_iv = stmt_for->iterator; CloogStatement *cs = body->statement; poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (cs); - return gcc_type_for_cloog_iv (cloog_iv, PBB_BLACK_BOX (pbb)); + return max_precision_type (lb_type, max_precision_type + (ub_type, compute_type_for_level (pbb, + level - 1))); } /* Creates a new LOOP corresponding to Cloog's STMT. Inserts an @@ -635,9 +807,13 @@ static struct loop * graphite_create_new_loop (sese region, edge entry_edge, struct clast_for *stmt, loop_p outer, VEC (tree, heap) **newivs, - htab_t newivs_index, htab_t params_index) + htab_t newivs_index, htab_t params_index, int level) { - tree type = gcc_type_for_iv_of_clast_loop (stmt); + tree lb_type = gcc_type_for_clast_expr (stmt->LB, region, *newivs, + newivs_index, params_index); + tree ub_type = gcc_type_for_clast_expr (stmt->UB, region, *newivs, + newivs_index, params_index); + tree type = gcc_type_for_iv_of_clast_loop (stmt, level, lb_type, ub_type); tree lb = clast_to_gcc_expression (type, stmt->LB, region, *newivs, newivs_index, params_index); tree ub = clast_to_gcc_expression (type, stmt->UB, region, *newivs, @@ -837,7 +1013,11 @@ graphite_create_new_loop_guard (sese region, edge entry_edge, { tree cond_expr; edge exit_edge; - tree type = gcc_type_for_iv_of_clast_loop (stmt); + tree lb_type = gcc_type_for_clast_expr (stmt->LB, region, newivs, + newivs_index, params_index); + tree ub_type = gcc_type_for_clast_expr (stmt->UB, region, newivs, + newivs_index, params_index); + tree type = max_precision_type (lb_type, ub_type); tree lb = clast_to_gcc_expression (type, stmt->LB, region, newivs, newivs_index, params_index); tree ub = clast_to_gcc_expression (type, stmt->UB, region, newivs, @@ -882,7 +1062,8 @@ translate_clast_for_loop (sese region, loop_p context_loop, { struct loop *loop = graphite_create_new_loop (region, next_e, stmt, context_loop, newivs, - newivs_index, params_index); + newivs_index, params_index, + level); edge last_e = single_exit (loop); edge to_body = single_succ_edge (loop->header); basic_block after = to_body->dest; @@ -927,7 +1108,7 @@ translate_clast_for (sese region, loop_p context_loop, struct clast_for *stmt, htab_t params_index) { edge last_e = graphite_create_new_loop_guard (region, next_e, stmt, *newivs, - newivs_index, params_index); + newivs_index, params_index); edge true_e = get_true_edge_from_guard_bb (next_e->dest); edge false_e = get_false_edge_from_guard_bb (next_e->dest); @@ -1045,122 +1226,6 @@ translate_clast (sese region, loop_p context_loop, struct clast_stmt *stmt, bb_pbb_mapping, level, params_index); } -/* Returns the first cloog name used in EXPR. */ - -static const char * -find_cloog_iv_in_expr (struct clast_expr *expr) -{ - struct clast_term *term = (struct clast_term *) expr; - struct clast_reduction *red; - int i; - - if (expr->type == expr_term) - return term->var; - - if (expr->type != expr_red) - return NULL; - - red = (struct clast_reduction *) expr; - for (i = 0; i < red->n; i++) - { - const char *res = find_cloog_iv_in_expr (red->elts[i]); - - if (res) - return res; - } - - return NULL; -} - -/* Build for USER_STMT a map between the CLAST induction variables and - the corresponding GCC old induction variables. This information is - stored on each GRAPHITE_BB. */ - -static void -compute_cloog_iv_types_1 (poly_bb_p pbb, struct clast_user_stmt *user_stmt) -{ - gimple_bb_p gbb = PBB_BLACK_BOX (pbb); - struct clast_stmt *t; - int index = 0; - - for (t = user_stmt->substitutions; t; t = t->next, index++) - { - PTR *slot; - struct ivtype_map_elt_s tmp; - struct clast_expr *expr = (struct clast_expr *) - ((struct clast_assignment *)t)->RHS; - - /* Create an entry (clast_var, type). */ - tmp.cloog_iv = find_cloog_iv_in_expr (expr); - if (!tmp.cloog_iv) - continue; - - slot = htab_find_slot (GBB_CLOOG_IV_TYPES (gbb), &tmp, INSERT); - - if (slot && !*slot) - { - tree oldiv = pbb_to_depth_to_oldiv (pbb, index); - tree type = TREE_TYPE (oldiv); - *slot = new_ivtype_map_elt (tmp.cloog_iv, type); - } - } -} - -/* Walk the CLAST tree starting from STMT and build for each - clast_user_stmt a map between the CLAST induction variables and the - corresponding GCC old induction variables. This information is - stored on each GRAPHITE_BB. */ - -static void -compute_cloog_iv_types (struct clast_stmt *stmt) -{ - if (!stmt) - return; - - if (CLAST_STMT_IS_A (stmt, stmt_root)) - goto next; - - if (CLAST_STMT_IS_A (stmt, stmt_user)) - { - CloogStatement *cs = ((struct clast_user_stmt *) stmt)->statement; - poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (cs); - gimple_bb_p gbb = PBB_BLACK_BOX (pbb); - - if (!GBB_CLOOG_IV_TYPES (gbb)) - GBB_CLOOG_IV_TYPES (gbb) = htab_create (10, ivtype_map_elt_info, - eq_ivtype_map_elts, free); - - compute_cloog_iv_types_1 (pbb, (struct clast_user_stmt *) stmt); - goto next; - } - - if (CLAST_STMT_IS_A (stmt, stmt_for)) - { - struct clast_stmt *s = ((struct clast_for *) stmt)->body; - compute_cloog_iv_types (s); - goto next; - } - - if (CLAST_STMT_IS_A (stmt, stmt_guard)) - { - struct clast_stmt *s = ((struct clast_guard *) stmt)->then; - compute_cloog_iv_types (s); - goto next; - } - - if (CLAST_STMT_IS_A (stmt, stmt_block)) - { - struct clast_stmt *s = ((struct clast_block *) stmt)->body; - compute_cloog_iv_types (s); - goto next; - } - - gcc_unreachable (); - - next: - compute_cloog_iv_types (stmt->next); -} - /* Free the SCATTERING domain list. */ static void @@ -1512,7 +1577,6 @@ gloog (scop_p scop, VEC (scop_p, heap) *scops, htab_t bb_pbb_mapping) graphite_verify (); context_loop = SESE_ENTRY (region)->src->loop_father; - compute_cloog_iv_types (pc.stmt); 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); diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c index 4584fe93aca..5c004f4abfc 100644 --- a/gcc/graphite-sese-to-poly.c +++ b/gcc/graphite-sese-to-poly.c @@ -280,7 +280,6 @@ new_gimple_bb (basic_block bb, VEC (data_reference_p, heap) *drs) GBB_DATA_REFS (gbb) = drs; GBB_CONDITIONS (gbb) = NULL; GBB_CONDITION_CASES (gbb) = NULL; - GBB_CLOOG_IV_TYPES (gbb) = NULL; return gbb; } @@ -308,9 +307,6 @@ free_data_refs_aux (VEC (data_reference_p, heap) *datarefs) static void free_gimple_bb (struct gimple_bb *gbb) { - if (GBB_CLOOG_IV_TYPES (gbb)) - htab_delete (GBB_CLOOG_IV_TYPES (gbb)); - free_data_refs_aux (GBB_DATA_REFS (gbb)); free_data_refs (GBB_DATA_REFS (gbb)); diff --git a/gcc/sese.h b/gcc/sese.h index 6219f34f453..28eb2fac8cd 100644 --- a/gcc/sese.h +++ b/gcc/sese.h @@ -346,14 +346,12 @@ typedef struct gimple_bb VEC (gimple, heap) *conditions; VEC (gimple, heap) *condition_cases; VEC (data_reference_p, heap) *data_refs; - htab_t cloog_iv_types; } *gimple_bb_p; #define GBB_BB(GBB) GBB->bb #define GBB_DATA_REFS(GBB) GBB->data_refs #define GBB_CONDITIONS(GBB) GBB->conditions #define GBB_CONDITION_CASES(GBB) GBB->condition_cases -#define GBB_CLOOG_IV_TYPES(GBB) GBB->cloog_iv_types /* Return the innermost loop that contains the basic block GBB. */ diff --git a/gcc/testsuite/gcc.dg/graphite/run-id-pr42644.c b/gcc/testsuite/gcc.dg/graphite/run-id-pr42644.c index 2e9006470c4..d134b5c3084 100644 --- a/gcc/testsuite/gcc.dg/graphite/run-id-pr42644.c +++ b/gcc/testsuite/gcc.dg/graphite/run-id-pr42644.c @@ -18,6 +18,8 @@ void foo(double Ke[2], int i, double ds[], int column) } } +extern void abort (); + int main () { @@ -28,5 +30,8 @@ main () foo(Ke, 0, ds, -1); - return (int) Ke[0] != 124; + if ((int) Ke[0] != 124) + abort (); + + return 0; } -- 2.30.2