+2018-08-01 Jakub Jelinek <jakub@redhat.com>
+
+ * tree.h (OMP_CLAUSE_REDUCTION_TASK, OMP_CLAUSE_REDUCTION_INSCAN):
+ Define.
+ * tree-pretty-print.c (dump_omp_clause): Print reduction modifiers.
+ * gimplify.c (gimplify_scan_omp_clauses): Handle
+ OMP_CLAUSE_REDUCTION_TASK diagnostics.
+
2018-07-25 Jakub Jelinek <jakub@redhat.com>
* gimple.h (enum gf_mask): Add GF_OMP_TEAMS_HOST.
+2018-08-01 Jakub Jelinek <jakub@redhat.com>
+
+ * c-omp.c (c_omp_split_clauses): Handle OMP_CLAUSE_REDUCTION_TASK.
+
2018-07-18 Jakub Jelinek <jakub@redhat.com>
* c-omp.c (c_omp_check_loop_iv_r): Look for orig decl of C++
Duplicate it on all of them, but omit on for or sections if
parallel is present. */
case OMP_CLAUSE_REDUCTION:
+ if (OMP_CLAUSE_REDUCTION_TASK (clauses))
+ {
+ if (code == OMP_SIMD /* || code == OMP_LOOP */)
+ {
+ error_at (OMP_CLAUSE_LOCATION (clauses),
+ "invalid %<task%> reduction modifier on construct "
+ "combined with %<simd%>" /* or %<loop%> */);
+ OMP_CLAUSE_REDUCTION_TASK (clauses) = 0;
+ }
+ else if (code != OMP_SECTIONS
+ && (mask & (OMP_CLAUSE_MASK_1
+ << PRAGMA_OMP_CLAUSE_SCHEDULE)) == 0
+ && (mask & (OMP_CLAUSE_MASK_1
+ << PRAGMA_OMP_CLAUSE_SCHEDULE)) == 0)
+ {
+ error_at (OMP_CLAUSE_LOCATION (clauses),
+ "invalid %<task%> reduction modifier on construct "
+ "not combined with %<parallel%>, %<for%> or "
+ "%<sections%>");
+ OMP_CLAUSE_REDUCTION_TASK (clauses) = 0;
+ }
+ }
if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE)) != 0)
{
if (code == OMP_SIMD)
= OMP_CLAUSE_REDUCTION_PLACEHOLDER (clauses);
OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (c)
= OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clauses);
- OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL];
- cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] = c;
- s = C_OMP_CLAUSE_SPLIT_TEAMS;
+ OMP_CLAUSE_CHAIN (c) = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
+ cclauses[C_OMP_CLAUSE_SPLIT_TEAMS] = c;
+ s = C_OMP_CLAUSE_SPLIT_PARALLEL;
}
else if ((mask & (OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_NUM_THREADS)) != 0)
+2018-08-01 Jakub Jelinek <jakub@redhat.com>
+
+ * c-parser.c (c_parser_omp_clause_reduction): Add IS_OMP argument,
+ parse reduction modifiers.
+ (c_parser_oacc_all_clauses, c_parser_omp_all_clauses): Adjust
+ c_parser_omp_clause_reduction callers.
+
2018-07-25 Jakub Jelinek <jakub@redhat.com>
* c-parser.c (c_parser_omp_teams): Force a BIND_EXPR with BLOCK
identifier
OpenMP 5.0:
+ reduction ( reduction-modifier, reduction-operator : variable-list )
in_reduction ( reduction-operator : variable-list )
task_reduction ( reduction-operator : variable-list ) */
static tree
c_parser_omp_clause_reduction (c_parser *parser, enum omp_clause_code kind,
- tree list)
+ bool is_omp, tree list)
{
location_t clause_loc = c_parser_peek_token (parser)->location;
matching_parens parens;
if (parens.require_open (parser))
{
+ bool task = false;
+ bool inscan = false;
enum tree_code code = ERROR_MARK;
tree reduc_id = NULL_TREE;
+ if (kind == OMP_CLAUSE_REDUCTION && is_omp)
+ {
+ if (c_parser_next_token_is_keyword (parser, RID_DEFAULT)
+ && c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
+ {
+ c_parser_consume_token (parser);
+ c_parser_consume_token (parser);
+ }
+ else if (c_parser_next_token_is (parser, CPP_NAME)
+ && c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
+ {
+ const char *p
+ = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
+ if (strcmp (p, "task") == 0)
+ task = true;
+ else if (strcmp (p, "inscan") == 0)
+ inscan = true;
+ if (task || inscan)
+ {
+ c_parser_consume_token (parser);
+ c_parser_consume_token (parser);
+ }
+ }
+ }
+
switch (c_parser_peek_token (parser)->type)
{
case CPP_PLUS:
while (TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
OMP_CLAUSE_REDUCTION_CODE (c) = code;
+ if (task)
+ OMP_CLAUSE_REDUCTION_TASK (c) = 1;
+ else if (inscan)
+ OMP_CLAUSE_REDUCTION_INSCAN (c) = 1;
if (code == ERROR_MARK
|| !(INTEGRAL_TYPE_P (type)
|| TREE_CODE (type) == REAL_TYPE
case PRAGMA_OACC_CLAUSE_REDUCTION:
clauses
= c_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
- clauses);
+ false, clauses);
c_name = "reduction";
break;
case PRAGMA_OACC_CLAUSE_SEQ:
clauses = c_parser_oacc_simple_clause (parser, OMP_CLAUSE_SEQ,
- clauses);
+ clauses);
c_name = "seq";
break;
case PRAGMA_OACC_CLAUSE_TILE:
case PRAGMA_OMP_CLAUSE_IN_REDUCTION:
clauses
= c_parser_omp_clause_reduction (parser, OMP_CLAUSE_IN_REDUCTION,
- clauses);
+ true, clauses);
c_name = "in_reduction";
break;
case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
case PRAGMA_OMP_CLAUSE_REDUCTION:
clauses
= c_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
- clauses);
+ true, clauses);
c_name = "reduction";
break;
case PRAGMA_OMP_CLAUSE_SCHEDULE:
case PRAGMA_OMP_CLAUSE_TASK_REDUCTION:
clauses
= c_parser_omp_clause_reduction (parser, OMP_CLAUSE_TASK_REDUCTION,
- clauses);
+ true, clauses);
c_name = "task_reduction";
break;
case PRAGMA_OMP_CLAUSE_UNTIED:
+2018-08-01 Jakub Jelinek <jakub@redhat.com>
+
+ * parser.c (cp_parser_omp_clause_reduction): Add IS_OMP argument,
+ parse reduction modifiers.
+ (cp_parser_oacc_all_clauses, cp_parser_omp_all_clauses): Adjust
+ cp_parser_omp_clause_reduction callers.
+
2018-07-25 Jakub Jelinek <jakub@redhat.com>
* cp-tree.h (finish_omp_atomic): Add LOC argument.
id-expression
OpenMP 5.0:
+ reduction ( reduction-modifier, reduction-operator : variable-list )
in_reduction ( reduction-operator : variable-list )
task_reduction ( reduction-operator : variable-list ) */
static tree
cp_parser_omp_clause_reduction (cp_parser *parser, enum omp_clause_code kind,
- tree list)
+ bool is_omp, tree list)
{
enum tree_code code = ERROR_MARK;
tree nlist, c, id = NULL_TREE;
+ bool task = false;
+ bool inscan = false;
if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
return list;
+ if (kind == OMP_CLAUSE_REDUCTION && is_omp)
+ {
+ if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT)
+ && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA))
+ {
+ cp_lexer_consume_token (parser->lexer);
+ cp_lexer_consume_token (parser->lexer);
+ }
+ else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
+ && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA))
+ {
+ tree id = cp_lexer_peek_token (parser->lexer)->u.value;
+ const char *p = IDENTIFIER_POINTER (id);
+ if (strcmp (p, "task") == 0)
+ task = true;
+ else if (strcmp (p, "inscan") == 0)
+ inscan = true;
+ if (task || inscan)
+ {
+ cp_lexer_consume_token (parser->lexer);
+ cp_lexer_consume_token (parser->lexer);
+ }
+ }
+ }
+
switch (cp_lexer_peek_token (parser->lexer)->type)
{
case CPP_PLUS: code = PLUS_EXPR; break;
for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
{
OMP_CLAUSE_REDUCTION_CODE (c) = code;
+ if (task)
+ OMP_CLAUSE_REDUCTION_TASK (c) = 1;
+ else if (inscan)
+ OMP_CLAUSE_REDUCTION_INSCAN (c) = 1;
OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = id;
}
case PRAGMA_OACC_CLAUSE_REDUCTION:
clauses
= cp_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
- clauses);
+ false, clauses);
c_name = "reduction";
break;
case PRAGMA_OACC_CLAUSE_SEQ:
case PRAGMA_OMP_CLAUSE_IN_REDUCTION:
clauses
= cp_parser_omp_clause_reduction (parser, OMP_CLAUSE_IN_REDUCTION,
- clauses);
+ true, clauses);
c_name = "in_reduction";
break;
case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
case PRAGMA_OMP_CLAUSE_REDUCTION:
clauses
= cp_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
- clauses);
+ true, clauses);
c_name = "reduction";
break;
case PRAGMA_OMP_CLAUSE_SCHEDULE:
clauses
= cp_parser_omp_clause_reduction (parser,
OMP_CLAUSE_TASK_REDUCTION,
- clauses);
+ true, clauses);
c_name = "task_reduction";
break;
case PRAGMA_OMP_CLAUSE_UNTIED:
hash_map<tree, tree> *struct_map_to_clause = NULL;
tree *prev_list_p = NULL;
int handled_depend_iterators = -1;
+ int nowait = -1;
ctx = new_omp_context (region_type);
outer_ctx = ctx->outer_context;
}
goto do_add;
case OMP_CLAUSE_REDUCTION:
+ if (OMP_CLAUSE_REDUCTION_TASK (c))
+ {
+ if (region_type == ORT_WORKSHARE)
+ {
+ if (nowait == -1)
+ nowait = omp_find_clause (*list_p,
+ OMP_CLAUSE_NOWAIT) != NULL_TREE;
+ if (nowait
+ && (outer_ctx == NULL
+ || outer_ctx->region_type != ORT_COMBINED_PARALLEL))
+ {
+ error_at (OMP_CLAUSE_LOCATION (c),
+ "%<task%> reduction modifier on a construct "
+ "with a %<nowait%> clause");
+ OMP_CLAUSE_REDUCTION_TASK (c) = 0;
+ }
+ }
+ else if ((region_type & ORT_PARALLEL) != ORT_PARALLEL)
+ {
+ error_at (OMP_CLAUSE_LOCATION (c),
+ "invalid %<task%> reduction modifier on construct "
+ "other than %<parallel%>, %<for%> or %<sections%>");
+ OMP_CLAUSE_REDUCTION_TASK (c) = 0;
+ }
+ }
+ /* FALLTHRU */
case OMP_CLAUSE_IN_REDUCTION:
case OMP_CLAUSE_TASK_REDUCTION:
flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
break;
case OMP_CLAUSE_NOWAIT:
+ nowait = 1;
+ break;
+
case OMP_CLAUSE_ORDERED:
case OMP_CLAUSE_UNTIED:
case OMP_CLAUSE_COLLAPSE:
+2018-08-01 Jakub Jelinek <jakub@redhat.com>
+
+ * c-c++-common/gomp/reduction-task-1.c: New test.
+ * c-c++-common/gomp/reduction-task-2.c: New test.
+
2018-07-25 Jakub Jelinek <jakub@redhat.com>
* c-c++-common/gomp/teams-1.c: New test.
--- /dev/null
+int v;
+extern void foo (int);
+
+void
+bar (void)
+{
+ int i;
+ #pragma omp for reduction (task, +: v)
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp sections reduction (task, +: v)
+ {
+ foo (-2);
+ #pragma omp section
+ foo (-3);
+ }
+ #pragma omp parallel reduction (task, +: v)
+ foo (-1);
+ #pragma omp parallel for reduction (task, +: v)
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp parallel sections reduction (task, +: v)
+ {
+ foo (-2);
+ #pragma omp section
+ foo (-3);
+ }
+ #pragma omp teams distribute parallel for reduction (task, +: v)
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp for reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp sections reduction (default, +: v)
+ {
+ foo (-2);
+ #pragma omp section
+ foo (-3);
+ }
+ #pragma omp parallel reduction (default, +: v)
+ foo (-1);
+ #pragma omp parallel for reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp parallel sections reduction (default, +: v)
+ {
+ foo (-2);
+ #pragma omp section
+ foo (-3);
+ }
+ #pragma omp teams distribute parallel for reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp for reduction (default, +: v) nowait
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp sections nowait reduction (default, +: v)
+ {
+ foo (-2);
+ #pragma omp section
+ foo (-3);
+ }
+ #pragma omp simd reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp for simd reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp parallel for simd reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp teams distribute parallel for simd reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp taskloop reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp taskloop simd reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp teams reduction (default, +: v)
+ foo (i);
+ #pragma omp teams distribute reduction (default, +: v)
+ for (i = 0; i < 64; i++)
+ foo (i);
+}
--- /dev/null
+int v;
+extern void foo (int);
+
+void
+bar (void)
+{
+ int i;
+ #pragma omp for reduction (task, +: v) nowait /* { dg-error "'task' reduction modifier on a construct with a 'nowait' clause" } */
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp sections nowait reduction (task, +: v) /* { dg-error "'task' reduction modifier on a construct with a 'nowait' clause" } */
+ {
+ foo (-2);
+ #pragma omp section
+ foo (-3);
+ }
+ #pragma omp simd reduction (task, +: v) /* { dg-error "invalid 'task' reduction modifier on construct other than 'parallel', 'for' or 'sections'" } */
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp for simd reduction (task, +: v) /* { dg-error "invalid 'task' reduction modifier on construct combined with 'simd'" } */
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp parallel for simd reduction (task, +: v) /* { dg-error "invalid 'task' reduction modifier on construct combined with 'simd'" } */
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp teams distribute parallel for simd reduction (task, +: v) /* { dg-error "invalid 'task' reduction modifier on construct combined with 'simd'" } */
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp taskloop reduction (task, +: v) /* { dg-error "invalid 'task' reduction modifier on construct other than 'parallel', 'for' or 'sections'" } */
+ for (i = 0; i < 64; i++)
+ foo (i);
+ #pragma omp taskloop simd reduction (task, +: v) /* { dg-error "invalid 'task' reduction modifier on construct combined with 'simd'" } */
+ for (i = 0; i < 64; i++)
+ v++;
+ #pragma omp teams reduction (task, +: v) /* { dg-error "invalid 'task' reduction modifier on construct other than 'parallel', 'for' or 'sections'" } */
+ foo (i);
+ #pragma omp teams distribute reduction (task, +: v) /* { dg-error "invalid 'task' reduction modifier on construct not combined with 'parallel', 'for' or 'sections'" } */
+ for (i = 0; i < 64; i++)
+ foo (i);
+}
/* FALLTHRU */
case OMP_CLAUSE_REDUCTION:
pp_string (pp, "reduction(");
+ if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_REDUCTION)
+ {
+ if (OMP_CLAUSE_REDUCTION_TASK (clause))
+ pp_string (pp, "task,");
+ else if (OMP_CLAUSE_REDUCTION_INSCAN (clause))
+ pp_string (pp, "inscan,");
+ }
if (OMP_CLAUSE_REDUCTION_CODE (clause) != ERROR_MARK)
{
pp_string (pp,
(OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
OMP_CLAUSE_IN_REDUCTION)->base.public_flag)
+/* True if a REDUCTION clause has task reduction-modifier. */
+#define OMP_CLAUSE_REDUCTION_TASK(NODE) \
+ TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
+
+/* True if a REDUCTION clause has inscan reduction-modifier. */
+#define OMP_CLAUSE_REDUCTION_INSCAN(NODE) \
+ TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
+
/* True if a LINEAR clause doesn't need copy in. True for iterator vars which
are always initialized inside of the loop construct, false otherwise. */
#define OMP_CLAUSE_LINEAR_NO_COPYIN(NODE) \
projects / thirdparty / gcc.git / commitdiff
