/* Conversion of SESE regions to Polyhedra.
- Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 2009-2015 Free Software Foundation, Inc.
Contributed by Sebastian Pop <sebastian.pop@amd.com>.
This file is part of GCC.
#include "config.h"
-#ifdef HAVE_cloog
+#ifdef HAVE_isl
#include <isl/set.h>
#include <isl/map.h>
#include <isl/union_map.h>
#include <isl/constraint.h>
#include <isl/aff.h>
-#include <cloog/cloog.h>
-#include <cloog/cloog.h>
-#include <cloog/isl/domain.h>
+#include <isl/val.h>
+
+/* Since ISL-0.13, the extern is in val_gmp.h. */
+#if !defined(HAVE_ISL_SCHED_CONSTRAINTS_COMPUTE_SCHEDULE) && defined(__cplusplus)
+extern "C" {
+#endif
+#include <isl/val_gmp.h>
+#if !defined(HAVE_ISL_SCHED_CONSTRAINTS_COMPUTE_SCHEDULE) && defined(__cplusplus)
+}
+#endif
#endif
#include "system.h"
#include "coretypes.h"
-#include "tree-flow.h"
+#include "hash-set.h"
+#include "machmode.h"
+#include "vec.h"
+#include "double-int.h"
+#include "input.h"
+#include "alias.h"
+#include "symtab.h"
+#include "options.h"
+#include "wide-int.h"
+#include "inchash.h"
+#include "tree.h"
+#include "fold-const.h"
+#include "predict.h"
+#include "tm.h"
+#include "hard-reg-set.h"
+#include "function.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "basic-block.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "gimple-expr.h"
+#include "is-a.h"
+#include "gimple.h"
+#include "gimple-iterator.h"
+#include "gimplify.h"
+#include "gimplify-me.h"
+#include "gimple-ssa.h"
+#include "tree-cfg.h"
+#include "tree-phinodes.h"
+#include "ssa-iterators.h"
+#include "stringpool.h"
+#include "tree-ssanames.h"
+#include "tree-ssa-loop-manip.h"
+#include "tree-ssa-loop-niter.h"
+#include "tree-ssa-loop.h"
+#include "tree-into-ssa.h"
#include "tree-pass.h"
#include "cfgloop.h"
#include "tree-chrec.h"
#include "tree-scalar-evolution.h"
#include "domwalk.h"
#include "sese.h"
-
-#ifdef HAVE_cloog
+#include "tree-ssa-propagate.h"
+
+#ifdef HAVE_isl
+#include "hashtab.h"
+#include "rtl.h"
+#include "flags.h"
+#include "statistics.h"
+#include "real.h"
+#include "fixed-value.h"
+#include "insn-config.h"
+#include "expmed.h"
+#include "dojump.h"
+#include "explow.h"
+#include "calls.h"
+#include "emit-rtl.h"
+#include "varasm.h"
+#include "stmt.h"
+#include "expr.h"
#include "graphite-poly.h"
#include "graphite-sese-to-poly.h"
static inline void
tree_int_to_gmp (tree t, mpz_t res)
{
- double_int di = tree_to_double_int (t);
- mpz_set_double_int (res, di, TYPE_UNSIGNED (TREE_TYPE (t)));
+ wi::to_mpz (t, res, TYPE_SIGN (TREE_TYPE (t)));
}
/* Returns the index of the PHI argument defined in the outermost
loop. */
static size_t
-phi_arg_in_outermost_loop (gimple phi)
+phi_arg_in_outermost_loop (gphi *phi)
{
loop_p loop = gimple_bb (phi)->loop_father;
size_t i, res = 0;
PSI by inserting on the loop ENTRY edge assignment "RES = INIT". */
static void
-remove_simple_copy_phi (gimple_stmt_iterator *psi)
+remove_simple_copy_phi (gphi_iterator *psi)
{
- gimple phi = gsi_stmt (*psi);
+ gphi *phi = psi->phi ();
tree res = gimple_phi_result (phi);
size_t entry = phi_arg_in_outermost_loop (phi);
tree init = gimple_phi_arg_def (phi, entry);
- gimple stmt = gimple_build_assign (res, init);
+ gassign *stmt = gimple_build_assign (res, init);
edge e = gimple_phi_arg_edge (phi, entry);
remove_phi_node (psi, false);
gsi_insert_on_edge_immediate (e, stmt);
- SSA_NAME_DEF_STMT (res) = stmt;
}
/* Removes an invariant phi node at position PSI by inserting on the
loop ENTRY edge the assignment RES = INIT. */
static void
-remove_invariant_phi (sese region, gimple_stmt_iterator *psi)
+remove_invariant_phi (sese region, gphi_iterator *psi)
{
- gimple phi = gsi_stmt (*psi);
+ gphi *phi = psi->phi ();
loop_p loop = loop_containing_stmt (phi);
tree res = gimple_phi_result (phi);
tree scev = scalar_evolution_in_region (region, loop, res);
size_t entry = phi_arg_in_outermost_loop (phi);
edge e = gimple_phi_arg_edge (phi, entry);
tree var;
- gimple stmt;
+ gassign *stmt;
gimple_seq stmts = NULL;
if (tree_contains_chrecs (scev, NULL))
/* Returns true when the phi node at PSI is of the form "a = phi (a, x)". */
static inline bool
-simple_copy_phi_p (gimple phi)
+simple_copy_phi_p (gphi *phi)
{
tree res;
be considered. */
static bool
-reduction_phi_p (sese region, gimple_stmt_iterator *psi)
+reduction_phi_p (sese region, gphi_iterator *psi)
{
loop_p loop;
- gimple phi = gsi_stmt (*psi);
+ gphi *phi = psi->phi ();
tree res = gimple_phi_result (phi);
loop = loop_containing_stmt (phi);
/* 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 bb, vec<data_reference_p> drs)
{
struct gimple_bb *gbb;
bb->aux = gbb;
GBB_BB (gbb) = bb;
GBB_DATA_REFS (gbb) = drs;
- GBB_CONDITIONS (gbb) = NULL;
- GBB_CONDITION_CASES (gbb) = NULL;
+ GBB_CONDITIONS (gbb).create (0);
+ GBB_CONDITION_CASES (gbb).create (0);
return gbb;
}
static void
-free_data_refs_aux (VEC (data_reference_p, heap) *datarefs)
+free_data_refs_aux (vec<data_reference_p> datarefs)
{
unsigned int i;
struct data_reference *dr;
- FOR_EACH_VEC_ELT (data_reference_p, datarefs, i, dr)
+ FOR_EACH_VEC_ELT (datarefs, i, dr)
if (dr->aux)
{
base_alias_pair *bap = (base_alias_pair *)(dr->aux);
free_data_refs_aux (GBB_DATA_REFS (gbb));
free_data_refs (GBB_DATA_REFS (gbb));
- VEC_free (gimple, heap, GBB_CONDITIONS (gbb));
- VEC_free (gimple, heap, GBB_CONDITION_CASES (gbb));
+ GBB_CONDITIONS (gbb).release ();
+ GBB_CONDITION_CASES (gbb).release ();
GBB_BB (gbb)->aux = 0;
XDELETE (gbb);
}
int i;
poly_bb_p pbb;
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
+ FOR_EACH_VEC_ELT (SCOP_BBS (scop), i, pbb)
free_gimple_bb (PBB_BLACK_BOX (pbb));
}
/* Deletes all scops in SCOPS. */
void
-free_scops (VEC (scop_p, heap) *scops)
+free_scops (vec<scop_p> scops)
{
int i;
scop_p scop;
- FOR_EACH_VEC_ELT (scop_p, scops, i, scop)
+ FOR_EACH_VEC_ELT (scops, i, scop)
{
remove_gbbs_in_scop (scop);
free_sese (SCOP_REGION (scop));
free_scop (scop);
}
- VEC_free (scop_p, heap, scops);
+ scops.release ();
}
/* Same as outermost_loop_in_sese, returns the outermost loop
static gimple_bb_p
try_generate_gimple_bb (scop_p scop, basic_block bb)
{
- VEC (data_reference_p, heap) *drs = VEC_alloc (data_reference_p, heap, 5);
+ vec<data_reference_p> drs;
+ drs.create (5);
sese region = SCOP_REGION (scop);
loop_p nest = outermost_loop_in_sese_1 (region, bb);
gimple_stmt_iterator gsi;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
- if (!TEST_BIT (map, e->src->index)
+ if (!bitmap_bit_p (map, e->src->index)
&& !dominated_by_p (CDI_DOMINATORS, e->src, bb))
return false;
a deepest loop level. */
static void
-graphite_sort_dominated_info (VEC (basic_block, heap) *dom)
+graphite_sort_dominated_info (vec<basic_block> dom)
{
- VEC_qsort (basic_block, dom, compare_bb_depths);
+ dom.qsort (compare_bb_depths);
}
/* Recursive helper function for build_scops_bbs. */
build_scop_bbs_1 (scop_p scop, sbitmap visited, basic_block bb)
{
sese region = SCOP_REGION (scop);
- VEC (basic_block, heap) *dom;
+ vec<basic_block> dom;
poly_bb_p pbb;
- if (TEST_BIT (visited, bb->index)
+ if (bitmap_bit_p (visited, bb->index)
|| !bb_in_sese_p (bb, region))
return;
pbb = new_poly_bb (scop, try_generate_gimple_bb (scop, bb));
- VEC_safe_push (poly_bb_p, heap, SCOP_BBS (scop), pbb);
- SET_BIT (visited, bb->index);
+ SCOP_BBS (scop).safe_push (pbb);
+ bitmap_set_bit (visited, bb->index);
dom = get_dominated_by (CDI_DOMINATORS, bb);
- if (dom == NULL)
+ if (!dom.exists ())
return;
graphite_sort_dominated_info (dom);
- while (!VEC_empty (basic_block, dom))
+ while (!dom.is_empty ())
{
int i;
basic_block dom_bb;
- FOR_EACH_VEC_ELT (basic_block, dom, i, dom_bb)
+ FOR_EACH_VEC_ELT (dom, i, dom_bb)
if (all_non_dominated_preds_marked_p (dom_bb, visited))
{
build_scop_bbs_1 (scop, visited, dom_bb);
- VEC_unordered_remove (basic_block, dom, i);
+ dom.unordered_remove (i);
break;
}
}
- VEC_free (basic_block, heap, dom);
+ dom.release ();
}
/* Gather the basic blocks belonging to the SCOP. */
static void
build_scop_bbs (scop_p scop)
{
- sbitmap visited = sbitmap_alloc (last_basic_block);
+ sbitmap visited = sbitmap_alloc (last_basic_block_for_fn (cfun));
sese region = SCOP_REGION (scop);
- sbitmap_zero (visited);
+ bitmap_clear (visited);
build_scop_bbs_1 (scop, visited, SESE_ENTRY_BB (region));
sbitmap_free (visited);
}
int i;
int nb_iterators = pbb_dim_iter_domain (pbb);
int used_scattering_dimensions = nb_iterators * 2 + 1;
- isl_int val;
+ isl_val *val;
isl_space *dc, *dm;
gcc_assert (scattering_dimensions >= used_scattering_dimensions);
- isl_int_init (val);
-
dc = isl_set_get_space (pbb->domain);
dm = isl_space_add_dims (isl_space_from_domain (dc),
isl_dim_out, scattering_dimensions);
isl_constraint *c = isl_equality_alloc
(isl_local_space_from_space (isl_map_get_space (pbb->schedule)));
- if (0 != isl_aff_get_coefficient (static_sched, isl_dim_in,
- i / 2, &val))
- gcc_unreachable ();
+ val = isl_aff_get_coefficient_val (static_sched, isl_dim_in, i / 2);
- isl_int_neg (val, val);
- c = isl_constraint_set_constant (c, val);
+ val = isl_val_neg (val);
+ c = isl_constraint_set_constant_val (c, val);
c = isl_constraint_set_coefficient_si (c, isl_dim_out, i, 1);
pbb->schedule = isl_map_add_constraint (pbb->schedule, c);
}
}
}
- isl_int_clear (val);
-
pbb->transformed = isl_map_copy (pbb->schedule);
}
isl_space *dc = isl_set_get_space (scop->context);
isl_aff *static_sched;
- dc = isl_space_add_dims (dc, isl_dim_set, number_of_loops());
+ dc = isl_space_add_dims (dc, isl_dim_set, number_of_loops (cfun));
static_sched = isl_aff_zero_on_domain (isl_local_space_from_space (dc));
/* We have to start schedules at 0 on the first component and
incremented before copying. */
static_sched = isl_aff_add_coefficient_si (static_sched, isl_dim_in, 0, -1);
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
+ FOR_EACH_VEC_ELT (SCOP_BBS (scop), i, pbb)
{
gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
int prefix;
isl_pw_aff *lhs = extract_affine (s, CHREC_LEFT (e), isl_space_copy (space));
isl_pw_aff *rhs = extract_affine (s, CHREC_RIGHT (e), isl_space_copy (space));
isl_local_space *ls = isl_local_space_from_space (space);
- unsigned pos = sese_loop_depth ((sese) s->region,
- get_loop (CHREC_VARIABLE (e))) - 1;
+ unsigned pos = sese_loop_depth ((sese) s->region, get_chrec_loop (e)) - 1;
isl_aff *loop = isl_aff_set_coefficient_si
(isl_aff_zero_on_domain (ls), isl_dim_in, pos, 1);
isl_pw_aff *l = isl_pw_aff_from_aff (loop);
id = isl_id_for_ssa_name (s, e);
dimension = isl_space_find_dim_by_id (space, isl_dim_param, id);
- isl_id_free(id);
+ isl_id_free (id);
dom = isl_set_universe (isl_space_copy (space));
aff = isl_aff_zero_on_domain (isl_local_space_from_space (space));
aff = isl_aff_add_coefficient_si (aff, isl_dim_param, dimension, 1);
isl_local_space *ls = isl_local_space_from_space (isl_space_copy (space));
isl_aff *aff = isl_aff_zero_on_domain (ls);
isl_set *dom = isl_set_universe (space);
- isl_int v;
+ isl_val *v;
+ isl_ctx *ct;
- isl_int_init (v);
- isl_int_set_gmp (v, g);
- aff = isl_aff_add_constant (aff, v);
- isl_int_clear (v);
+ ct = isl_aff_get_ctx (aff);
+ v = isl_val_int_from_gmp (ct, g);
+ aff = isl_aff_add_constant_val (aff, v);
return isl_pw_aff_alloc (dom, aff);
}
/* Compute pwaff mod 2^width. */
+extern isl_ctx *the_isl_ctx;
+
static isl_pw_aff *
wrap (isl_pw_aff *pwaff, unsigned width)
{
- isl_int mod;
-
- isl_int_init (mod);
- isl_int_set_si (mod, 1);
- isl_int_mul_2exp (mod, mod, width);
+ isl_val *mod;
- pwaff = isl_pw_aff_mod (pwaff, mod);
-
- isl_int_clear (mod);
+ mod = isl_val_int_from_ui(the_isl_ctx, width);
+ mod = isl_val_2exp (mod);
+ pwaff = isl_pw_aff_mod_val (pwaff, mod);
return pwaff;
}
gcc_assert (TREE_CODE (name) == SSA_NAME);
- FOR_EACH_VEC_ELT (tree, SESE_PARAMS (region), i, p)
+ FOR_EACH_VEC_ELT (SESE_PARAMS (region), i, p)
if (p == name)
return i;
gcc_assert (SESE_ADD_PARAMS (region));
- i = VEC_length (tree, SESE_PARAMS (region));
- VEC_safe_push (tree, heap, SESE_PARAMS (region), name);
+ i = SESE_PARAMS (region).length ();
+ SESE_PARAMS (region).safe_push (name);
return i;
}
loop_p loop = GBB_BB (gbb)->loop_father;
/* Find parameters in the access functions of data references. */
- FOR_EACH_VEC_ELT (data_reference_p, GBB_DATA_REFS (gbb), i, dr)
+ FOR_EACH_VEC_ELT (GBB_DATA_REFS (gbb), i, dr)
for (j = 0; j < DR_NUM_DIMENSIONS (dr); j++)
scan_tree_for_params (region, DR_ACCESS_FN (dr, j));
/* Find parameters in conditional statements. */
- FOR_EACH_VEC_ELT (gimple, GBB_CONDITIONS (gbb), i, stmt)
+ FOR_EACH_VEC_ELT (GBB_CONDITIONS (gbb), i, stmt)
{
tree lhs = scalar_evolution_in_region (region, loop,
gimple_cond_lhs (stmt));
int nbp;
/* Find the parameters used in the loop bounds. */
- FOR_EACH_VEC_ELT (loop_p, SESE_LOOP_NEST (region), i, loop)
+ FOR_EACH_VEC_ELT (SESE_LOOP_NEST (region), i, loop)
{
tree nb_iters = number_of_latch_executions (loop);
}
/* Find the parameters used in data accesses. */
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
+ FOR_EACH_VEC_ELT (SCOP_BBS (scop), i, pbb)
find_params_in_bb (region, PBB_BLACK_BOX (pbb));
nbp = sese_nb_params (region);
tree e;
isl_space *space = isl_space_set_alloc (scop->ctx, nbp, 0);
- FOR_EACH_VEC_ELT (tree, SESE_PARAMS (region), i, e)
+ FOR_EACH_VEC_ELT (SESE_PARAMS (region), i, e)
space = isl_space_set_dim_id (space, isl_dim_param, i,
isl_id_for_ssa_name (scop, e));
isl_space *space;
isl_constraint *c;
int pos = isl_set_dim (outer, isl_dim_set);
- isl_int v;
+ isl_val *v;
mpz_t g;
mpz_init (g);
- isl_int_init (v);
inner = isl_set_add_dims (inner, isl_dim_set, 1);
space = isl_set_get_space (inner);
if (TREE_CODE (nb_iters) == INTEGER_CST)
{
c = isl_inequality_alloc
- (isl_local_space_from_space(isl_space_copy (space)));
+ (isl_local_space_from_space (isl_space_copy (space)));
c = isl_constraint_set_coefficient_si (c, isl_dim_set, pos, -1);
tree_int_to_gmp (nb_iters, g);
- isl_int_set_gmp (v, g);
- c = isl_constraint_set_constant (c, v);
+ v = isl_val_int_from_gmp (the_isl_ctx, g);
+ c = isl_constraint_set_constant_val (c, v);
inner = isl_set_add_constraint (inner, c);
}
/* loop_i <= expr_nb_iters */
else if (!chrec_contains_undetermined (nb_iters))
{
- double_int nit;
+ widest_int nit;
isl_pw_aff *aff;
isl_set *valid;
isl_local_space *ls;
isl_constraint *c;
mpz_init (g);
- mpz_set_double_int (g, nit, false);
+ wi::to_mpz (nit, g, SIGNED);
mpz_sub_ui (g, g, 1);
approx = extract_affine_gmp (g, isl_set_get_space (inner));
x = isl_pw_aff_ge_set (approx, aff);
c = isl_inequality_alloc
(isl_local_space_from_space (isl_space_copy (space)));
c = isl_constraint_set_coefficient_si (c, isl_dim_set, pos, -1);
- isl_int_set_gmp (v, g);
+ v = isl_val_int_from_gmp (the_isl_ctx, g);
mpz_clear (g);
- c = isl_constraint_set_constant (c, v);
+ c = isl_constraint_set_constant_val (c, v);
inner = isl_set_add_constraint (inner, c);
}
+ else
+ isl_pw_aff_free (aff);
}
else
gcc_unreachable ();
isl_set_free (outer);
isl_space_free (space);
- isl_int_clear (v);
mpz_clear (g);
}
inequalities. */
static void
-add_condition_to_pbb (poly_bb_p pbb, gimple stmt, enum tree_code code)
+add_condition_to_pbb (poly_bb_p pbb, gcond *stmt, enum tree_code code)
{
isl_pw_aff *lhs = create_pw_aff_from_tree (pbb, gimple_cond_lhs (stmt));
isl_pw_aff *rhs = create_pw_aff_from_tree (pbb, gimple_cond_rhs (stmt));
break;
default:
- isl_pw_aff_free(lhs);
- isl_pw_aff_free(rhs);
+ isl_pw_aff_free (lhs);
+ isl_pw_aff_free (rhs);
return;
}
gimple stmt;
gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
- if (VEC_empty (gimple, GBB_CONDITIONS (gbb)))
+ if (GBB_CONDITIONS (gbb).is_empty ())
return;
- FOR_EACH_VEC_ELT (gimple, GBB_CONDITIONS (gbb), i, stmt)
+ FOR_EACH_VEC_ELT (GBB_CONDITIONS (gbb), i, stmt)
switch (gimple_code (stmt))
{
case GIMPLE_COND:
{
- enum tree_code code = gimple_cond_code (stmt);
+ gcond *cond_stmt = as_a <gcond *> (stmt);
+ enum tree_code code = gimple_cond_code (cond_stmt);
/* The conditions for ELSE-branches are inverted. */
- if (!VEC_index (gimple, GBB_CONDITION_CASES (gbb), i))
+ if (!GBB_CONDITION_CASES (gbb)[i])
code = invert_tree_comparison (code, false);
- add_condition_to_pbb (pbb, stmt, code);
+ add_condition_to_pbb (pbb, cond_stmt, code);
break;
}
int i;
poly_bb_p pbb;
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
+ FOR_EACH_VEC_ELT (SCOP_BBS (scop), i, pbb)
add_conditions_to_domain (pbb);
}
-/* Structure used to pass data to dom_walk. */
-
-struct bsc
-{
- VEC (gimple, heap) **conditions, **cases;
- sese region;
-};
-
/* Returns a COND_EXPR statement when BB has a single predecessor, the
edge between BB and its predecessor is not a loop exit edge, and
the last statement of the single predecessor is a COND_EXPR. */
-static gimple
+static gcond *
single_pred_cond_non_loop_exit (basic_block bb)
{
if (single_pred_p (bb))
stmt = last_stmt (pred);
if (stmt && gimple_code (stmt) == GIMPLE_COND)
- return stmt;
+ return as_a <gcond *> (stmt);
}
return NULL;
}
+class sese_dom_walker : public dom_walker
+{
+public:
+ sese_dom_walker (cdi_direction, sese);
+
+ virtual void before_dom_children (basic_block);
+ virtual void after_dom_children (basic_block);
+
+private:
+ auto_vec<gimple, 3> m_conditions, m_cases;
+ sese m_region;
+};
+
+sese_dom_walker::sese_dom_walker (cdi_direction direction, sese region)
+ : dom_walker (direction), m_region (region)
+{
+}
+
/* Call-back for dom_walk executed before visiting the dominated
blocks. */
-static void
-build_sese_conditions_before (struct dom_walk_data *dw_data,
- basic_block bb)
+void
+sese_dom_walker::before_dom_children (basic_block bb)
{
- struct bsc *data = (struct bsc *) dw_data->global_data;
- VEC (gimple, heap) **conditions = data->conditions;
- VEC (gimple, heap) **cases = data->cases;
gimple_bb_p gbb;
- gimple stmt;
+ gcond *stmt;
- if (!bb_in_sese_p (bb, data->region))
+ if (!bb_in_sese_p (bb, m_region))
return;
stmt = single_pred_cond_non_loop_exit (bb);
{
edge e = single_pred_edge (bb);
- VEC_safe_push (gimple, heap, *conditions, stmt);
+ m_conditions.safe_push (stmt);
if (e->flags & EDGE_TRUE_VALUE)
- VEC_safe_push (gimple, heap, *cases, stmt);
+ m_cases.safe_push (stmt);
else
- VEC_safe_push (gimple, heap, *cases, NULL);
+ m_cases.safe_push (NULL);
}
gbb = gbb_from_bb (bb);
if (gbb)
{
- GBB_CONDITIONS (gbb) = VEC_copy (gimple, heap, *conditions);
- GBB_CONDITION_CASES (gbb) = VEC_copy (gimple, heap, *cases);
+ GBB_CONDITIONS (gbb) = m_conditions.copy ();
+ GBB_CONDITION_CASES (gbb) = m_cases.copy ();
}
}
/* Call-back for dom_walk executed after visiting the dominated
blocks. */
-static void
-build_sese_conditions_after (struct dom_walk_data *dw_data,
- basic_block bb)
+void
+sese_dom_walker::after_dom_children (basic_block bb)
{
- struct bsc *data = (struct bsc *) dw_data->global_data;
- VEC (gimple, heap) **conditions = data->conditions;
- VEC (gimple, heap) **cases = data->cases;
-
- if (!bb_in_sese_p (bb, data->region))
+ if (!bb_in_sese_p (bb, m_region))
return;
if (single_pred_cond_non_loop_exit (bb))
{
- VEC_pop (gimple, *conditions);
- VEC_pop (gimple, *cases);
+ m_conditions.pop ();
+ m_cases.pop ();
}
}
-/* Record all conditions in REGION. */
-
-static void
-build_sese_conditions (sese region)
-{
- struct dom_walk_data walk_data;
- VEC (gimple, heap) *conditions = VEC_alloc (gimple, heap, 3);
- VEC (gimple, heap) *cases = VEC_alloc (gimple, heap, 3);
- struct bsc data;
-
- data.conditions = &conditions;
- data.cases = &cases;
- data.region = region;
-
- walk_data.dom_direction = CDI_DOMINATORS;
- walk_data.initialize_block_local_data = NULL;
- walk_data.before_dom_children = build_sese_conditions_before;
- walk_data.after_dom_children = build_sese_conditions_after;
- walk_data.global_data = &data;
- walk_data.block_local_data_size = 0;
-
- init_walk_dominator_tree (&walk_data);
- walk_dominator_tree (&walk_data, SESE_ENTRY_BB (region));
- fini_walk_dominator_tree (&walk_data);
-
- VEC_free (gimple, heap, conditions);
- VEC_free (gimple, heap, cases);
-}
-
/* Add constraints on the possible values of parameter P from the type
of P. */
static void
add_param_constraints (scop_p scop, graphite_dim_t p)
{
- tree parameter = VEC_index (tree, SESE_PARAMS (SCOP_REGION (scop)), p);
+ tree parameter = SESE_PARAMS (SCOP_REGION (scop))[p];
tree type = TREE_TYPE (parameter);
tree lb = NULL_TREE;
tree ub = NULL_TREE;
isl_space *space = isl_set_get_space (scop->context);
isl_constraint *c;
mpz_t g;
- isl_int v;
+ isl_val *v;
c = isl_inequality_alloc (isl_local_space_from_space (space));
mpz_init (g);
- isl_int_init (v);
tree_int_to_gmp (lb, g);
- isl_int_set_gmp (v, g);
- isl_int_neg (v, v);
+ v = isl_val_int_from_gmp (the_isl_ctx, g);
+ v = isl_val_neg (v);
mpz_clear (g);
- c = isl_constraint_set_constant (c, v);
- isl_int_clear (v);
+ c = isl_constraint_set_constant_val (c, v);
c = isl_constraint_set_coefficient_si (c, isl_dim_param, p, 1);
scop->context = isl_set_add_constraint (scop->context, c);
isl_space *space = isl_set_get_space (scop->context);
isl_constraint *c;
mpz_t g;
- isl_int v;
+ isl_val *v;
c = isl_inequality_alloc (isl_local_space_from_space (space));
mpz_init (g);
- isl_int_init (v);
tree_int_to_gmp (ub, g);
- isl_int_set_gmp (v, g);
+ v = isl_val_int_from_gmp (the_isl_ctx, g);
mpz_clear (g);
- c = isl_constraint_set_constant (c, v);
- isl_int_clear (v);
+ c = isl_constraint_set_constant_val (c, v);
c = isl_constraint_set_coefficient_si (c, isl_dim_param, p, -1);
scop->context = isl_set_add_constraint (scop->context, c);
sese region = SCOP_REGION (scop);
int i;
poly_bb_p pbb;
- int nb_loops = number_of_loops ();
+ int nb_loops = number_of_loops (cfun);
isl_set **doms = XCNEWVEC (isl_set *, nb_loops);
- FOR_EACH_VEC_ELT (loop_p, SESE_LOOP_NEST (region), i, loop)
+ FOR_EACH_VEC_ELT (SESE_LOOP_NEST (region), i, loop)
if (!loop_in_sese_p (loop_outer (loop), region))
build_loop_iteration_domains (scop, loop, 0,
isl_set_copy (scop->context), doms);
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
+ FOR_EACH_VEC_ELT (SCOP_BBS (scop), i, pbb)
{
loop = pbb_loop (pbb);
subscript - low >= 0 and high - subscript >= 0 in case one of
the two bounds isn't known. Do the same here? */
- if (host_integerp (low, 0)
+ if (tree_fits_shwi_p (low)
&& high
- && host_integerp (high, 0)
+ && tree_fits_shwi_p (high)
/* 1-element arrays at end of structures may extend over
their declared size. */
&& !(array_at_struct_end_p (ref)
static inline bool
write_alias_graph_to_ascii_dimacs (FILE *file, char *comment,
- VEC (data_reference_p, heap) *drs)
+ vec<data_reference_p> drs)
{
- int num_vertex = VEC_length (data_reference_p, drs);
+ int num_vertex = drs.length ();
int edge_num = 0;
data_reference_p dr1, dr2;
int i, j;
if (num_vertex == 0)
return true;
- FOR_EACH_VEC_ELT (data_reference_p, drs, i, dr1)
- for (j = i + 1; VEC_iterate (data_reference_p, drs, j, dr2); j++)
+ FOR_EACH_VEC_ELT (drs, i, dr1)
+ for (j = i + 1; drs.iterate (j, &dr2); j++)
if (dr_may_alias_p (dr1, dr2, true))
edge_num++;
fprintf (file, "p edge %d %d\n", num_vertex, edge_num);
- FOR_EACH_VEC_ELT (data_reference_p, drs, i, dr1)
- for (j = i + 1; VEC_iterate (data_reference_p, drs, j, dr2); j++)
+ FOR_EACH_VEC_ELT (drs, i, dr1)
+ for (j = i + 1; drs.iterate (j, &dr2); j++)
if (dr_may_alias_p (dr1, dr2, true))
fprintf (file, "e %d %d\n", i + 1, j + 1);
static inline bool
write_alias_graph_to_ascii_dot (FILE *file, char *comment,
- VEC (data_reference_p, heap) *drs)
+ vec<data_reference_p> drs)
{
- int num_vertex = VEC_length (data_reference_p, drs);
+ int num_vertex = drs.length ();
data_reference_p dr1, dr2;
int i, j;
fprintf (file, "c %s\n", comment);
/* First print all the vertices. */
- FOR_EACH_VEC_ELT (data_reference_p, drs, i, dr1)
+ FOR_EACH_VEC_ELT (drs, i, dr1)
fprintf (file, "n%d;\n", i);
- FOR_EACH_VEC_ELT (data_reference_p, drs, i, dr1)
- for (j = i + 1; VEC_iterate (data_reference_p, drs, j, dr2); j++)
+ FOR_EACH_VEC_ELT (drs, i, dr1)
+ for (j = i + 1; drs.iterate (j, &dr2); j++)
if (dr_may_alias_p (dr1, dr2, true))
fprintf (file, "n%d n%d\n", i, j);
static inline bool
write_alias_graph_to_ascii_ecc (FILE *file, char *comment,
- VEC (data_reference_p, heap) *drs)
+ vec<data_reference_p> drs)
{
- int num_vertex = VEC_length (data_reference_p, drs);
+ int num_vertex = drs.length ();
data_reference_p dr1, dr2;
int i, j;
if (comment)
fprintf (file, "c %s\n", comment);
- FOR_EACH_VEC_ELT (data_reference_p, drs, i, dr1)
- for (j = i + 1; VEC_iterate (data_reference_p, drs, j, dr2); j++)
+ FOR_EACH_VEC_ELT (drs, i, dr1)
+ for (j = i + 1; drs.iterate (j, &dr2); j++)
if (dr_may_alias_p (dr1, dr2, true))
fprintf (file, "%d %d\n", i, j);
true (1) if the above test is true, and false (0) otherwise. */
static int
-build_alias_set_optimal_p (VEC (data_reference_p, heap) *drs)
+build_alias_set_optimal_p (vec<data_reference_p> drs)
{
- int num_vertices = VEC_length (data_reference_p, drs);
+ int num_vertices = drs.length ();
struct graph *g = new_graph (num_vertices);
data_reference_p dr1, dr2;
int i, j;
int this_component_is_clique;
int all_components_are_cliques = 1;
- FOR_EACH_VEC_ELT (data_reference_p, drs, i, dr1)
- for (j = i+1; VEC_iterate (data_reference_p, drs, j, dr2); j++)
+ FOR_EACH_VEC_ELT (drs, i, dr1)
+ for (j = i+1; drs.iterate (j, &dr2); j++)
if (dr_may_alias_p (dr1, dr2, true))
{
add_edge (g, i, j);
NULL, true, NULL);
for (i = 0; i < g->n_vertices; i++)
{
- data_reference_p dr = VEC_index (data_reference_p, drs, i);
+ data_reference_p dr = drs[i];
base_alias_pair *bap;
gcc_assert (dr->aux);
/* Group each data reference in DRS with its base object set num. */
static void
-build_base_obj_set_for_drs (VEC (data_reference_p, heap) *drs)
+build_base_obj_set_for_drs (vec<data_reference_p> drs)
{
- int num_vertex = VEC_length (data_reference_p, drs);
+ int num_vertex = drs.length ();
struct graph *g = new_graph (num_vertex);
data_reference_p dr1, dr2;
int i, j;
int *queue;
- FOR_EACH_VEC_ELT (data_reference_p, drs, i, dr1)
- for (j = i + 1; VEC_iterate (data_reference_p, drs, j, dr2); j++)
+ FOR_EACH_VEC_ELT (drs, i, dr1)
+ for (j = i + 1; drs.iterate (j, &dr2); j++)
if (dr_same_base_object_p (dr1, dr2))
{
add_edge (g, i, j);
for (i = 0; i < g->n_vertices; i++)
{
- data_reference_p dr = VEC_index (data_reference_p, drs, i);
+ data_reference_p dr = drs[i];
base_alias_pair *bap;
gcc_assert (dr->aux);
{
int j;
data_reference_p dr;
- VEC (data_reference_p, heap) *gbb_drs = GBB_DATA_REFS (PBB_BLACK_BOX (pbb));
+ vec<data_reference_p> gbb_drs = GBB_DATA_REFS (PBB_BLACK_BOX (pbb));
- FOR_EACH_VEC_ELT (data_reference_p, gbb_drs, j, dr)
+ FOR_EACH_VEC_ELT (gbb_drs, j, dr)
build_poly_dr (dr, pbb);
}
/* Dump to file the alias graphs for the data references in DRS. */
static void
-dump_alias_graphs (VEC (data_reference_p, heap) *drs)
+dump_alias_graphs (vec<data_reference_p> drs)
{
char comment[100];
FILE *file_dimacs, *file_ecc, *file_dot;
int i, j;
poly_bb_p pbb;
data_reference_p dr;
- VEC (data_reference_p, heap) *drs = VEC_alloc (data_reference_p, heap, 3);
+ auto_vec<data_reference_p, 3> drs;
/* Remove all the PBBs that do not have data references: these basic
blocks are not handled in the polyhedral representation. */
- for (i = 0; VEC_iterate (poly_bb_p, SCOP_BBS (scop), i, pbb); i++)
- if (VEC_empty (data_reference_p, GBB_DATA_REFS (PBB_BLACK_BOX (pbb))))
+ for (i = 0; SCOP_BBS (scop).iterate (i, &pbb); i++)
+ if (GBB_DATA_REFS (PBB_BLACK_BOX (pbb)).is_empty ())
{
free_gimple_bb (PBB_BLACK_BOX (pbb));
free_poly_bb (pbb);
- VEC_ordered_remove (poly_bb_p, SCOP_BBS (scop), i);
+ SCOP_BBS (scop).ordered_remove (i);
i--;
}
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
- for (j = 0; VEC_iterate (data_reference_p,
- GBB_DATA_REFS (PBB_BLACK_BOX (pbb)), j, dr); j++)
- VEC_safe_push (data_reference_p, heap, drs, dr);
+ FOR_EACH_VEC_ELT (SCOP_BBS (scop), i, pbb)
+ for (j = 0; GBB_DATA_REFS (PBB_BLACK_BOX (pbb)).iterate (j, &dr); j++)
+ drs.safe_push (dr);
- FOR_EACH_VEC_ELT (data_reference_p, drs, i, dr)
+ FOR_EACH_VEC_ELT (drs, i, dr)
dr->aux = XNEW (base_alias_pair);
if (!build_alias_set_optimal_p (drs))
if (0)
dump_alias_graphs (drs);
- VEC_free (data_reference_p, heap, drs);
+ drs.release ();
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
+ FOR_EACH_VEC_ELT (SCOP_BBS (scop), i, pbb)
build_pbb_drs (pbb);
}
/* Return a gsi at the position of the phi node STMT. */
-static gimple_stmt_iterator
-gsi_for_phi_node (gimple stmt)
+static gphi_iterator
+gsi_for_phi_node (gphi *stmt)
{
- gimple_stmt_iterator psi;
+ gphi_iterator psi;
basic_block bb = gimple_bb (stmt);
for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
- if (stmt == gsi_stmt (psi))
+ if (stmt == psi.phi ())
return psi;
gcc_unreachable ();
GBB_DATA_REFS vector of BB. */
static void
-analyze_drs_in_stmts (scop_p scop, basic_block bb, VEC (gimple, heap) *stmts)
+analyze_drs_in_stmts (scop_p scop, basic_block bb, vec<gimple> stmts)
{
loop_p nest;
gimple_bb_p gbb;
nest = outermost_loop_in_sese_1 (region, bb);
gbb = gbb_from_bb (bb);
- FOR_EACH_VEC_ELT (gimple, stmts, i, stmt)
+ FOR_EACH_VEC_ELT (stmts, i, stmt)
{
loop_p loop;
gimple_stmt_iterator insert_gsi)
{
gimple_stmt_iterator gsi;
- VEC (gimple, heap) *x = VEC_alloc (gimple, heap, 3);
+ auto_vec<gimple, 3> x;
gimple_seq_add_stmt (&stmts, stmt);
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
- VEC_safe_push (gimple, heap, x, gsi_stmt (gsi));
+ x.safe_push (gsi_stmt (gsi));
gsi_insert_seq_before (&insert_gsi, stmts, GSI_SAME_STMT);
analyze_drs_in_stmts (scop, gsi_bb (insert_gsi), x);
- VEC_free (gimple, heap, x);
}
/* Insert the assignment "RES := EXPR" just after AFTER_STMT. */
gimple_seq stmts;
gimple_stmt_iterator gsi;
tree var = force_gimple_operand (expr, &stmts, true, NULL_TREE);
- gimple stmt = gimple_build_assign (res, var);
- VEC (gimple, heap) *x = VEC_alloc (gimple, heap, 3);
+ gassign *stmt = gimple_build_assign (unshare_expr (res), var);
+ auto_vec<gimple, 3> x;
gimple_seq_add_stmt (&stmts, stmt);
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
- VEC_safe_push (gimple, heap, x, gsi_stmt (gsi));
+ x.safe_push (gsi_stmt (gsi));
if (gimple_code (after_stmt) == GIMPLE_PHI)
{
}
analyze_drs_in_stmts (scop, gimple_bb (after_stmt), x);
- VEC_free (gimple, heap, x);
}
/* Creates a poly_bb_p for basic_block BB from the existing PBB. */
static void
new_pbb_from_pbb (scop_p scop, poly_bb_p pbb, basic_block bb)
{
- VEC (data_reference_p, heap) *drs = VEC_alloc (data_reference_p, heap, 3);
+ vec<data_reference_p> drs;
+ drs.create (3);
gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
gimple_bb_p gbb1 = new_gimple_bb (bb, drs);
poly_bb_p pbb1 = new_poly_bb (scop, gbb1);
- int index, n = VEC_length (poly_bb_p, SCOP_BBS (scop));
+ int index, n = SCOP_BBS (scop).length ();
/* The INDEX of PBB in SCOP_BBS. */
for (index = 0; index < n; index++)
- if (VEC_index (poly_bb_p, SCOP_BBS (scop), index) == pbb)
+ if (SCOP_BBS (scop)[index] == pbb)
break;
pbb1->domain = isl_set_copy (pbb->domain);
+ pbb1->domain = isl_set_set_tuple_id (pbb1->domain,
+ isl_id_for_pbb (scop, pbb1));
GBB_PBB (gbb1) = pbb1;
- GBB_CONDITIONS (gbb1) = VEC_copy (gimple, heap, GBB_CONDITIONS (gbb));
- GBB_CONDITION_CASES (gbb1) = VEC_copy (gimple, heap, GBB_CONDITION_CASES (gbb));
- VEC_safe_insert (poly_bb_p, heap, SCOP_BBS (scop), index + 1, pbb1);
+ GBB_CONDITIONS (gbb1) = GBB_CONDITIONS (gbb).copy ();
+ GBB_CONDITION_CASES (gbb1) = GBB_CONDITION_CASES (gbb).copy ();
+ SCOP_BBS (scop).safe_insert (index + 1, pbb1);
}
/* Insert on edge E the assignment "RES := EXPR". */
gimple_stmt_iterator gsi;
gimple_seq stmts = NULL;
tree var = force_gimple_operand (expr, &stmts, true, NULL_TREE);
- gimple stmt = gimple_build_assign (res, var);
+ gimple stmt = gimple_build_assign (unshare_expr (res), var);
basic_block bb;
- VEC (gimple, heap) *x = VEC_alloc (gimple, heap, 3);
+ auto_vec<gimple, 3> x;
gimple_seq_add_stmt (&stmts, stmt);
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
- VEC_safe_push (gimple, heap, x, gsi_stmt (gsi));
+ x.safe_push (gsi_stmt (gsi));
gsi_insert_seq_on_edge (e, stmts);
gsi_commit_edge_inserts ();
new_pbb_from_pbb (scop, pbb_from_bb (e->src), bb);
analyze_drs_in_stmts (scop, bb, x);
- VEC_free (gimple, heap, x);
}
/* Creates a zero dimension array of the same type as VAR. */
stmt = gimple_build_assign (res, arg);
remove_phi_node (psi, false);
gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
- SSA_NAME_DEF_STMT (res) = stmt;
return;
}
{
tree zero_dim_array = create_zero_dim_array (res, "Close_Phi");
- stmt = gimple_build_assign (res, zero_dim_array);
+ stmt = gimple_build_assign (res, unshare_expr (zero_dim_array));
if (TREE_CODE (arg) == SSA_NAME)
insert_out_of_ssa_copy (scop, zero_dim_array, arg,
dimension array for it. */
static void
-rewrite_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi)
+rewrite_phi_out_of_ssa (scop_p scop, gphi_iterator *psi)
{
size_t i;
- gimple phi = gsi_stmt (*psi);
+ gphi *phi = psi->phi ();
basic_block bb = gimple_bb (phi);
tree res = gimple_phi_result (phi);
- tree var;
tree zero_dim_array = create_zero_dim_array (res, "phi_out_of_ssa");
gimple stmt;
- gimple_seq stmts;
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
/* Avoid the insertion of code in the loop latch to please the
pattern matching of the vectorizer. */
if (TREE_CODE (arg) == SSA_NAME
+ && !SSA_NAME_IS_DEFAULT_DEF (arg)
&& e->src == bb->loop_father->latch)
insert_out_of_ssa_copy (scop, zero_dim_array, arg,
SSA_NAME_DEF_STMT (arg));
insert_out_of_ssa_copy_on_edge (scop, e, zero_dim_array, arg);
}
- var = force_gimple_operand (zero_dim_array, &stmts, true, NULL_TREE);
-
- stmt = gimple_build_assign (res, var);
+ stmt = gimple_build_assign (res, unshare_expr (zero_dim_array));
remove_phi_node (psi, false);
- SSA_NAME_DEF_STMT (res) = stmt;
-
- insert_stmts (scop, stmt, stmts, gsi_after_labels (bb));
+ insert_stmts (scop, stmt, NULL, gsi_after_labels (bb));
}
/* Rewrite the degenerate phi node at position PSI from the degenerate
form "x = phi (y, y, ..., y)" to "x = y". */
static void
-rewrite_degenerate_phi (gimple_stmt_iterator *psi)
+rewrite_degenerate_phi (gphi_iterator *psi)
{
tree rhs;
gimple stmt;
gimple_stmt_iterator gsi;
- gimple phi = gsi_stmt (*psi);
+ gphi *phi = psi->phi ();
tree res = gimple_phi_result (phi);
basic_block bb;
stmt = gimple_build_assign (res, rhs);
remove_phi_node (psi, false);
- SSA_NAME_DEF_STMT (res) = stmt;
gsi = gsi_after_labels (bb);
gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
rewrite_reductions_out_of_ssa (scop_p scop)
{
basic_block bb;
- gimple_stmt_iterator psi;
+ gphi_iterator psi;
sese region = SCOP_REGION (scop);
- FOR_EACH_BB (bb)
+ FOR_EACH_BB_FN (bb, cfun)
if (bb_in_sese_p (bb, region))
for (psi = gsi_start_phis (bb); !gsi_end_p (psi);)
{
- gimple phi = gsi_stmt (psi);
+ gphi *phi = psi.phi ();
if (virtual_operand_p (gimple_phi_result (phi)))
{
gcc_assert (gimple_code (use_stmt) != GIMPLE_PHI);
- name = copy_ssa_name (def, NULL);
+ name = copy_ssa_name (def);
name_stmt = gimple_build_assign (name, zero_dim_array);
gimple_assign_set_lhs (name_stmt, name);
static void
handle_scalar_deps_crossing_scop_limits (scop_p scop, tree def, gimple stmt)
{
- tree var = create_tmp_reg (TREE_TYPE (def), NULL);
+ tree var = create_tmp_reg (TREE_TYPE (def));
tree new_name = make_ssa_name (var, stmt);
bool needs_copy = false;
use_operand_p use_p;
gimple assign = gimple_build_assign (new_name, def);
gimple_stmt_iterator psi = gsi_after_labels (SESE_EXIT (region)->dest);
- SSA_NAME_DEF_STMT (new_name) = assign;
update_stmt (assign);
gsi_insert_before (&psi, assign, GSI_SAME_STMT);
}
if (gimple_code (use_stmt) == GIMPLE_PHI
&& (res = true))
{
- gimple_stmt_iterator psi = gsi_for_stmt (use_stmt);
+ gphi_iterator psi = gsi_start_phis (gimple_bb (use_stmt));
if (scalar_close_phi_node_p (gsi_stmt (psi)))
rewrite_close_phi_out_of_ssa (scop, &psi);
gsi_next (gsi);
}
- rewrite_cross_bb_scalar_dependence (scop, zero_dim_array,
+ rewrite_cross_bb_scalar_dependence (scop, unshare_expr (zero_dim_array),
def, use_stmt);
}
/* Create an extra empty BB after the scop. */
split_edge (SESE_EXIT (region));
- FOR_EACH_BB (bb)
+ FOR_EACH_BB_FN (bb, cfun)
if (bb_in_sese_p (bb, region))
for (psi = gsi_start_bb (bb); !gsi_end_p (psi); gsi_next (&psi))
changed |= rewrite_cross_bb_scalar_deps (scop, &psi);
poly_bb_p pbb;
int res = 0;
- FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
+ FOR_EACH_VEC_ELT (SCOP_BBS (scop), i, pbb)
if (loop_in_sese_p (gbb_loop (PBB_BLACK_BOX (pbb)), SCOP_REGION (scop)))
res++;
/* A part of the data references will end in a different basic block
after the split: move the DRs from the original GBB to the newly
created GBB1. */
- FOR_EACH_VEC_ELT (data_reference_p, GBB_DATA_REFS (gbb), i, dr)
+ FOR_EACH_VEC_ELT (GBB_DATA_REFS (gbb), i, dr)
{
basic_block bb1 = gimple_bb (DR_STMT (dr));
if (bb1 != bb)
{
gimple_bb_p gbb1 = gbb_from_bb (bb1);
- VEC_safe_push (data_reference_p, heap, GBB_DATA_REFS (gbb1), dr);
- VEC_ordered_remove (data_reference_p, GBB_DATA_REFS (gbb), i);
+ GBB_DATA_REFS (gbb1).safe_push (dr);
+ GBB_DATA_REFS (gbb).ordered_remove (i);
i--;
}
}
/* Returns true when PHI contains an argument ARG. */
static bool
-phi_contains_arg (gimple phi, tree arg)
+phi_contains_arg (gphi *phi, tree arg)
{
size_t i;
/* Return a loop phi node that corresponds to a reduction containing LHS. */
-static gimple
+static gphi *
follow_ssa_with_commutative_ops (tree arg, tree lhs)
{
gimple stmt;
|| gimple_code (stmt) == GIMPLE_CALL)
return NULL;
- if (gimple_code (stmt) == GIMPLE_PHI)
+ if (gphi *phi = dyn_cast <gphi *> (stmt))
{
- if (phi_contains_arg (stmt, lhs))
- return stmt;
+ if (phi_contains_arg (phi, lhs))
+ return phi;
return NULL;
}
if (is_reduction_operation_p (stmt))
{
- gimple res = follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs);
+ gphi *res
+ = follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs);
return res ? res :
follow_ssa_with_commutative_ops (gimple_assign_rhs2 (stmt), lhs);
/* Detect commutative and associative scalar reductions starting at
the STMT. Return the phi node of the reduction cycle, or NULL. */
-static gimple
+static gphi *
detect_commutative_reduction_arg (tree lhs, gimple stmt, tree arg,
- VEC (gimple, heap) **in,
- VEC (gimple, heap) **out)
+ vec<gimple> *in,
+ vec<gimple> *out)
{
- gimple phi = follow_ssa_with_commutative_ops (arg, lhs);
+ gphi *phi = follow_ssa_with_commutative_ops (arg, lhs);
if (!phi)
return NULL;
- VEC_safe_push (gimple, heap, *in, stmt);
- VEC_safe_push (gimple, heap, *out, stmt);
+ in->safe_push (stmt);
+ out->safe_push (stmt);
return phi;
}
/* Detect commutative and associative scalar reductions starting at
STMT. Return the phi node of the reduction cycle, or NULL. */
-static gimple
-detect_commutative_reduction_assign (gimple stmt, VEC (gimple, heap) **in,
- VEC (gimple, heap) **out)
+static gphi *
+detect_commutative_reduction_assign (gimple stmt, vec<gimple> *in,
+ vec<gimple> *out)
{
tree lhs = gimple_assign_lhs (stmt);
if (is_reduction_operation_p (stmt))
{
- gimple res = detect_commutative_reduction_arg (lhs, stmt,
- gimple_assign_rhs1 (stmt),
- in, out);
+ gphi *res = detect_commutative_reduction_arg (lhs, stmt,
+ gimple_assign_rhs1 (stmt),
+ in, out);
return res ? res
: detect_commutative_reduction_arg (lhs, stmt,
gimple_assign_rhs2 (stmt),
/* Return a loop phi node that corresponds to a reduction containing LHS. */
-static gimple
+static gphi *
follow_inital_value_to_phi (tree arg, tree lhs)
{
gimple stmt;
stmt = SSA_NAME_DEF_STMT (arg);
- if (gimple_code (stmt) == GIMPLE_PHI
- && phi_contains_arg (stmt, lhs))
- return stmt;
+ if (gphi *phi = dyn_cast <gphi *> (stmt))
+ if (phi_contains_arg (phi, lhs))
+ return phi;
return NULL;
}
from outside the loop. */
static edge
-edge_initial_value_for_loop_phi (gimple phi)
+edge_initial_value_for_loop_phi (gphi *phi)
{
size_t i;
from outside the loop. */
static tree
-initial_value_for_loop_phi (gimple phi)
+initial_value_for_loop_phi (gphi *phi)
{
size_t i;
the SCOP starting at the loop closed phi node STMT. Return the phi
node of the reduction cycle, or NULL. */
-static gimple
-detect_commutative_reduction (scop_p scop, gimple stmt, VEC (gimple, heap) **in,
- VEC (gimple, heap) **out)
+static gphi *
+detect_commutative_reduction (scop_p scop, gimple stmt, vec<gimple> *in,
+ vec<gimple> *out)
{
if (scalar_close_phi_node_p (stmt))
{
- gimple def, loop_phi, phi, close_phi = stmt;
+ gimple def;
+ gphi *loop_phi, *phi, *close_phi = as_a <gphi *> (stmt);
tree init, lhs, arg = gimple_phi_arg_def (close_phi, 0);
if (TREE_CODE (arg) != SSA_NAME)
|| !has_single_use (gimple_phi_result (phi))))
return NULL;
- VEC_safe_push (gimple, heap, *in, loop_phi);
- VEC_safe_push (gimple, heap, *out, close_phi);
+ in->safe_push (loop_phi);
+ out->safe_push (close_phi);
return phi;
}
static void
translate_scalar_reduction_to_array_for_stmt (scop_p scop, tree red,
- gimple stmt, gimple loop_phi)
+ gimple stmt, gphi *loop_phi)
{
tree res = gimple_phi_result (loop_phi);
- gimple assign = gimple_build_assign (res, unshare_expr (red));
+ gassign *assign = gimple_build_assign (res, unshare_expr (red));
gimple_stmt_iterator gsi;
insert_stmts (scop, assign, NULL, gsi_after_labels (gimple_bb (loop_phi)));
the PHI_RESULT. */
static void
-remove_phi (gimple phi)
+remove_phi (gphi *phi)
{
imm_use_iterator imm_iter;
tree def;
use_operand_p use_p;
gimple_stmt_iterator gsi;
- VEC (gimple, heap) *update = VEC_alloc (gimple, heap, 3);
+ auto_vec<gimple, 3> update;
unsigned int i;
gimple stmt;
if (is_gimple_debug (stmt))
{
gimple_debug_bind_reset_value (stmt);
- VEC_safe_push (gimple, heap, update, stmt);
+ update.safe_push (stmt);
}
}
- FOR_EACH_VEC_ELT (gimple, update, i, stmt)
+ FOR_EACH_VEC_ELT (update, i, stmt)
update_stmt (stmt);
- VEC_free (gimple, heap, update);
-
gsi = gsi_for_phi_node (phi);
remove_phi_node (&gsi, false);
}
NULL_TREE. */
static tree
-close_phi_written_to_memory (gimple close_phi)
+close_phi_written_to_memory (gphi *close_phi)
{
imm_use_iterator imm_iter;
use_operand_p use_p;
static void
translate_scalar_reduction_to_array (scop_p scop,
- VEC (gimple, heap) *in,
- VEC (gimple, heap) *out)
+ vec<gimple> in,
+ vec<gimple> out)
{
- gimple loop_phi;
- unsigned int i = VEC_length (gimple, out) - 1;
- tree red = close_phi_written_to_memory (VEC_index (gimple, out, i));
+ gimple loop_stmt;
+ unsigned int i = out.length () - 1;
+ tree red = close_phi_written_to_memory (as_a <gphi *> (out[i]));
- FOR_EACH_VEC_ELT (gimple, in, i, loop_phi)
+ FOR_EACH_VEC_ELT (in, i, loop_stmt)
{
- gimple close_phi = VEC_index (gimple, out, i);
+ gimple close_stmt = out[i];
if (i == 0)
{
- gimple stmt = loop_phi;
- basic_block bb = split_reduction_stmt (scop, stmt);
+ basic_block bb = split_reduction_stmt (scop, loop_stmt);
poly_bb_p pbb = pbb_from_bb (bb);
PBB_IS_REDUCTION (pbb) = true;
- gcc_assert (close_phi == loop_phi);
+ gcc_assert (close_stmt == loop_stmt);
if (!red)
red = create_zero_dim_array
- (gimple_assign_lhs (stmt), "Commutative_Associative_Reduction");
+ (gimple_assign_lhs (loop_stmt), "Commutative_Associative_Reduction");
- translate_scalar_reduction_to_array_for_stmt
- (scop, red, stmt, VEC_index (gimple, in, 1));
+ translate_scalar_reduction_to_array_for_stmt (scop, red, loop_stmt,
+ as_a <gphi *> (in[1]));
continue;
}
- if (i == VEC_length (gimple, in) - 1)
+ gphi *loop_phi = as_a <gphi *> (loop_stmt);
+ gphi *close_phi = as_a <gphi *> (close_stmt);
+
+ if (i == in.length () - 1)
{
insert_out_of_ssa_copy (scop, gimple_phi_result (close_phi),
unshare_expr (red), close_phi);
static bool
rewrite_commutative_reductions_out_of_ssa_close_phi (scop_p scop,
- gimple close_phi)
+ gphi *close_phi)
{
bool res;
- VEC (gimple, heap) *in = VEC_alloc (gimple, heap, 10);
- VEC (gimple, heap) *out = VEC_alloc (gimple, heap, 10);
+ auto_vec<gimple, 10> in;
+ auto_vec<gimple, 10> out;
detect_commutative_reduction (scop, close_phi, &in, &out);
- res = VEC_length (gimple, in) > 1;
+ res = in.length () > 1;
if (res)
translate_scalar_reduction_to_array (scop, in, out);
- VEC_free (gimple, heap, in);
- VEC_free (gimple, heap, out);
return res;
}
rewrite_commutative_reductions_out_of_ssa_loop (scop_p scop,
loop_p loop)
{
- gimple_stmt_iterator gsi;
+ gphi_iterator gsi;
edge exit = single_exit (loop);
tree res;
bool changed = false;
return false;
for (gsi = gsi_start_phis (exit->dest); !gsi_end_p (gsi); gsi_next (&gsi))
- if ((res = gimple_phi_result (gsi_stmt (gsi)))
+ if ((res = gimple_phi_result (gsi.phi ()))
&& !virtual_operand_p (res)
&& !scev_analyzable_p (res, SCOP_REGION (scop)))
changed |= rewrite_commutative_reductions_out_of_ssa_close_phi
- (scop, gsi_stmt (gsi));
+ (scop, gsi.phi ());
return changed;
}
static void
rewrite_commutative_reductions_out_of_ssa (scop_p scop)
{
- loop_iterator li;
loop_p loop;
bool changed = false;
sese region = SCOP_REGION (scop);
- FOR_EACH_LOOP (li, loop, 0)
+ FOR_EACH_LOOP (loop, 0)
if (loop_in_sese_p (loop, region))
changed |= rewrite_commutative_reductions_out_of_ssa_loop (scop, loop);
static bool
scop_ivs_can_be_represented (scop_p scop)
{
- loop_iterator li;
loop_p loop;
- gimple_stmt_iterator psi;
+ gphi_iterator psi;
+ bool result = true;
- FOR_EACH_LOOP (li, loop, 0)
+ FOR_EACH_LOOP (loop, 0)
{
if (!loop_in_sese_p (loop, SCOP_REGION (scop)))
continue;
for (psi = gsi_start_phis (loop->header);
!gsi_end_p (psi); gsi_next (&psi))
{
- gimple phi = gsi_stmt (psi);
+ gphi *phi = psi.phi ();
tree res = PHI_RESULT (phi);
tree type = TREE_TYPE (res);
if (TYPE_UNSIGNED (type)
&& TYPE_PRECISION (type) >= TYPE_PRECISION (long_long_integer_type_node))
- return false;
+ {
+ result = false;
+ break;
+ }
}
+ if (!result)
+ break;
}
- return true;
+ return result;
}
/* Builds the polyhedral representation for a SESE region. */
rewrite_commutative_reductions_out_of_ssa (scop);
build_sese_loop_nests (region);
- build_sese_conditions (region);
+ /* Record all conditions in REGION. */
+ sese_dom_walker (CDI_DOMINATORS, region).walk (cfun->cfg->x_entry_block_ptr);
find_scop_parameters (scop);
max_dim = PARAM_VALUE (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS);
projects / gcc.git / blobdiff