From patchwork Tue Dec 13 17:44:27 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Tobias Burnus X-Patchwork-Id: 61878 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 4978B383A0EF for ; Tue, 13 Dec 2022 17:44:55 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from esa1.mentor.iphmx.com (esa1.mentor.iphmx.com [68.232.129.153]) by sourceware.org (Postfix) with ESMTPS id A2B25383B686 for ; Tue, 13 Dec 2022 17:44:34 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org A2B25383B686 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=codesourcery.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=mentor.com X-IronPort-AV: E=Sophos;i="5.96,242,1665475200"; d="diff'?scan'208";a="92768427" Received: from orw-gwy-02-in.mentorg.com ([192.94.38.167]) by esa1.mentor.iphmx.com with ESMTP; 13 Dec 2022 09:44:32 -0800 IronPort-SDR: C0QTvycRt/Ey6PVahVbSXY9mnbtGK3xKd6TqzlOgC9+1DeOzIcQ+pnIiMRu6c5WGu00OPoThlQ Klo6NLH30hG0N5SwUM30bs5yq/7fb7DwfCbzyF1bEs0x+Svowr9mvDATRzxSaCECONouIxWUHu 5PAO1CbjpDp4JHzIQVGN6NJHlmYqI161/VA7b1RVCEC38DlVNCy/p3iUjA5BzeJYegr9KnhLmw WPpKGhJlwLmXJOKXCo30gJt88RCQwF2YCZVU3NcNF47GUFN+L6lEz4IaWf3u0xsoNQ1qur/V3K 2AY= Message-ID: <857e44cb-92ce-7f1d-c036-579d2e345107@codesourcery.com> Date: Tue, 13 Dec 2022 18:44:27 +0100 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.5.1 Content-Language: en-US To: Jakub Jelinek , gcc-patches From: Tobias Burnus Subject: [Patch] OpenMP: Parse align clause in allocate directive in C/C++ X-Originating-IP: [137.202.0.90] X-ClientProxiedBy: svr-ies-mbx-14.mgc.mentorg.com (139.181.222.14) To svr-ies-mbx-12.mgc.mentorg.com (139.181.222.12) X-Spam-Status: No, score=-11.4 required=5.0 tests=BAYES_00, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, SPF_HELO_PASS, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) 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+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" We have a working parsing support for the 'allocate' directive (failing immediately with a sorry after parsing). To be in line with the rest of the allocat(e,or) etc. handling, it makes sense to take care of 'align' as well, which is this patch does - it still fails with a 'sorry' after parsing. OK for mainline? Tobias ----------------- Siemens Electronic Design Automation GmbH; Anschrift: Arnulfstraße 201, 80634 München; Gesellschaft mit beschränkter Haftung; Geschäftsführer: Thomas Heurung, Frank Thürauf; Sitz der Gesellschaft: München; Registergericht München, HRB 106955 OpenMP: Parse align clause in allocate directive in C/C++ gcc/c/ChangeLog: * c-parser.cc (c_parser_omp_allocate): Parse align clause and check for restrictions. gcc/cp/ChangeLog: * parser.cc (cp_parser_omp_allocate): Parse align clause. gcc/testsuite/ChangeLog: * c-c++-common/gomp/allocate-5.c: Extend for align clause. gcc/c/c-parser.cc | 88 ++++++++++++++++++++-------- gcc/cp/parser.cc | 58 +++++++++++++----- gcc/testsuite/c-c++-common/gomp/allocate-5.c | 36 ++++++++++++ 3 files changed, 144 insertions(+), 38 deletions(-) diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc index 1bbb39f9b08..62c302748dd 100644 --- a/gcc/c/c-parser.cc +++ b/gcc/c/c-parser.cc @@ -18819,32 +18819,71 @@ c_parser_oacc_wait (location_t loc, c_parser *parser, char *p_name) return stmt; } -/* OpenMP 5.0: - # pragma omp allocate (list) [allocator(allocator)] */ +/* OpenMP 5.x: + # pragma omp allocate (list) clauses + + OpenMP 5.0 clause: + allocator (omp_allocator_handle_t expression) + + OpenMP 5.1 additional clause: + align (int expression)] */ static void c_parser_omp_allocate (location_t loc, c_parser *parser) { + tree alignment = NULL_TREE; 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_COMMA) - && c_parser_peek_2nd_token (parser)->type == CPP_NAME) - c_parser_consume_token (parser); - if (c_parser_next_token_is (parser, CPP_NAME)) + do { + if (c_parser_next_token_is (parser, CPP_COMMA) + && c_parser_peek_2nd_token (parser)->type == CPP_NAME) + c_parser_consume_token (parser); + if (!c_parser_next_token_is (parser, CPP_NAME)) + break; 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; + if (strcmp ("align", p) != 0 && strcmp ("allocator", p) != 0) { - 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); + error_at (c_parser_peek_token (parser)->location, + "expected % or %"); + break; + } + if (!parens.require_open (parser)) + break; + + c_expr expr = c_parser_expr_no_commas (parser, NULL); + expr = convert_lvalue_to_rvalue (expr_loc, expr, false, true); + expr_loc = c_parser_peek_token (parser)->location; + if (p[2] == 'i' && alignment) + { + error_at (expr_loc, "too many %qs clauses", "align"); + break; + } + else if (p[2] == 'i') + { + alignment = c_fully_fold (expr.value, false, NULL); + if (TREE_CODE (alignment) != INTEGER_CST + || !INTEGRAL_TYPE_P (TREE_TYPE (alignment)) + || tree_int_cst_sgn (alignment) != 1 + || !integer_pow2p (alignment)) + { + error_at (expr_loc, "% clause argument needs to be " + "positive constant power of two integer " + "expression"); + alignment = NULL_TREE; + } + } + else if (allocator) + { + error_at (expr_loc, "too many %qs clauses", "allocator"); + break; + } + else + { + allocator = c_fully_fold (expr.value, false, NULL); tree orig_type = expr.original_type ? expr.original_type : TREE_TYPE (allocator); orig_type = TYPE_MAIN_VARIANT (orig_type); @@ -18853,20 +18892,23 @@ c_parser_omp_allocate (location_t loc, c_parser *parser) || 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)); + error_at (expr_loc, + "% clause allocator expression has type " + "%qT rather than %", + TREE_TYPE (allocator)); allocator = NULL_TREE; } - parens.skip_until_found_close (parser); } - } + parens.skip_until_found_close (parser); + } while (true); c_parser_skip_to_pragma_eol (parser); - if (allocator) + if (allocator || alignment) for (tree c = nl; c != NULL_TREE; c = OMP_CLAUSE_CHAIN (c)) - OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator; + { + OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator; + OMP_CLAUSE_ALLOCATE_ALIGN (c) = alignment; + } sorry_at (loc, "%<#pragma omp allocate%> not yet supported"); } diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 4798aae1fbb..d284022266f 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -41398,36 +41398,64 @@ static void cp_parser_omp_allocate (cp_parser *parser, cp_token *pragma_tok) { tree allocator = NULL_TREE; + tree alignment = 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_COMMA) - && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME)) - cp_lexer_consume_token (parser->lexer); - - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) + do { + if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA) + && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME)) + cp_lexer_consume_token (parser->lexer); + + if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME)) + break; 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)) + if (strcmp (p, "allocator") != 0 && strcmp (p, "align") != 0) { - allocator = cp_parser_assignment_expression (parser); - if (allocator == error_mark_node) - allocator = NULL_TREE; - parens.require_close (parser); + error_at (cloc, "expected % or %"); + break; } - } + if (!parens.require_open (parser)) + break; + tree expr = cp_parser_assignment_expression (parser); + if (p[2] == 'i' && alignment) + { + error_at (cloc, "too many %qs clauses", "align"); + break; + } + else if (p[2] == 'i') + { + if (expr != error_mark_node) + alignment = expr; + } + else if (allocator) + { + error_at (cloc, "too many %qs clauses", "allocator"); + break; + } + else + { + if (expr != error_mark_node) + allocator = expr; + } + parens.require_close (parser); + } while (true); cp_parser_require_pragma_eol (parser, pragma_tok); - if (allocator) + if (allocator || alignment) for (tree c = nl; c != NULL_TREE; c = OMP_CLAUSE_CHAIN (c)) - OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator; + { + OMP_CLAUSE_ALLOCATE_ALLOCATOR (c) = allocator; + OMP_CLAUSE_ALLOCATE_ALIGN (c) = alignment; + } + /* align/allocator needs same check as the modifiers to the + 'allocator' clause in semantics.cc's finish_omp_clauses. */ sorry_at (loc, "%<#pragma omp allocate%> not yet supported"); } diff --git a/gcc/testsuite/c-c++-common/gomp/allocate-5.c b/gcc/testsuite/c-c++-common/gomp/allocate-5.c index 34dcb48c3d7..997e7f06896 100644 --- a/gcc/testsuite/c-c++-common/gomp/allocate-5.c +++ b/gcc/testsuite/c-c++-common/gomp/allocate-5.c @@ -39,3 +39,39 @@ bar () #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 } */ } + + +void +align_test () +{ + int i; + #pragma omp allocate(i) allocator(omp_default_mem_alloc), align(32) + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ + #pragma omp allocate(i) align ( 32 ),allocator(omp_default_mem_alloc) + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ + #pragma omp allocate(i),allocator(omp_default_mem_alloc) align(32) + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ + #pragma omp allocate(i) align ( 32 ) allocator(omp_default_mem_alloc) + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ + + #pragma omp allocate(i) allocator ( omp_high_bw_mem_alloc ), align ( 32 ) allocator(omp_default_mem_alloc) + /* { dg-error "too many 'allocator' clauses" "" { target *-*-* } .-1 } */ + /* { dg-error "expected end of line before '\\)' token" "" { target *-*-* } .-2 } */ + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-3 } */ + #pragma omp allocate(i) align ( 32 ), align(32) allocator(omp_default_mem_alloc) + /* { dg-error "too many 'align' clauses" "" { target *-*-* } .-1 } */ + /* { dg-error "expected end of line before '\\)' token" "" { target *-*-* } .-2 } */ + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-3 } */ +} + +void +align_test2 () +{ + int i; + #pragma omp allocate(i) align (32.0) /* { dg-error "'align' clause argument needs to be positive constant power of two integer expression" "todo: cp/semantics.c" { xfail c++ } } */ + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ + #pragma omp allocate(i) align ( 31 ) /* { dg-error "'align' clause argument needs to be positive constant power of two integer expression" "todo: cp/semantics.c" { xfail c++ } } */ + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ + #pragma omp allocate(i) align ( -32 ) /* { dg-error "'align' clause argument needs to be positive constant power of two integer expression" "todo: cp/semantics.c" { xfail c++ } } */ + /* { dg-message "sorry, unimplemented: '#pragma omp allocate' not yet supported" "" { target *-*-* } .-1 } */ +}