This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: Re: [OpenACC 4/11] C FE changes
- From: Cesar Philippidis <cesar_philippidis at mentor dot com>
- To: Jakub Jelinek <jakub at redhat dot com>, Nathan Sidwell <nathan at acm dot org>
- Cc: GCC Patches <gcc-patches at gcc dot gnu dot org>, Bernd Schmidt <bschmidt at redhat dot com>, Jason Merrill <jason at redhat dot com>, "Joseph S. Myers" <joseph at codesourcery dot com>
- Date: Fri, 23 Oct 2015 13:17:07 -0700
- Subject: Re: Re: [OpenACC 4/11] C FE changes
- Authentication-results: sourceware.org; auth=none
- References: <20151022082249 dot GF478 at tucnak dot redhat dot com>
On 10/22/2015 01:22 AM, Jakub Jelinek wrote:
> On Wed, Oct 21, 2015 at 03:16:20PM -0400, Nathan Sidwell wrote:
>> 2015-10-20 Cesar Philippidis <cesar@codesourcery.com>
>> Thomas Schwinge <thomas@codesourcery.com>
>> James Norris <jnorris@codesourcery.com>
>> Joseph Myers <joseph@codesourcery.com>
>> Julian Brown <julian@codesourcery.com>
>>
>> * c-parser.c (c_parser_oacc_shape_clause): New.
>> (c_parser_oacc_simple_clause): New.
>> (c_parser_oacc_all_clauses): Add auto, gang, seq, vector, worker.
>> (OACC_LOOP_CLAUSE_MASK): Add gang, worker, vector, auto, seq.
>
> Ok, with one nit.
>
>> /* OpenACC:
>> + gang [( gang_expr_list )]
>> + worker [( expression )]
>> + vector [( expression )] */
>> +
>> +static tree
>> +c_parser_oacc_shape_clause (c_parser *parser, pragma_omp_clause c_kind,
>> + const char *str, tree list)
>
> I think it would be better to remove the c_kind argument and pass to this
> function omp_clause_code kind instead. The callers are already in a big
> switch, with a separate call for each of the clauses.
> After all, e.g. for c_parser_oacc_simple_clause you already do it that way
> too.
>
>> +{
>> + omp_clause_code kind;
>> + const char *id = "num";
>> +
>> + switch (c_kind)
>> + {
>> + default:
>> + gcc_unreachable ();
>> + case PRAGMA_OACC_CLAUSE_GANG:
>> + kind = OMP_CLAUSE_GANG;
>> + break;
>> + case PRAGMA_OACC_CLAUSE_VECTOR:
>> + kind = OMP_CLAUSE_VECTOR;
>> + id = "length";
>> + break;
>> + case PRAGMA_OACC_CLAUSE_WORKER:
>> + kind = OMP_CLAUSE_WORKER;
>> + break;
>> + }
>
> Then you can replace this switch with just if (kind == OMP_CLAUSE_VECTOR)
> id = "length";
Good idea, thanks. This patch also corrects the problems parsing weird
combinations of num, static and length arguments that you mentioned
elsewhere.
Is this OK for trunk?
Nathan, can you try out this patch with your updated patch set? I saw
some test cases getting stuck when expanding expand_GOACC_DIM_SIZE in on
the host compiler, which is wrong. I don't see that happening in
gomp-4_0-branch with this patch. Also, can you merge this patch along
with the c++ and new test case patches to trunk? I'll handle the gomp4
backport.
Cesar
2015-10-20 Cesar Philippidis <cesar@codesourcery.com>
Thomas Schwinge <thomas@codesourcery.com>
James Norris <jnorris@codesourcery.com>
Joseph Myers <joseph@codesourcery.com>
Julian Brown <julian@codesourcery.com>
Bernd Schmidt <bschmidt@redhat.com>
* c-parser.c (c_parser_oacc_shape_clause): New.
(c_parser_oacc_simple_clause): New.
(c_parser_oacc_all_clauses): Add auto, gang, seq, vector, worker.
(OACC_LOOP_CLAUSE_MASK): Add gang, worker, vector, auto, seq.
diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
index c8c6a2d..1e3c333 100644
--- a/gcc/c/c-parser.c
+++ b/gcc/c/c-parser.c
@@ -11188,6 +11188,142 @@ c_parser_omp_clause_num_workers (c_parser *parser, tree list)
}
/* OpenACC:
+
+ gang [( gang-arg-list )]
+ worker [( [num:] int-expr )]
+ vector [( [length:] int-expr )]
+
+ where gang-arg is one of:
+
+ [num:] int-expr
+ static: size-expr
+
+ and size-expr may be:
+
+ *
+ int-expr
+*/
+
+static tree
+c_parser_oacc_shape_clause (c_parser *parser, omp_clause_code kind,
+ const char *str, tree list)
+{
+ const char *id = "num";
+
+ if (kind == OMP_CLAUSE_VECTOR)
+ id = "length";
+
+ tree op0 = NULL_TREE, op1 = NULL_TREE;
+ location_t loc = c_parser_peek_token (parser)->location;
+
+ if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
+ {
+ tree *op_to_parse = &op0;
+ c_parser_consume_token (parser);
+
+ do
+ {
+ loc = c_parser_peek_token (parser)->location;
+ op_to_parse = &op0;
+
+ if ((c_parser_next_token_is (parser, CPP_NAME)
+ || c_parser_next_token_is (parser, CPP_KEYWORD))
+ && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
+ {
+ tree name_kind = c_parser_peek_token (parser)->value;
+ const char *p = IDENTIFIER_POINTER (name_kind);
+ if (kind == OMP_CLAUSE_GANG
+ && c_parser_next_token_is_keyword (parser, RID_STATIC))
+ {
+ c_parser_consume_token (parser); /* static */
+ c_parser_consume_token (parser); /* ':' */
+
+ op_to_parse = &op1;
+ if (c_parser_next_token_is (parser, CPP_MULT))
+ {
+ c_parser_consume_token (parser);
+ *op_to_parse = integer_minus_one_node;
+
+ /* Consume a comma if present. */
+ if (c_parser_next_token_is (parser, CPP_COMMA))
+ c_parser_consume_token (parser);
+
+ continue;
+ }
+ }
+ else if (strcmp (id, p) == 0)
+ {
+ c_parser_consume_token (parser); /* id */
+ c_parser_consume_token (parser); /* ':' */
+ }
+ else
+ {
+ if (kind == OMP_CLAUSE_GANG)
+ c_parser_error (parser, "expected %<num%> or %<static%>");
+ else if (kind == OMP_CLAUSE_VECTOR)
+ c_parser_error (parser, "expected %<length%>");
+ else
+ c_parser_error (parser, "expected %<num%>");
+ c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
+ return list;
+ }
+ }
+
+ if (*op_to_parse != NULL_TREE)
+ {
+ c_parser_error (parser, "unexpected argument");
+ c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
+ return list;
+ }
+
+ tree expr = c_parser_expr_no_commas (parser, NULL).value;
+ if (expr == error_mark_node)
+ {
+ c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
+ return list;
+ }
+
+ mark_exp_read (expr);
+ *op_to_parse = expr;
+
+ /* Consume a comma if present. */
+ if (c_parser_next_token_is (parser, CPP_COMMA))
+ c_parser_consume_token (parser);
+ }
+ while (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN));
+ c_parser_consume_token (parser);
+ }
+
+ check_no_duplicate_clause (list, kind, str);
+
+ tree c = build_omp_clause (loc, kind);
+ if (op0)
+ OMP_CLAUSE_OPERAND (c, 0) = op0;
+ if (op1)
+ OMP_CLAUSE_OPERAND (c, 1) = op1;
+ OMP_CLAUSE_CHAIN (c) = list;
+ return c;
+}
+
+/* OpenACC:
+ auto
+ independent
+ nohost
+ seq */
+
+static tree
+c_parser_oacc_simple_clause (c_parser *parser ATTRIBUTE_UNUSED,
+ enum omp_clause_code code, tree list)
+{
+ check_no_duplicate_clause (list, code, omp_clause_code_name[code]);
+
+ tree c = build_omp_clause (c_parser_peek_token (parser)->location, code);
+ OMP_CLAUSE_CHAIN (c) = list;
+
+ return c;
+}
+
+/* OpenACC:
async [( int-expr )] */
static tree
@@ -12393,6 +12529,11 @@ c_parser_oacc_all_clauses (c_parser *parser, omp_clause_mask mask,
clauses = c_parser_oacc_clause_async (parser, clauses);
c_name = "async";
break;
+ case PRAGMA_OACC_CLAUSE_AUTO:
+ clauses = c_parser_oacc_simple_clause (parser, OMP_CLAUSE_AUTO,
+ clauses);
+ c_name = "auto";
+ break;
case PRAGMA_OACC_CLAUSE_COLLAPSE:
clauses = c_parser_omp_clause_collapse (parser, clauses);
c_name = "collapse";
@@ -12429,6 +12570,11 @@ c_parser_oacc_all_clauses (c_parser *parser, omp_clause_mask mask,
clauses = c_parser_omp_clause_firstprivate (parser, clauses);
c_name = "firstprivate";
break;
+ case PRAGMA_OACC_CLAUSE_GANG:
+ c_name = "gang";
+ clauses = c_parser_oacc_shape_clause (parser, OMP_CLAUSE_GANG,
+ c_name, clauses);
+ break;
case PRAGMA_OACC_CLAUSE_HOST:
clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
c_name = "host";
@@ -12477,6 +12623,16 @@ c_parser_oacc_all_clauses (c_parser *parser, omp_clause_mask mask,
clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
c_name = "self";
break;
+ case PRAGMA_OACC_CLAUSE_SEQ:
+ clauses = c_parser_oacc_simple_clause (parser, OMP_CLAUSE_SEQ,
+ clauses);
+ c_name = "seq";
+ break;
+ case PRAGMA_OACC_CLAUSE_VECTOR:
+ c_name = "vector";
+ clauses = c_parser_oacc_shape_clause (parser, OMP_CLAUSE_VECTOR,
+ c_name, clauses);
+ break;
case PRAGMA_OACC_CLAUSE_VECTOR_LENGTH:
clauses = c_parser_omp_clause_vector_length (parser, clauses);
c_name = "vector_length";
@@ -12485,6 +12641,11 @@ c_parser_oacc_all_clauses (c_parser *parser, omp_clause_mask mask,
clauses = c_parser_oacc_clause_wait (parser, clauses);
c_name = "wait";
break;
+ case PRAGMA_OACC_CLAUSE_WORKER:
+ c_name = "worker";
+ clauses = c_parser_oacc_shape_clause (parser, OMP_CLAUSE_WORKER,
+ c_name, clauses);
+ break;
default:
c_parser_error (parser, "expected %<#pragma acc%> clause");
goto saw_error;
@@ -13015,6 +13176,11 @@ c_parser_oacc_enter_exit_data (c_parser *parser, bool enter)
#define OACC_LOOP_CLAUSE_MASK \
( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
+ | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
+ | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
+ | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
+ | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
+ | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
| (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) )
static tree