From patchwork Mon Nov 23 14:50:33 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Tobias Burnus X-Patchwork-Id: 1404864 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=sourceware.org; envelope-from=gcc-patches-bounces@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Received: from sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4CfqpF5xrvz9sRK for ; Tue, 24 Nov 2020 01:50:45 +1100 (AEDT) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 90DE5386F442; Mon, 23 Nov 2020 14:50:43 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from esa2.mentor.iphmx.com (esa2.mentor.iphmx.com [68.232.141.98]) by sourceware.org (Postfix) with ESMTPS id 033663857C5A for ; Mon, 23 Nov 2020 14:50:40 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 033663857C5A Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=Tobias_Burnus@mentor.com IronPort-SDR: alAZInDqzHylHHOQO2mEOtIFDlCikBuAqTxK2t9JPu70Y7qgCaW8gKWf/IHf5uFagf1Dc7V33Y 15C2RkuB4UZ3BSQJJvTFBMo42AGOUjvKm37okF+Oco5K2cBbgtx3btYGi9ik9F2A+UgPc5ik42 7y+/6m3I2sZicfoDNmNANcS7RY/nE8ABXNYgkkHYDunnqiSlCae8VJ5iezvZ9sytRhdFErbfj1 xd/wKdcojK5BLzozIf44Di7qoUFpDL7mz087ZoAc3eUAHRr5+70qXHA/fVrKF4hFFqY2D0fhCs jfI= X-IronPort-AV: E=Sophos;i="5.78,363,1599552000"; d="diff'?scan'208";a="55396939" Received: from orw-gwy-02-in.mentorg.com ([192.94.38.167]) by esa2.mentor.iphmx.com with ESMTP; 23 Nov 2020 06:50:39 -0800 IronPort-SDR: C9S7ufDlqvKtRaQ7EH430fLaQDQzTeNaB8hi6nKm6OY8HYr4Xqy+jrDscoSmyhTlYzp+Zpj3wB d+v8Kx3zRrFYKdp8apnTNmA8F32a696cGbIIbhoPdKoQBZYGOYdBqewL27IEf28ov8gBZ6cEMp 2f1Tb68SzZavZvfWTr9NiZlgdHbLojJtlgGGM0VKiufmly72l0RZGgId2baCjWcGHAoRXKa3kN 1eD0zBwEo8w+iuNRDOKYp+nOrfTwVo7aNsNvvVqNR4Oy+diRjdf+oATGKVG9itaF/N74BTiWmt tG8= To: gcc-patches , Jakub Jelinek From: Tobias Burnus Subject: [Patch] OpenMP: C/C++ parse 'omp allocate' Message-ID: Date: Mon, 23 Nov 2020 15:50:33 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.4.3 MIME-Version: 1.0 Content-Language: en-US X-Originating-IP: [137.202.0.90] X-ClientProxiedBy: svr-ies-mbx-02.mgc.mentorg.com (139.181.222.2) To svr-ies-mbx-01.mgc.mentorg.com (139.181.222.1) X-Spam-Status: No, score=-12.4 required=5.0 tests=BAYES_00, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces@gcc.gnu.org Sender: "Gcc-patches" Given that (at least for C/C++) there is some initial support for OpenMP 5.0's allocators, it is likely that users will try it. Also the release notes state: "the allocator routines of OpenMP 5.0, including initial|allocate| clause support in C/C++." The latter does not include the omp allocate directive, still, it can be expected that users will try: #pragma omp allocate(...) And that will fail at runtime. I think that's undesirable, even if - like any unknown directive - -Wunknown-pragmas (-Wall) warns about it. Thoughts? OK? Tobias PS: I have not tried to implement restrictions or additions like 'allocate(a[5])', which is currently rejected. I also did not check whether there are differences between the clause ([partially] implemented) and the directive (this patch). ----------------- Mentor Graphics (Deutschland) GmbH, Arnulfstraße 201, 80634 München / Germany Registergericht München HRB 106955, Geschäftsführer: Thomas Heurung, Alexander Walter OpenMP: C/C++ parse 'omp allocate' gcc/c-family/ChangeLog: * c-pragma.c (omp_pragmas): Add 'allocate'. * c-pragma.h (enum pragma_kind): Add PRAGMA_OMP_ALLOCATE. gcc/c/ChangeLog: * c-parser.c (c_parser_omp_allocate): New. (c_parser_omp_construct): Call it. gcc/cp/ChangeLog: * parser.c (cp_parser_omp_allocate): New. (cp_parser_omp_construct, cp_parser_pragma): Call it. gcc/testsuite/ChangeLog: * c-c++-common/gomp/allocate-5.c: New test. gcc/c-family/c-pragma.c | 1 + gcc/c-family/c-pragma.h | 1 + gcc/c/c-parser.c | 52 ++++++++++++++++++++++++++++ gcc/cp/parser.c | 43 ++++++++++++++++++++++- gcc/testsuite/c-c++-common/gomp/allocate-5.c | 41 ++++++++++++++++++++++ 5 files changed, 137 insertions(+), 1 deletion(-) diff --git a/gcc/c-family/c-pragma.c b/gcc/c-family/c-pragma.c index d68985ca277..e80dcd7c0a1 100644 --- a/gcc/c-family/c-pragma.c +++ b/gcc/c-family/c-pragma.c @@ -1309,6 +1309,7 @@ static const struct omp_pragma_def oacc_pragmas[] = { { "wait", PRAGMA_OACC_WAIT } }; static const struct omp_pragma_def omp_pragmas[] = { + { "allocate", PRAGMA_OMP_ALLOCATE }, { "atomic", PRAGMA_OMP_ATOMIC }, { "barrier", PRAGMA_OMP_BARRIER }, { "cancel", PRAGMA_OMP_CANCEL }, diff --git a/gcc/c-family/c-pragma.h b/gcc/c-family/c-pragma.h index 5a493fe5175..e0e4da6b6b3 100644 --- a/gcc/c-family/c-pragma.h +++ b/gcc/c-family/c-pragma.h @@ -42,6 +42,7 @@ enum pragma_kind { PRAGMA_OACC_UPDATE, PRAGMA_OACC_WAIT, + PRAGMA_OMP_ALLOCATE, PRAGMA_OMP_ATOMIC, PRAGMA_OMP_BARRIER, PRAGMA_OMP_CANCEL, diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c index 7540a15d65d..fddd5c3c8c6 100644 --- a/gcc/c/c-parser.c +++ b/gcc/c/c-parser.c @@ -17255,6 +17255,55 @@ c_parser_oacc_wait (location_t loc, c_parser *parser, char *p_name) return stmt; } +/* OpenMP 5.0: + # pragma omp allocate (list) [allocator(allocator)] */ + +static void +c_parser_omp_allocate (location_t loc, c_parser *parser) +{ + tree allocator = NULL_TREE; + tree nl = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ALLOCATE, NULL_TREE); + if (c_parser_next_token_is (parser, CPP_NAME)) + { + matching_parens parens; + const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value); + c_parser_consume_token (parser); + if (strcmp ("allocator", p) != 0) + error_at (c_parser_peek_token (parser)->location, + "expected %"); + else if (parens.require_open (parser)) + { + location_t expr_loc = c_parser_peek_token (parser)->location; + c_expr expr = c_parser_expr_no_commas (parser, NULL); + expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true); + allocator = expr.value; + allocator = c_fully_fold (allocator, false, NULL); + tree orig_type + = expr.original_type ? expr.original_type : TREE_TYPE (allocator); + orig_type = TYPE_MAIN_VARIANT (orig_type); + if (!INTEGRAL_TYPE_P (TREE_TYPE (allocator)) + || TREE_CODE (orig_type) != ENUMERAL_TYPE + || TYPE_NAME (orig_type) + != get_identifier ("omp_allocator_handle_t")) + { + error_at (expr_loc, "% clause allocator expression " + "has type %qT rather than " + "%", + TREE_TYPE (allocator)); + allocator = NULL_TREE; + } + parens.skip_until_found_close (parser); + } + } + c_parser_skip_to_pragma_eol (parser); + + if (allocator) + for (tree c = nl; c != NULL_TREE; c = OMP_CLAUSE_CHAIN (c)) + OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator; + + sorry_at (loc, "%<#pragma omp allocate%> not yet supported"); +} + /* OpenMP 2.5: # pragma omp atomic new-line expression-stmt @@ -21542,6 +21591,9 @@ c_parser_omp_construct (c_parser *parser, bool *if_p) strcpy (p_name, "#pragma wait"); stmt = c_parser_oacc_wait (loc, parser, p_name); break; + case PRAGMA_OMP_ALLOCATE: + c_parser_omp_allocate (loc, parser); + return; case PRAGMA_OMP_ATOMIC: c_parser_omp_atomic (loc, parser, false); return; diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 88021243ee4..54e71e9743b 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -38136,6 +38136,42 @@ cp_parser_omp_structured_block (cp_parser *parser, bool *if_p) return finish_omp_structured_block (stmt); } +/* OpenMP 5.0: + # pragma omp allocate (list) [allocator(allocator)] */ + +static void +cp_parser_omp_allocate (cp_parser *parser, cp_token *pragma_tok) +{ + tree allocator = NULL_TREE; + location_t loc = pragma_tok->location; + tree nl = cp_parser_omp_var_list (parser, OMP_CLAUSE_ALLOCATE, NULL_TREE); + + if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) + { + matching_parens parens; + tree id = cp_lexer_peek_token (parser->lexer)->u.value; + const char *p = IDENTIFIER_POINTER (id); + location_t cloc = cp_lexer_peek_token (parser->lexer)->location; + cp_lexer_consume_token (parser->lexer); + if (strcmp (p, "allocator") != 0) + error_at (cloc, "expected %"); + else if (parens.require_open (parser)) + { + allocator = cp_parser_assignment_expression (parser); + if (allocator == error_mark_node) + allocator = NULL_TREE; + parens.require_close (parser); + } + } + cp_parser_require_pragma_eol (parser, pragma_tok); + + if (allocator) + for (tree c = nl; c != NULL_TREE; c = OMP_CLAUSE_CHAIN (c)) + OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator; + + sorry_at (loc, "%<#pragma omp allocate%> not yet supported"); +} + /* OpenMP 2.5: # pragma omp atomic new-line expression-stmt @@ -43767,6 +43803,9 @@ cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok, bool *if_p) case PRAGMA_OACC_WAIT: stmt = cp_parser_oacc_wait (parser, pragma_tok); break; + case PRAGMA_OMP_ALLOCATE: + cp_parser_omp_allocate (parser, pragma_tok); + return; case PRAGMA_OMP_ATOMIC: cp_parser_omp_atomic (parser, pragma_tok, false); return; @@ -44412,7 +44451,9 @@ cp_parser_pragma (cp_parser *parser, enum pragma_context context, bool *if_p) goto bad_stmt; cp_parser_omp_construct (parser, pragma_tok, if_p); return true; - + case PRAGMA_OMP_ALLOCATE: + cp_parser_omp_allocate (parser, pragma_tok); + return false; case PRAGMA_OACC_ATOMIC: case PRAGMA_OACC_CACHE: case PRAGMA_OACC_DATA: diff --git a/gcc/testsuite/c-c++-common/gomp/allocate-5.c b/gcc/testsuite/c-c++-common/gomp/allocate-5.c new file mode 100644 index 00000000000..34dcb48c3d7 --- /dev/null +++ b/gcc/testsuite/c-c++-common/gomp/allocate-5.c @@ -0,0 +1,41 @@ +typedef enum omp_allocator_handle_t +#if __cplusplus >= 201103L +: __UINTPTR_TYPE__ +#endif +{ + omp_null_allocator = 0, + omp_default_mem_alloc = 1, + omp_large_cap_mem_alloc = 2, + omp_const_mem_alloc = 3, + omp_high_bw_mem_alloc = 4, + omp_low_lat_mem_alloc = 5, + omp_cgroup_mem_alloc = 6, + omp_pteam_mem_alloc = 7, + omp_thread_mem_alloc = 8, + __omp_allocator_handle_t_max__ = __UINTPTR_MAX__ +} omp_allocator_handle_t; + +void +foo () +{ + int a, b; + omp_allocator_handle_t my_allocator; +#pragma omp allocate (a) /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" } */ +#pragma omp allocate (b) allocator(my_allocator) /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" } */ +} + +void +bar () +{ + int a, b; + omp_allocator_handle_t my_allocator; +#pragma omp allocate /* { dg-error "expected '\\(' before end of line" } */ + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ +#pragma omp allocate allocator(my_allocator) /* { dg-error "expected '\\(' before 'allocator'" } */ + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ +#pragma omp allocate(a) foo(my_allocator) /* { dg-error "expected 'allocator'" } */ + /* { dg-error "expected end of line before '\\(' token" "" { target *-*-* } .-1 } */ + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-2 } */ +#pragma omp allocate(a) allocator(b) /* { dg-error "'allocator' clause allocator expression has type 'int' rather than 'omp_allocator_handle_t'" "todo: cp/semantics.c" { xfail c++ } } */ + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ +}