This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] [Graphite] Using SESE regions as black-boxes
- From: Antoniu Pop <antoniu dot pop at mines-paristech dot fr>
- To: gcc-graphite at googlegroups dot com, gcc-patches at gcc dot gnu dot org
- Date: Wed, 19 May 2010 17:25:12 +0200
- Subject: [PATCH] [Graphite] Using SESE regions as black-boxes
Hi,
This patch enables using SESE regions (instead of basic blocks) as
black-boxes in POLY_BB, so it allows hiding non-static control-flow,
function calls and non-affine subscripts as long as it is possible to
know that the region is actually well-behaved. The whole SESE region
is considered a single poly statement.
The functionality for deciding which code regions should be hidden
will come in subsequent patches.
The patch passes regression tests on the Graphite branch.
Changelog:
2010-05-19 Antoniu Pop <antoniu.pop@gmail.com>
* graphite-scop-detection.c (gbb_type): Added GBB_BLACK_BOX.
(get_bb_type): Return the new type when apropriate.
(scopdet_basic_block_info): New GBB_BLACK_BOX case in the switch.
* sese.c (new_bb_bb_def, bb_bb_map_hash, eq_bb_bb_map,
find_new_bb, insert_new_bb): New. Handle the mapping between old
BBs and new ones.
(copy_bb_and_scalar_dependences): Renamed to
copy_gbb_and_scalar_dependences and changed the parameters. The
function now can either copy a single BB or a whole black-boxed
SESE region when re-generating the gimple.
* sese.h (bb_bb_def): New.
(gimple_bb): Replaced BB by ENTRY and EXIT for SESE region
handling.
(GBB_BB): Removed.
(GBB_ENTRY, GBB_EXIT): New.
(gbb_loop): Adapted.
(gbb_from_bb): Moved from graphite-sese-to-poly.c.
* graphite-clast-to-gimple.c (translate_clast_user): Adapted.
* graphite-poly.c (print_pbb_domain, dump_gbb_cases,
dump_gbb_conditions, loop_to_lst, scop_to_lst): Adapted.
* graphite-poly.h (poly_bb, pbb_bb): Adapted and commented.
* graphite-sese-to-poly.c (new_gimple_bb, free_gimple_bb):
Constructor and destructor updated.
(try_generate_gimple_bb): Added traversal of the SESE region to
gather data references for the new case. The function now also
marks the visited BBs itself (and takes the bitmap as parameter)
as it may need to mark all the BBs in the SESE.
(build_scop_bbs_1): Adapted.
(find_params_in_bb): Replaced old GBB accessor.
(gbb_from_bb): Moved to sese.h as it is needed.
Index: gcc/graphite-scop-detection.c
===================================================================
--- gcc/graphite-scop-detection.c (revision 159556)
+++ gcc/graphite-scop-detection.c (working copy)
@@ -60,7 +60,8 @@
GBB_LOOP_EXIT,
GBB_COND_HEADER,
GBB_SIMPLE,
- GBB_LAST
+ GBB_LAST,
+ GBB_BLACK_BOX
} gbb_type;
/* Detect the type of BB. Loop headers are only marked, if they are
@@ -75,6 +76,14 @@
int nb_dom, nb_suc;
struct loop *loop = bb->loop_father;
+ /* If the gimple_bb has already been built, then this should already
+ be seen as a black box. */
+ if (gbb_from_bb (bb))
+ {
+ gcc_assert (GBB_EXIT (gbb_from_bb (bb)));
+ return GBB_BLACK_BOX;
+ }
+
/* Check, if we entry into a new loop. */
if (loop != last_loop)
{
@@ -451,6 +460,22 @@
switch (type)
{
+ case GBB_BLACK_BOX:
+ {
+ gimple_bb_p gbb = gbb_from_bb (bb);
+
+ /* For now we will consider that only SESE regions (i.e., no
+ single BB) can be considered black-boxes, though this may
+ change. */
+ gcc_assert (GBB_EXIT (gbb));
+
+ /* We skip the whole SESE of this WBB. */
+ result.next = single_succ (GBB_EXIT (gbb));
+ result.exits = false;
+ result.exit = single_succ (GBB_EXIT (gbb));
+ result.difficult = false;
+ break;
+ }
case GBB_LAST:
result.next = NULL;
result.exits = false;
Index: gcc/sese.c
===================================================================
--- gcc/sese.c (revision 159556)
+++ gcc/sese.c (working copy)
@@ -142,8 +142,66 @@
return (elt1->cloog_iv == elt2->cloog_iv);
}
-
+/* Construct bb_bb_def with OLD_BB and NEW_BB. */
+static bb_bb_def *
+new_bb_bb_def (basic_block old_bb, basic_block new_bb)
+{
+ bb_bb_def *bb_bb_p;
+ bb_bb_p = XNEW (bb_bb_def);
+ bb_bb_p->old_bb = old_bb;
+ bb_bb_p->new_bb = new_bb;
+ return bb_bb_p;
+}
+
+/* Hash function for data base element BB_BB. */
+
+static inline hashval_t
+bb_bb_map_hash (const void *bb_bb)
+{
+ return (hashval_t)(((const bb_bb_def *)bb_bb)->old_bb->index);
+}
+
+/* Compare data base element BB_BB1 and BB_BB2. */
+
+static inline int
+eq_bb_bb_map (const void *bb_bb1, const void *bb_bb2)
+{
+ const bb_bb_def *bb1 = (const bb_bb_def *) bb_bb1;
+ const bb_bb_def *bb2 = (const bb_bb_def *) bb_bb2;
+ return (bb1->old_bb->index == bb2->old_bb->index);
+}
+
+/* Find in BB_MAP the new copy BB of the OLD BB. */
+
+static inline basic_block
+find_new_bb (basic_block old, htab_t bb_map)
+{
+ bb_bb_def tmp;
+ PTR *x;
+
+ tmp.old_bb = old;
+ x = htab_find_slot (bb_map, &tmp, NO_INSERT);
+ if (!x || !*x)
+ return NULL;
+
+ return ((bb_bb_def *) (*x))->new_bb;
+}
+
+/* Insert in BB_MAP the copy NEW_BB of the OLD BB. */
+
+static inline void
+insert_new_bb (basic_block new_bb, basic_block old, htab_t bb_map)
+{
+ bb_bb_def tmp;
+ PTR *x;
+
+ tmp.old_bb = old;
+ x = htab_find_slot (bb_map, &tmp, INSERT);
+ if (x && !*x)
+ *x = new_bb_bb_def (old, new_bb);
+}
+
/* Record LOOP as occuring in REGION. */
static void
@@ -1426,18 +1484,93 @@
and returns the next edge following this new block. */
edge
-copy_bb_and_scalar_dependences (basic_block bb, sese region,
- edge next_e, htab_t map)
+copy_gbb_and_scalar_dependences (gimple_bb_p gbb, sese region,
+ edge next_e, htab_t map)
{
- basic_block new_bb = split_edge (next_e);
- next_e = single_succ_edge (new_bb);
- graphite_copy_stmts_from_block (bb, new_bb, map);
- remove_condition (new_bb);
- remove_phi_nodes (new_bb);
- expand_scalar_variables (new_bb, region, map);
- rename_variables (new_bb, map);
+ /* If this was a simple BB and not a SESE. */
+ if (GBB_EXIT (gbb) == NULL)
+ {
+ basic_block bb = GBB_ENTRY (gbb);
+ basic_block new_bb = split_edge (next_e);
+ next_e = single_succ_edge (new_bb);
+ graphite_copy_stmts_from_block (bb, new_bb, map);
+ remove_condition (new_bb);
+ remove_phi_nodes (new_bb);
+ expand_scalar_variables (new_bb, region, map);
+ rename_variables (new_bb, map);
+ }
+ else
+ {
+ /* The internal structure of the SESE must be replicated.
+ Conditions in the last block only should be removed. A SESE
+ should be assumed it has at least two blocks (the guards
+ should ensure that). */
+ htab_t bb_map = htab_create (10, bb_bb_map_hash, eq_bb_bb_map, free);
+ basic_block entry_bb = GBB_ENTRY (gbb);
+ basic_block exit_bb = GBB_EXIT (gbb);
+ basic_block new_post_exit_bb = next_e->dest;
+ VEC(basic_block,heap) *bbs = NULL;
+ basic_block bb;
+
+ VEC_safe_push (basic_block, heap, bbs, entry_bb);
+ gather_blocks_in_sese_region (entry_bb, exit_bb, &bbs);
+
+ /* Replicate all blocks. */
+ /*for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)*/
+ FOR_BB_BETWEEN(bb, entry_bb, single_succ(exit_bb), next_bb)
+ {
+ basic_block new_bb = split_edge (next_e);
+ next_e = single_succ_edge (new_bb);
+
+ graphite_copy_stmts_from_block (bb, new_bb, map);
+ remove_phi_nodes (new_bb);
+ if (bb == exit_bb) remove_condition (new_bb);
+ expand_scalar_variables (new_bb, region, map);
+ rename_variables (new_bb, map);
+
+ insert_new_bb (new_bb, bb, bb_map);
+ }
+
+ /* We need to fix-up the edges in the new SESE. */
+ /*for (i = 0; VEC_iterate (basic_block, bbs, i, bb); i++)*/
+ FOR_BB_BETWEEN(bb, entry_bb, single_succ(exit_bb), next_bb)
+ {
+ basic_block new_bb = find_new_bb (bb, bb_map);
+ edge e, n;
+ edge_iterator ei;
+
+ /* Always remove the existing edges as they serve no purpose
+ except for the entry (which would not be removed anyway
+ here) and exit ones. */
+ remove_edge (single_succ_edge (new_bb));
+
+ /* Copy all the edges form the original. */
+ FOR_EACH_EDGE (e, ei, bb->succs)
+ {
+ basic_block nsrc = find_new_bb (e->src, bb_map);
+ basic_block ndst;
+
+ if (bb == exit_bb)
+ ndst = new_post_exit_bb;
+ else
+ ndst = find_new_bb (e->dest, bb_map);
+
+ gcc_assert (nsrc != NULL && ndst != NULL);
+
+ n = unchecked_make_edge (nsrc, ndst, e->flags);
+ n->probability = e->probability;
+ }
+ }
+
+ bb = find_new_bb (exit_bb, bb_map);
+ next_e = single_succ_edge (bb);
+ recompute_all_dominators ();
+
+ VEC_free (basic_block, heap, bbs);
+ htab_delete (bb_map);
+ }
return next_e;
}
Index: gcc/sese.h
===================================================================
--- gcc/sese.h (revision 159556)
+++ gcc/sese.h (working copy)
@@ -52,12 +52,14 @@
#define SESE_LOOP_NEST(S) (S->loop_nest)
#define SESE_ADD_PARAMS(S) (S->add_params)
+struct gimple_bb;
+
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 sese_adjust_liveout_phis (sese, htab_t, 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_gbb_and_scalar_dependences (struct gimple_bb *, sese, edge, htab_t);
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);
@@ -318,9 +320,22 @@
calculate_dominance_info (CDI_POST_DOMINATORS);
}
+/* Mapping the new gimple BBs in the code generated from the CLAST to
+ the old gimple BBs. */
+
+typedef struct bb_bb_def
+{
+ basic_block old_bb;
+ basic_block new_bb;
+} bb_bb_def;
+
+/* Gimple Black-Box. */
+
typedef struct gimple_bb
{
- basic_block bb;
+ /* ENTRY and EXIT blocks of what must be a SESE region. If a single
+ BB is used, exit should be NULL. */
+ basic_block entry, exit;
/* Lists containing the restrictions of the conditional statements
dominating this bb. This bb can only be executed, if all conditions
@@ -347,7 +362,8 @@
VEC (data_reference_p, heap) *data_refs;
} *gimple_bb_p;
-#define GBB_BB(GBB) GBB->bb
+#define GBB_ENTRY(GBB) GBB->entry
+#define GBB_EXIT(GBB) GBB->exit
#define GBB_DATA_REFS(GBB) GBB->data_refs
#define GBB_CONDITIONS(GBB) GBB->conditions
#define GBB_CONDITION_CASES(GBB) GBB->condition_cases
@@ -355,11 +371,19 @@
/* Return the innermost loop that contains the basic block GBB. */
static inline struct loop *
-gbb_loop (struct gimple_bb *gbb)
+gbb_loop (gimple_bb_p gbb)
{
- return GBB_BB (gbb)->loop_father;
+ return GBB_ENTRY (gbb)->loop_father;
}
+/* Returns a gimple_bb from BB. */
+
+static inline gimple_bb_p
+gbb_from_bb (basic_block bb)
+{
+ return (gimple_bb_p) bb->aux;
+}
+
/* Returns the gimple loop, that corresponds to the loop_iterator_INDEX.
If there is no corresponding gimple loop, we return NULL. */
Index: gcc/graphite-clast-to-gimple.c
===================================================================
--- gcc/graphite-clast-to-gimple.c (revision 159556)
+++ gcc/graphite-clast-to-gimple.c (working copy)
@@ -995,13 +995,13 @@
poly_bb_p pbb = (poly_bb_p) cloog_statement_usr (stmt->statement);
gbb = PBB_BLACK_BOX (pbb);
- if (GBB_BB (gbb) == ENTRY_BLOCK_PTR)
+ if (GBB_ENTRY (gbb) == ENTRY_BLOCK_PTR)
return next_e;
build_iv_mapping (rename_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 = copy_gbb_and_scalar_dependences (gbb, region,
+ next_e, rename_map);
new_bb = next_e->src;
mark_bb_with_pbb (pbb, new_bb, bb_pbb_mapping);
update_ssa (TODO_update_ssa);
Index: gcc/graphite-poly.c
===================================================================
--- gcc/graphite-poly.c (revision 159556)
+++ gcc/graphite-poly.c (working copy)
@@ -596,7 +596,7 @@
if (verbosity > 0)
{
- fprintf (file, "# Iteration domain of bb_%d (\n", GBB_BB (gbb)->index);
+ fprintf (file, "# Iteration domain of bb_%d (\n", GBB_ENTRY (gbb)->index);
fprintf (file, "# eq");
for (i = 0; i < pbb_dim_iter_domain (pbb); i++)
@@ -633,7 +633,7 @@
if (VEC_empty (gimple, cases))
return;
- fprintf (file, "# cases bb_%d (\n", GBB_BB (gbb)->index);
+ fprintf (file, "# cases bb_%d (\n", GBB_ENTRY (gbb)->index);
for (i = 0; VEC_iterate (gimple, cases, i, stmt); i++)
{
@@ -660,7 +660,7 @@
if (VEC_empty (gimple, conditions))
return;
- fprintf (file, "# conditions bb_%d (\n", GBB_BB (gbb)->index);
+ fprintf (file, "# conditions bb_%d (\n", GBB_ENTRY (gbb)->index);
for (i = 0; VEC_iterate (gimple, conditions, i, stmt); i++)
{
@@ -1161,7 +1161,7 @@
for (; VEC_iterate (poly_bb_p, bbs, *i, pbb); (*i)++)
{
lst_p stmt;
- basic_block bb = GBB_BB (PBB_BLACK_BOX (pbb));
+ basic_block bb = GBB_ENTRY (PBB_BLACK_BOX (pbb));
if (bb->loop_father == loop)
stmt = new_lst_stmt (pbb);
@@ -1200,7 +1200,7 @@
for (i = 0; i < n; i++)
{
poly_bb_p pbb = VEC_index (poly_bb_p, SCOP_BBS (scop), i);
- loop_p loop = outermost_loop_in_sese (region, GBB_BB (PBB_BLACK_BOX (pbb)));
+ loop_p loop = outermost_loop_in_sese (region, GBB_ENTRY (PBB_BLACK_BOX (pbb)));
if (loop_in_sese_p (loop, region))
res = loop_to_lst (loop, SCOP_BBS (scop), &i);
Index: gcc/graphite-poly.h
===================================================================
--- gcc/graphite-poly.h (revision 159556)
+++ gcc/graphite-poly.h (working copy)
@@ -279,7 +279,8 @@
struct poly_bb
{
- /* Pointer to a basic block or a statement in the compiler. */
+ /* Pointer to a GIMPLE Black Box, which is a SESE region that will
+ be seen as a black box. */
void *black_box;
/* Pointer to the SCOP containing this PBB. */
@@ -391,7 +392,7 @@
static inline basic_block
pbb_bb (poly_bb_p pbb)
{
- return GBB_BB (PBB_BLACK_BOX (pbb));
+ return GBB_ENTRY (PBB_BLACK_BOX (pbb));
}
/* The index of the PBB. */
Index: gcc/graphite-sese-to-poly.c
===================================================================
--- gcc/graphite-sese-to-poly.c (revision 159556)
+++ gcc/graphite-sese-to-poly.c (working copy)
@@ -272,13 +272,15 @@
/* Store the GRAPHITE representation of BB. */
static gimple_bb_p
-new_gimple_bb (basic_block bb, VEC (data_reference_p, heap) *drs)
+new_gimple_bb (basic_block entry, basic_block exit,
+ VEC (data_reference_p, heap) *drs)
{
struct gimple_bb *gbb;
gbb = XNEW (struct gimple_bb);
- bb->aux = gbb;
- GBB_BB (gbb) = bb;
+ entry->aux = gbb;
+ GBB_ENTRY (gbb) = entry;
+ GBB_EXIT (gbb) = exit;
GBB_DATA_REFS (gbb) = drs;
GBB_CONDITIONS (gbb) = NULL;
GBB_CONDITION_CASES (gbb) = NULL;
@@ -314,7 +316,7 @@
VEC_free (gimple, heap, GBB_CONDITIONS (gbb));
VEC_free (gimple, heap, GBB_CONDITION_CASES (gbb));
- GBB_BB (gbb)->aux = 0;
+ GBB_ENTRY (gbb)->aux = 0;
XDELETE (gbb);
}
@@ -352,24 +354,68 @@
information. */
static void
-try_generate_gimple_bb (scop_p scop, basic_block bb, sbitmap reductions)
+try_generate_gimple_bb (scop_p scop, basic_block bb, sbitmap reductions, sbitmap visited)
{
VEC (data_reference_p, heap) *drs = VEC_alloc (data_reference_p, heap, 5);
loop_p nest = outermost_loop_in_sese (SCOP_REGION (scop), bb);
gimple_stmt_iterator gsi;
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ /* Check whether this block is the entry point of a black boxed
+ region. */
+ gimple_bb_p gbb = gbb_from_bb (bb);
+
+ if (gbb == NULL || GBB_EXIT (gbb) == NULL)
{
- gimple stmt = gsi_stmt (gsi);
- if (!is_gimple_debug (stmt))
- graphite_find_data_references_in_stmt (nest, stmt, &drs);
+ gcc_assert (gbb == NULL);
+
+ /* Base case: this block has not been pre-black-boxed. */
+ for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ {
+ gimple stmt = gsi_stmt (gsi);
+ if (!is_gimple_debug (stmt))
+ graphite_find_data_references_in_stmt (nest, stmt, &drs);
+ }
+
+ if (!graphite_stmt_p (SCOP_REGION (scop), bb, drs))
+ free_data_refs (drs);
+ else
+ new_poly_bb (scop, new_gimple_bb (bb, NULL, drs),
+ TEST_BIT (reductions, bb->index));
+
+ SET_BIT (visited, bb->index);
}
+ else
+ {
+ /* This is the entry point of a SESE region that has been
+ selected to be black-boxed.
- if (!graphite_stmt_p (SCOP_REGION (scop), bb, drs))
- free_data_refs (drs);
- else
- new_poly_bb (scop, new_gimple_bb (bb, drs), TEST_BIT (reductions,
- bb->index));
+ FIXME: later, there may be a possibility to avoid looking at
+ the data refs within the SESE in some cases like if this
+ black box corresponds to OpenMP annotations that explicit all
+ memory effects. For now, gather all data refs in the whole
+ SESE. */
+ VEC(basic_block,heap) *blocks_in_sese = NULL;
+ basic_block it_bb;
+ int i;
+
+ VEC_safe_push (basic_block, heap, blocks_in_sese, GBB_ENTRY (gbb));
+ gather_blocks_in_sese_region (GBB_ENTRY (gbb), GBB_EXIT (gbb),
+ &blocks_in_sese);
+ for (i = 0; VEC_iterate (basic_block, blocks_in_sese, i, it_bb); i++)
+ {
+ for (gsi = gsi_start_bb (it_bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ {
+ gimple stmt = gsi_stmt (gsi);
+ if (!is_gimple_debug (stmt))
+ graphite_find_data_references_in_stmt (nest, stmt, &drs);
+ }
+ SET_BIT (visited, it_bb->index);
+ }
+
+ GBB_DATA_REFS (gbb) = drs;
+ new_poly_bb (scop, gbb, TEST_BIT (reductions, bb->index));
+ VEC_free (basic_block, heap, blocks_in_sese);
+ }
}
/* Returns true if all predecessors of BB, that are not dominated by BB, are
@@ -433,8 +479,7 @@
|| !bb_in_sese_p (bb, region))
return;
- try_generate_gimple_bb (scop, bb, reductions);
- SET_BIT (visited, bb->index);
+ try_generate_gimple_bb (scop, bb, reductions, visited);
dom = get_dominated_by (CDI_DOMINATORS, bb);
@@ -962,7 +1007,7 @@
unsigned j;
data_reference_p dr;
gimple stmt;
- loop_p loop = GBB_BB (gbb)->loop_father;
+ loop_p loop = gbb_loop (gbb);
mpz_t one;
mpz_init (one);
@@ -1028,14 +1073,6 @@
(&SCOP_CONTEXT (scop), scop_nb_params (scop), 0);
}
-/* Returns a gimple_bb from BB. */
-
-static inline gimple_bb_p
-gbb_from_bb (basic_block bb)
-{
- return (gimple_bb_p) bb->aux;
-}
-
/* Insert in the SCOP context constraints from the estimation of the
number of iterations. UB_EXPR is a linear expression describing
the number of iterations in a loop. This expression is bounded by
Index: gcc/ChangeLog.graphite
===================================================================
--- gcc/ChangeLog.graphite (revision 159556)
+++ gcc/ChangeLog.graphite (working copy)
@@ -1,3 +1,40 @@
+2010-05-19 Antoniu Pop <antoniu.pop@gmail.com>
+
+ * graphite-scop-detection.c (gbb_type): Added GBB_BLACK_BOX.
+ (get_bb_type): Return the new type when apropriate.
+ (scopdet_basic_block_info): New GBB_BLACK_BOX case in the switch.
+
+ * sese.c (new_bb_bb_def, bb_bb_map_hash, eq_bb_bb_map,
+ find_new_bb, insert_new_bb): New. Handle the mapping between old
+ BBs and new ones.
+ (copy_bb_and_scalar_dependences): Renamed to
+ copy_gbb_and_scalar_dependences and changed the parameters. The
+ function now can either copy a single BB or a whole black-boxed
+ SESE region when re-generating the gimple.
+
+ * sese.h (bb_bb_def): New.
+ (gimple_bb): Replaced BB by ENTRY and EXIT for SESE region
+ handling.
+ (GBB_BB): Removed.
+ (GBB_ENTRY, GBB_EXIT): New.
+ (gbb_loop): Adapted.
+ (gbb_from_bb): Moved from graphite-sese-to-poly.c.
+
+ * graphite-clast-to-gimple.c (translate_clast_user): Adapted.
+ * graphite-poly.c (print_pbb_domain, dump_gbb_cases,
+ dump_gbb_conditions, loop_to_lst, scop_to_lst): Adapted.
+ * graphite-poly.h (poly_bb, pbb_bb): Adapted and commented.
+
+ * graphite-sese-to-poly.c (new_gimple_bb, free_gimple_bb):
+ Constructor and destructor updated.
+ (try_generate_gimple_bb): Added traversal of the SESE region to
+ gather data references for the new case. The function now also
+ marks the visited BBs itself (and takes the bitmap as parameter)
+ as it may need to mark all the BBs in the SESE.
+ (build_scop_bbs_1): Adapted.
+ (find_params_in_bb): Replaced old GBB accessor.
+ (gbb_from_bb): Moved to sese.h as it is needed.
+
2010-05-07 Sebastian Pop <sebastian.pop@amd.com>
* graphite-clast-to-gimple.c (graphite_create_new_loop_guard): Fix