This patch makes omp_max_vf return a polynomial vectorization factor.
We then need to be able to stash a polynomial value in
OMP_CLAUSE_SAFELEN_EXPR too:
/* If max_vf is non-zero, then we can use only a vectorization factor
up to the max_vf we chose. So stick it into the safelen clause. */
For now the cfgloop safelen is still constant though.
2017-10-23 Richard Sandiford <richard.sandif...@linaro.org>
Alan Hayward <alan.hayw...@arm.com>
David Sherwood <david.sherw...@arm.com>
gcc/
* omp-general.h (omp_max_vf): Return a poly_uint64 instead of an int.
* omp-general.c (omp_max_vf): Likewise.
* omp-expand.c (omp_adjust_chunk_size): Update call to omp_max_vf.
(expand_omp_simd): Handle polynomial safelen.
* omp-low.c (omplow_simd_context): Add a default constructor.
(omplow_simd_context::max_vf): Change from int to poly_uint64.
(lower_rec_simd_input_clauses): Update accordingly.
(lower_rec_input_clauses): Likewise.
Index: gcc/omp-general.h
===================================================================
--- gcc/omp-general.h 2017-05-18 07:51:12.357753671 +0100
+++ gcc/omp-general.h 2017-10-23 17:22:29.881163047 +0100
@@ -78,7 +78,7 @@ extern tree omp_get_for_step_from_incr (
extern void omp_extract_for_data (gomp_for *for_stmt, struct omp_for_data *fd,
struct omp_for_data_loop *loops);
extern gimple *omp_build_barrier (tree lhs);
-extern int omp_max_vf (void);
+extern poly_uint64 omp_max_vf (void);
extern int omp_max_simt_vf (void);
extern tree oacc_launch_pack (unsigned code, tree device, unsigned op);
extern void oacc_replace_fn_attrib (tree fn, tree dims);
Index: gcc/omp-general.c
===================================================================
--- gcc/omp-general.c 2017-08-10 14:36:08.449457108 +0100
+++ gcc/omp-general.c 2017-10-23 17:22:29.881163047 +0100
@@ -423,7 +423,7 @@ omp_build_barrier (tree lhs)
/* Return maximum possible vectorization factor for the target. */
-int
+poly_uint64
omp_max_vf (void)
{
if (!optimize
Index: gcc/omp-expand.c
===================================================================
--- gcc/omp-expand.c 2017-10-02 09:10:57.525659817 +0100
+++ gcc/omp-expand.c 2017-10-23 17:22:29.881163047 +0100
@@ -206,8 +206,8 @@ omp_adjust_chunk_size (tree chunk_size,
if (!simd_schedule)
return chunk_size;
- int vf = omp_max_vf ();
- if (vf == 1)
+ poly_uint64 vf = omp_max_vf ();
+ if (must_eq (vf, 1U))
return chunk_size;
tree type = TREE_TYPE (chunk_size);
@@ -4609,11 +4609,12 @@ expand_omp_simd (struct omp_region *regi
if (safelen)
{
+ poly_uint64 val;
safelen = OMP_CLAUSE_SAFELEN_EXPR (safelen);
- if (TREE_CODE (safelen) != INTEGER_CST)
+ if (!poly_int_tree_p (safelen, &val))
safelen_int = 0;
- else if (tree_fits_uhwi_p (safelen) && tree_to_uhwi (safelen) < INT_MAX)
- safelen_int = tree_to_uhwi (safelen);
+ else
+ safelen_int = MIN (constant_lower_bound (val), INT_MAX);
if (safelen_int == 1)
safelen_int = 0;
}
Index: gcc/omp-low.c
===================================================================
--- gcc/omp-low.c 2017-10-23 17:17:01.432034493 +0100
+++ gcc/omp-low.c 2017-10-23 17:22:29.882163248 +0100
@@ -3487,11 +3487,12 @@ omp_clause_aligned_alignment (tree claus
and lower_rec_input_clauses. */
struct omplow_simd_context {
+ omplow_simd_context () { memset (this, 0, sizeof (*this)); }
tree idx;
tree lane;
vec<tree, va_heap> simt_eargs;
gimple_seq simt_dlist;
- int max_vf;
+ poly_uint64_pod max_vf;
bool is_simt;
};
@@ -3502,28 +3503,30 @@ struct omplow_simd_context {
lower_rec_simd_input_clauses (tree new_var, omp_context *ctx,
omplow_simd_context *sctx, tree &ivar, tree &lvar)
{
- if (sctx->max_vf == 0)
+ if (known_zero (sctx->max_vf))
{
sctx->max_vf = sctx->is_simt ? omp_max_simt_vf () : omp_max_vf ();
- if (sctx->max_vf > 1)
+ if (may_gt (sctx->max_vf, 1U))
{
tree c = omp_find_clause (gimple_omp_for_clauses (ctx->stmt),
OMP_CLAUSE_SAFELEN);
- if (c
- && (TREE_CODE (OMP_CLAUSE_SAFELEN_EXPR (c)) != INTEGER_CST
- || tree_int_cst_sgn (OMP_CLAUSE_SAFELEN_EXPR (c)) != 1))
- sctx->max_vf = 1;
- else if (c && compare_tree_int (OMP_CLAUSE_SAFELEN_EXPR (c),
- sctx->max_vf) == -1)
- sctx->max_vf = tree_to_shwi (OMP_CLAUSE_SAFELEN_EXPR (c));
+ if (c)
+ {
+ poly_uint64 safe_len;
+ if (!poly_int_tree_p (OMP_CLAUSE_SAFELEN_EXPR (c), &safe_len)
+ || may_lt (safe_len, 1U))
+ sctx->max_vf = 1;
+ else
+ sctx->max_vf = lower_bound (sctx->max_vf, safe_len);
+ }
}
- if (sctx->max_vf > 1)
+ if (may_gt (sctx->max_vf, 1U))
{
sctx->idx = create_tmp_var (unsigned_type_node);
sctx->lane = create_tmp_var (unsigned_type_node);
}
}
- if (sctx->max_vf == 1)
+ if (must_eq (sctx->max_vf, 1U))
return false;
if (sctx->is_simt)
@@ -3637,7 +3640,7 @@ lower_rec_input_clauses (tree clauses, g
}
/* Add a placeholder for simduid. */
- if (sctx.is_simt && sctx.max_vf != 1)
+ if (sctx.is_simt && may_ne (sctx.max_vf, 1U))
sctx.simt_eargs.safe_push (NULL_TREE);
/* Do all the fixed sized types in the first pass, and the variable sized
@@ -4527,7 +4530,7 @@ lower_rec_input_clauses (tree clauses, g
}
}
- if (sctx.max_vf == 1)
+ if (must_eq (sctx.max_vf, 1U))
sctx.is_simt = false;
if (sctx.lane || sctx.is_simt)
@@ -4664,14 +4667,14 @@ lower_rec_input_clauses (tree clauses, g
/* If max_vf is non-zero, then we can use only a vectorization factor
up to the max_vf we chose. So stick it into the safelen clause. */
- if (sctx.max_vf)
+ if (maybe_nonzero (sctx.max_vf))
{
tree c = omp_find_clause (gimple_omp_for_clauses (ctx->stmt),
OMP_CLAUSE_SAFELEN);
+ poly_uint64 safe_len;
if (c == NULL_TREE
- || (TREE_CODE (OMP_CLAUSE_SAFELEN_EXPR (c)) == INTEGER_CST
- && compare_tree_int (OMP_CLAUSE_SAFELEN_EXPR (c),
- sctx.max_vf) == 1))
+ || (poly_int_tree_p (OMP_CLAUSE_SAFELEN_EXPR (c), &safe_len)
+ && may_gt (safe_len, sctx.max_vf)))
{
c = build_omp_clause (UNKNOWN_LOCATION, OMP_CLAUSE_SAFELEN);
OMP_CLAUSE_SAFELEN_EXPR (c) = build_int_cst (integer_type_node,
