From 81b822d5d08d3158fe0dd4afdef519e6a1cc4ee1 Mon Sep 17 00:00:00 2001 From: Sebastian Pop Date: Thu, 11 Dec 2008 07:23:02 +0000 Subject: Fix testsuite/gfortran.dg/graphite/id-4.f90. 2008-12-11 Sebastian Pop Fix testsuite/gfortran.dg/graphite/id-4.f90. * graphite.c (scan_tree_for_params): Do not compute the multiplicand when not needed. 2008-12-11 Sebastian Pop * graphite.c (build_scops_1): Initialize open_scop.exit and sinfo.last. 2008-12-11 Sebastian Pop Jan Sjodin Harsha Jagasia PR middle-end/37852 PR middle-end/37883 PR middle-end/37928 PR middle-end/37980 PR middle-end/38038 PR middle-end/38039 PR middle-end/38073 PR middle-end/38083 PR middle-end/38125 * tree-phinodes.c (remove_phi_nodes): New, extracted from... * tree-cfg.c (remove_phi_nodes_and_edges_for_unreachable_block): ...here. * tree-flow.h (remove_phi_nodes, canonicalize_loop_ivs): Declared. * Makefile.in (graphite.o): Depend on value-prof.h. (graphite.o-warn): Removed -Wno-error. * tree-parloops.c (canonicalize_loop_ivs): Allow reduction_list to be a NULL pointer. Call update_stmt. Return the newly created cannonical induction variable. * graphite.h (debug_rename_map): Declared. Fix some comments. * graphite.c: Reimplement the code generation from graphite to gimple. Include value-prof.h. (loop_iv_stack_get_iv): Do not return NULL for constant substitutions. (get_old_iv_from_ssa_name): Removed. (graphite_stmt_p): New. (new_graphite_bb): Test for useful statements before building a graphite statement for the basic block. (free_graphite_bb): Do not free GBB_DATA_REFS: this is a bug in free_data_ref that calls BITMAP_FREE (DR_VOPS (dr)) without reason. (recompute_all_dominators, graphite_verify, nb_reductions_in_loop, graphite_loop_normal_form): New. (scop_record_loop): Call graphite_loop_normal_form. (build_scop_loop_nests): Iterate over all the blocks of the function instead of relying on the incomplete information from SCOP_BBS. Return the success of the operation. (find_params_in_bb): Use the data from GBB_DATA_REFS. (add_bb_domains): Removed. (build_loop_iteration_domains): Don't call add_bb_domains. Add the iteration domain only to the basic blocks that have been translated to graphite. (build_scop_conditions_1): Add constraints only if the basic block have been translated to graphite. (build_scop_data_accesses): Completely disabled until data dependence is correctly implemented. (debug_rename_elt, debug_rename_map_1, debug_rename_map): New. (remove_all_edges_1, remove_all_edges): Removed. (get_new_name_from_old_name): New. (graphite_rename_variables_in_stmt): Renamed rename_variables_in_stmt. Call get_new_name_from_old_name. Use replace_exp and update_stmt. (is_old_iv): Renamed is_iv. (expand_scalar_variables_stmt): Extra parameter for renaming map. Use replace_exp and update_stmt. (expand_scalar_variables_expr): Same. Use the map to get the new names for the renaming of induction variables and for the renaming of variables after a basic block has been copied. (expand_scalar_variables): Same. (graphite_rename_variables): Renamed rename_variables. (move_phi_nodes): Removed. (get_false_edge_from_guard_bb): New. (build_iv_mapping): Do not insert the induction variable of a loop in the renaming iv map if the basic block does not belong to that loop. (register_old_new_names, graphite_copy_stmts_from_block, copy_bb_and_scalar_dependences): New. (translate_clast): Heavily reimplemented: copy basic blocks, do not move them. Finally, in call cleanup_tree_cfg in gloog. At each translation step call graphite_verify ensuring the consistency of the SSA, loops and dominators information. (collect_virtual_phis, find_vdef_for_var_in_bb, find_vdef_for_var_1, find_vdef_for_var, patch_phis_for_virtual_defs): Removed huge hack. (mark_old_loops, remove_dead_loops, skip_phi_defs, collect_scop_exit_phi_args, patch_scop_exit_phi_args, gbb_can_be_ignored, scop_remove_ignoreable_gbbs, ): Removed. (remove_sese_region, ifsese, if_region_entry, if_region_exit, if_region_get_condition_block, if_region_set_false_region, create_if_region_on_edge, move_sese_in_condition, bb_in_sese_p, sese_find_uses_to_rename_use, sese_find_uses_to_rename_bb, sese_add_exit_phis_edge, sese_add_exit_phis_var, rewrite_into_sese_closed_ssa): New. (gloog): Remove dead code. Early return if code cannot be generated. Call cleanup_tree_cfg once the scop has been code generated. (graphite_trans_scop_block, graphite_trans_loop_block): Do not block loops with less than two loops. (graphite_apply_transformations): Remove the call to scop_remove_ignoreable_gbbs. (limit_scops): When build_scop_loop_nests fails, continue on next scop. Fix open_scop.entry. (graphite_transform_loops): Call recompute_all_dominators: force the recomputation of correct CDI_DOMINATORS and CDI_POST_DOMINATORS. Call initialize_original_copy_tables and free_original_copy_tables to be able to copy basic blocks during code generation. When build_scop_loop_nests fails, continue on next scop. (value_clast): New union. (clast_to_gcc_expression): Fix type cast warning. 2008-12-11 Sebastian Pop * gcc.dg/graphite/pr37928.c: New. * gcc.dg/graphite/pr37883.c: New. * gcc.dg/graphite/pr38073.c: New. * gcc.dg/graphite/pr38125.c: New. * gfortran.dg/graphite/pr38083.f90: New. * gfortran.dg/graphite/pr37852.f90: New. * gfortran.dg/graphite/pr37980.f90: New. * gfortran.dg/graphite/id-2.f90: New. * gfortran.dg/graphite/id-4.f90: New. * gcc.dg/graphite/scop-18.c: Remove reduction, test for the number of detected scops. Copy exact same test for loop blocking... * gcc.dg/graphite/block-1.c: Fix the number of expected loops to be blocked as reductions are not handled. * gcc.dg/graphite/block-4.c: ...here. New. From-SVN: r142673 --- gcc/graphite.h | 107 ++++++++++++++++++++++++++++++++++++++------------------- 1 file changed, 71 insertions(+), 36 deletions(-) (limited to 'gcc/graphite.h') diff --git a/gcc/graphite.h b/gcc/graphite.h index 2e2904a..faae009 100644 --- a/gcc/graphite.h +++ b/gcc/graphite.h @@ -18,6 +18,9 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ +#ifndef GCC_GRAPHITE_H +#define GCC_GRAPHITE_H + #include "tree-data-ref.h" typedef struct graphite_bb *graphite_bb_p; @@ -31,7 +34,7 @@ static inline int scop_nb_loops (scop_p scop); static inline unsigned scop_nb_params (scop_p scop); static inline bool scop_contains_loop (scop_p scop, struct loop *loop); -struct graphite_bb +typedef struct graphite_bb { basic_block bb; scop_p scop; @@ -116,7 +119,7 @@ struct graphite_bb CloogMatrix *domain; /* Lists containing the restrictions of the conditional statements - dominating this bb. This bb can only be executed, if all conditions + dominating this bb. This bb can only be executed, if all conditions are true. Example: @@ -129,13 +132,13 @@ struct graphite_bb B } - So for B there is a additional condition (2i <= 8). + So for B there is an additional condition (2i <= 8). - TODO: Add this restrictions to the domain matrix. + TODO: Add these restrictions to the domain matrix. - List of COND_EXPR and SWITCH_EXPR. A COND_EXPR is true only if the - corresponding element in CONDITION_CASES is not NULL_TREE. For a - SWITCH_EXPR the corresponding element in CONDITION_CASES is a + List of COND_EXPR and SWITCH_EXPR. A COND_EXPR is true only if the + corresponding element in CONDITION_CASES is not NULL_TREE. For a + SWITCH_EXPR the corresponding element in CONDITION_CASES is a CASE_LABEL_EXPR. */ VEC (gimple, heap) *conditions; VEC (gimple, heap) *condition_cases; @@ -190,7 +193,7 @@ struct graphite_bb lambda_vector compressed_alpha_matrix; CloogMatrix *dynamic_schedule; VEC (data_reference_p, heap) *data_refs; -}; +} *gbb_p; #define GBB_BB(GBB) GBB->bb #define GBB_SCOP(GBB) GBB->scop @@ -234,7 +237,7 @@ gbb_loop_at_index (graphite_bb_p gb, int index) return VEC_index (loop_p, GBB_LOOPS (gb), index); } -/* Returns the corresponding loop iterator index for a gimple loop. */ +/* Returns the index of LOOP in the loop nest around GB. */ static inline int gbb_loop_index (graphite_bb_p gb, loop_p loop) @@ -305,8 +308,13 @@ struct scop /* ??? It looks like a global mapping loop_id -> cloog_loop would work. */ htab_t loop2cloog_loop; - /* CLooG representation of this SCOP. */ + /* Cloog representation of this scop. */ CloogProgram *program; + + /* Are we allowed to add more params? This is for debugging purpose. We + can only add new params before generating the bb domains, otherwise they + become invalid. */ + bool add_params; }; #define SCOP_BBS(S) S->bbs @@ -322,6 +330,7 @@ struct scop #define SCOP_STATIC_SCHEDULE(S) S->static_schedule #define SCOP_LOOPS(S) S->loops #define SCOP_LOOP_NEST(S) S->loop_nest +#define SCOP_ADD_PARAMS(S) S->add_params #define SCOP_PARAMS(S) S->params #define SCOP_OLDIVS(S) S->old_ivs #define SCOP_PROG(S) S->program @@ -335,8 +344,7 @@ extern void debug_gbb (graphite_bb_p, int); extern void dot_scop (scop_p); extern void dot_all_scops (void); extern void debug_clast_stmt (struct clast_stmt *); - - +extern void debug_rename_map (htab_t); extern void debug_loop_vec (graphite_bb_p gb); extern void debug_oldivs (scop_p); @@ -369,7 +377,6 @@ DEF_VEC_ALLOC_P(iv_stack_entry_p,heap); typedef VEC(iv_stack_entry_p, heap) **loop_iv_stack; extern void debug_loop_iv_stack (loop_iv_stack); - /* Return the number of gimple loops contained in SCOP. */ static inline int @@ -422,15 +429,6 @@ loop_domain_dim (unsigned int loop_num, scop_p scop) return cloog_domain_dim (cloog_loop_domain (slot->cloog_loop)) + 2; } -/* Returns the dimensionality of an enclosing loop iteration domain - with respect to enclosing SCoP for a given data reference REF. */ - -static inline int -ref_nb_loops (data_reference_p ref) -{ - return loop_domain_dim (loop_containing_stmt (DR_STMT (ref))->num, DR_SCOP (ref)); -} - /* Returns the dimensionality of a loop iteration vector in a loop iteration domain for a given loop (identified by LOOP_NUM) with respect to SCOP. */ @@ -521,22 +519,59 @@ scop_gimple_loop_depth (scop_p scop, loop_p loop) return depth; } -/* Associate a POLYHEDRON dependence description to two data - references A and B. */ -struct data_dependence_polyhedron +/* Static inline function prototypes. */ + +static inline unsigned scop_nb_params (scop_p scop); + +/* Returns true when BB is in SCOP. */ + +static inline bool +bb_in_scop_p (basic_block bb, scop_p scop) { - struct data_reference *a; - struct data_reference *b; - bool reversed_p; - bool loop_carried; /*TODO:konrad get rid of this, make level signed */ - signed level; - CloogDomain *polyhedron; -}; + return bitmap_bit_p (SCOP_BBS_B (scop), bb->index); +} -#define RDGE_DDP(E) ((struct data_dependence_polyhedron*) ((E)->data)) +/* Returns true when LOOP is in SCOP. */ -typedef struct data_dependence_polyhedron *ddp_p; +static inline bool +loop_in_scop_p (struct loop *loop, scop_p scop) +{ + return (bb_in_scop_p (loop->header, scop) + && bb_in_scop_p (loop->latch, scop)); +} + +/* Calculate the number of loops around LOOP in the SCOP. */ + +static inline int +nb_loops_around_loop_in_scop (struct loop *l, scop_p scop) +{ + int d = 0; + + for (; loop_in_scop_p (l, scop); d++, l = loop_outer (l)); + + return d; +} + +/* Calculate the number of loops around GB in the current SCOP. */ + +static inline int +nb_loops_around_gb (graphite_bb_p gb) +{ + return nb_loops_around_loop_in_scop (gbb_loop (gb), GBB_SCOP (gb)); +} + +/* Returns the dimensionality of an enclosing loop iteration domain + with respect to enclosing SCoP for a given data reference REF. The + returned dimensionality is homogeneous (depth of loop nest + number + of SCoP parameters + const). */ -DEF_VEC_P(ddp_p); -DEF_VEC_ALLOC_P(ddp_p,heap); +static inline int +ref_nb_loops (data_reference_p ref) +{ + loop_p loop = loop_containing_stmt (DR_STMT (ref)); + scop_p scop = DR_SCOP (ref); + + return nb_loops_around_loop_in_scop (loop, scop) + scop_nb_params (scop) + 2; +} +#endif /* GCC_GRAPHITE_H */ -- cgit v1.1