From patchwork Fri Oct 23 20:17:07 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cesar Philippidis X-Patchwork-Id: 535243 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 59CC91402CC for ; Sat, 24 Oct 2015 07:17:24 +1100 (AEDT) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b=tpK1ihhT; dkim-atps=neutral DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :subject:to:references:cc:from:message-id:date:mime-version :in-reply-to:content-type; q=dns; s=default; b=oldPLMp1JgRMk9WLr oaoPPgL0YNq/fGmqkXb964VDYG9P0YqSS5f3Z5W5LYVzgJQjNxJYHu+4GQIDDQq0 H9pgsk53aGcFCkXkwyW6DDDQ6SaBjVVNvu4VUfiY7JbYOHUgRcdU14B8g/C8c0IT QVP67MX9qqbY+tWxKKoUmApfEg= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :subject:to:references:cc:from:message-id:date:mime-version :in-reply-to:content-type; s=default; bh=v6poCsm9hqihDOX9owusV1V cyiU=; b=tpK1ihhTjj6pcmGUuJ2qYiaXgRG1mt5E+66BwQ0es6IDM8exKlV4DP2 zu5ra7RQS0u5zCaiuITPAt0XqC2lQH6XBOLb6xVxOZ2sDvjEYF8NIMybI7h0q+WL o4pYYwOsOL5WBXxeH+iPhyhPOk+EJwH2JwBQFvz7cOhbE6Q0SZ/g= Received: (qmail 119335 invoked by alias); 23 Oct 2015 20:17:15 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 119322 invoked by uid 89); 23 Oct 2015 20:17:14 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.2 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: relay1.mentorg.com Received: from relay1.mentorg.com (HELO relay1.mentorg.com) (192.94.38.131) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 23 Oct 2015 20:17:13 +0000 Received: from svr-orw-fem-04.mgc.mentorg.com ([147.34.97.41]) by relay1.mentorg.com with esmtp id 1Zpilw-0005e8-P7 from Cesar_Philippidis@mentor.com ; Fri, 23 Oct 2015 13:17:08 -0700 Received: from [127.0.0.1] (147.34.91.1) by svr-orw-fem-04.mgc.mentorg.com (147.34.97.41) with Microsoft SMTP Server id 14.3.224.2; Fri, 23 Oct 2015 13:17:08 -0700 Subject: Re: Re: [OpenACC 4/11] C FE changes To: Jakub Jelinek , Nathan Sidwell References: <20151022082249.GF478@tucnak.redhat.com> CC: GCC Patches , Bernd Schmidt , Jason Merrill , "Joseph S. Myers" From: Cesar Philippidis Message-ID: <562A95C3.2040100@mentor.com> Date: Fri, 23 Oct 2015 13:17:07 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.3.0 MIME-Version: 1.0 In-Reply-To: <20151022082249.GF478@tucnak.redhat.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 >> Thomas Schwinge >> James Norris >> Joseph Myers >> Julian Brown >> >> * 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 Thomas Schwinge James Norris Joseph Myers Julian Brown Bernd Schmidt * 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 % or %"); + else if (kind == OMP_CLAUSE_VECTOR) + c_parser_error (parser, "expected %"); + else + c_parser_error (parser, "expected %"); + 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