From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 2965 invoked by alias); 16 Jul 2010 07:05:03 -0000 Received: (qmail 535 invoked by uid 22791); 16 Jul 2010 07:04:40 -0000 X-SWARE-Spam-Status: No, hits=-1.9 required=5.0 tests=AWL,BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,TW_GB,TW_TM,T_TO_NO_BRKTS_FREEMAIL X-Spam-Check-By: sourceware.org Received: from mail-gx0-f175.google.com (HELO mail-gx0-f175.google.com) (209.85.161.175) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 16 Jul 2010 07:04:26 +0000 Received: by gxk3 with SMTP id 3so830309gxk.20 for ; Fri, 16 Jul 2010 00:04:23 -0700 (PDT) Received: by 10.101.5.40 with SMTP id h40mr806281ani.133.1279263863686; Fri, 16 Jul 2010 00:04:23 -0700 (PDT) Received: from napoca (cpe-70-120-196-107.austin.res.rr.com [70.120.196.107]) by mx.google.com with ESMTPS id p12sm21499812ane.14.2010.07.16.00.04.21 (version=TLSv1/SSLv3 cipher=RC4-MD5); Fri, 16 Jul 2010 00:04:23 -0700 (PDT) Received: by napoca (sSMTP sendmail emulation); Fri, 16 Jul 2010 02:04:20 -0500 From: Sebastian Pop To: gcc-patches@gcc.gnu.org Cc: gcc-graphite@googlegroups.com, Sebastian Pop Subject: [PATCH 02/12] Remove expand_scalar_variables_ hack. Date: Fri, 16 Jul 2010 07:05:00 -0000 Message-Id: <1279263843-9149-3-git-send-email-sebpop@gmail.com> In-Reply-To: <1279263843-9149-1-git-send-email-sebpop@gmail.com> References: <1279263843-9149-1-git-send-email-sebpop@gmail.com> X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org X-SW-Source: 2010-07/txt/msg01319.txt.bz2 2010-07-15 Sebastian Pop * 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. --- gcc/ChangeLog.graphite | 47 +++ gcc/graphite-clast-to-gimple.c | 129 +++----- gcc/graphite-clast-to-gimple.h | 1 - gcc/graphite-sese-to-poly.c | 14 - gcc/sese.c | 675 ++++++++-------------------------------- gcc/sese.h | 19 +- gcc/tree-chrec.c | 17 + gcc/tree-chrec.h | 1 + 8 files changed, 246 insertions(+), 657 deletions(-) diff --git a/gcc/ChangeLog.graphite b/gcc/ChangeLog.graphite index 3774b46..7498956 100644 --- a/gcc/ChangeLog.graphite +++ b/gcc/ChangeLog.graphite @@ -1,5 +1,52 @@ 2010-07-15 Sebastian Pop + * 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 + * graphite-clast-to-gimple.c (translate_clast_for_loop): Do not call insert_loop_close_phis. * sese.c (name_defined_in_loop_p): Removed. diff --git a/gcc/graphite-clast-to-gimple.c b/gcc/graphite-clast-to-gimple.c index 042857f..4d30daf 100644 --- a/gcc/graphite-clast-to-gimple.c +++ b/gcc/graphite-clast-to-gimple.c @@ -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); @@ -1011,20 +974,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) { @@ -1040,7 +1004,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); @@ -1060,14 +1024,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) { @@ -1075,8 +1037,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; @@ -1087,15 +1048,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) { @@ -1104,7 +1063,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; } @@ -1114,12 +1073,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) { @@ -1131,25 +1088,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(); @@ -1158,7 +1115,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); } @@ -1485,7 +1442,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); @@ -1512,7 +1469,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, @@ -1522,7 +1478,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 (); @@ -1536,7 +1492,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); diff --git a/gcc/graphite-clast-to-gimple.h b/gcc/graphite-clast-to-gimple.h index c90cfc0..fbb4efa 100644 --- a/gcc/graphite-clast-to-gimple.h +++ b/gcc/graphite-clast-to-gimple.h @@ -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. */ diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c index c186dd1..6e09532 100644 --- a/gcc/graphite-sese-to-poly.c +++ b/gcc/graphite-sese-to-poly.c @@ -2332,20 +2332,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. */ diff --git a/gcc/sese.c b/gcc/sese.c index e0c06da..913ac4d 100644 --- a/gcc/sese.c +++ b/gcc/sese.c @@ -394,6 +394,38 @@ sese_insert_phis_for_liveouts (sese region, basic_block bb, update_ssa (TODO_update_ssa); } +/* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag set. */ + +edge +get_true_edge_from_guard_bb (basic_block bb) +{ + edge e; + edge_iterator ei; + + FOR_EACH_EDGE (e, ei, bb->succs) + if (e->flags & EDGE_TRUE_VALUE) + return e; + + gcc_unreachable (); + return NULL; +} + +/* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag cleared. */ + +edge +get_false_edge_from_guard_bb (basic_block bb) +{ + edge e; + edge_iterator ei; + + FOR_EACH_EDGE (e, ei, bb->succs) + if (!(e->flags & EDGE_TRUE_VALUE)) + return e; + + gcc_unreachable (); + return NULL; +} + /* Returns the expression associated to OLD_NAME in RENAME_MAP. */ static tree @@ -409,12 +441,12 @@ get_rename (htab_t rename_map, tree old_name) if (slot && *slot) return ((rename_map_elt) *slot)->expr; - return old_name; + return NULL_TREE; } /* Register in RENAME_MAP the rename tuple (OLD_NAME, EXPR). */ -void +static void set_rename (htab_t rename_map, tree old_name, tree expr) { struct rename_map_elt_s tmp; @@ -435,579 +467,101 @@ set_rename (htab_t rename_map, tree old_name, tree expr) *slot = new_rename_map_elt (old_name, expr); } -/* Rename the SSA_NAMEs used in STMT and that appear in RENAME_MAP. */ +/* 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_variables_in_stmt (gimple stmt, htab_t rename_map, gimple_stmt_iterator *insert_gsi) +rename_uses (gimple copy, htab_t rename_map, gimple_stmt_iterator *gsi_tgt, + sese region, loop_p loop, VEC (tree, heap) *iv_map) { - ssa_op_iter iter; use_operand_p use_p; + ssa_op_iter op_iter; - FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES) + FOR_EACH_SSA_USE_OPERAND (use_p, copy, op_iter, SSA_OP_ALL_USES) { - tree use = USE_FROM_PTR (use_p); - tree expr, type_use, type_expr; + tree old_name = USE_FROM_PTR (use_p); + tree new_expr, scev; gimple_seq stmts; - if (TREE_CODE (use) != SSA_NAME) - continue; - - expr = get_rename (rename_map, use); - if (use == expr) + if (TREE_CODE (old_name) != SSA_NAME + || !is_gimple_reg (old_name) + || SSA_NAME_IS_DEFAULT_DEF (old_name)) 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))) + new_expr = get_rename (rename_map, old_name); + if (new_expr) { - tree var; + tree type_old_name = TREE_TYPE (old_name); + tree type_new_expr = TREE_TYPE (new_expr); - if (is_gimple_debug (stmt)) + if (type_old_name != type_new_expr + || (TREE_CODE (new_expr) != SSA_NAME + && is_gimple_reg (old_name))) { - 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; + tree var; - use_expr = expand_scalar_variables_expr (type, use, code, NULL, bb, - region, rename_map, gsi); - use_expr = fold_convert (type, use_expr); + if (is_gimple_debug (copy)) + { + if (gimple_debug_bind_p (copy)) + gimple_debug_bind_reset_value (copy); + else + gcc_unreachable (); - if (use_expr == use) - continue; + break; + } - if (is_gimple_debug (stmt)) - { - if (gimple_debug_bind_p (stmt)) - gimple_debug_bind_reset_value (stmt); - else - gcc_unreachable (); + var = create_tmp_var (type_old_name, "var"); - break; - } + if (type_old_name != type_new_expr) + new_expr = fold_convert (type_old_name, new_expr); - if (TREE_CODE (use_expr) != SSA_NAME) - { - tree var = create_tmp_var (type, "var"); + 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); + } - 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, new_expr); + continue; } - 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 -get_true_edge_from_guard_bb (basic_block bb) -{ - edge e; - edge_iterator ei; - - FOR_EACH_EDGE (e, ei, bb->succs) - if (e->flags & EDGE_TRUE_VALUE) - return e; - - gcc_unreachable (); - return NULL; -} - -/* Returns the first successor edge of BB with EDGE_TRUE_VALUE flag cleared. */ - -edge -get_false_edge_from_guard_bb (basic_block bb) -{ - edge e; - edge_iterator ei; - - FOR_EACH_EDGE (e, ei, bb->succs) - if (!(e->flags & EDGE_TRUE_VALUE)) - return e; - - gcc_unreachable (); - return NULL; -} - -/* Helper structure for htab_traverse in insert_guard_phis. */ + scev = scalar_evolution_in_region (region, loop, old_name); -struct igp { - basic_block bb; - edge true_edge, false_edge; - htab_t before_guard; -}; + /* 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)); -/* Return the default name that is before the guard. */ + new_expr = chrec_apply_map (scev, iv_map); -static tree -default_before_guard (htab_t before_guard, tree old_name) -{ - tree res = get_rename (before_guard, old_name); + /* 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)); - 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)); + /* 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); } - - return res; } -/* 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. */ +/* 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) +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; + + /* Do not copy labels or conditions. */ + if (gimple_code (stmt) == GIMPLE_LABEL + || gimple_code (stmt) == GIMPLE_COND) + continue; - if (gimple_code (stmt) == GIMPLE_LABEL) + /* 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; } diff --git a/gcc/sese.h b/gcc/sese.h index d0d829f..1502cbe 100644 --- a/gcc/sese.h +++ b/gcc/sese.h @@ -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 diff --git a/gcc/tree-chrec.c b/gcc/tree-chrec.c index 2d15285..c92b6b9 100644 --- a/gcc/tree-chrec.c +++ b/gcc/tree-chrec.c @@ -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 diff --git a/gcc/tree-chrec.h b/gcc/tree-chrec.h index fcff93a..eb60ac9 100644 --- a/gcc/tree-chrec.h +++ b/gcc/tree-chrec.h @@ -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); -- 1.7.0.4