From patchwork Tue Oct 27 20:22:03 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nathan Sidwell X-Patchwork-Id: 536840 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 B257E141348 for ; Wed, 28 Oct 2015 07:22:20 +1100 (AEDT) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b=vPQa0Ak8; 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=XSlKVHN4mB2mKBoML kU/C/tX+y6Si8hwtCntlAiKMrmfg6roXbMQc/sRL5mIjBBwyCk5EWVcRAtMyqtS8 dE5Eqeu48LnT4jf6e4q7h2rKU+FGe6mppPlQW0oB0EAJafbAC73Q+B075o5swFgN lvFUVTnL3LkesMSz0vcT6vIyOc= 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=4vvIgP8ojCd97zPVfxUZ/wk auA8=; b=vPQa0Ak80JJG0qp9oNhRj6tsg7LRhnBFvBCYo8cISiEVOTCnnJ0bDkn YB9vbO7pmzaNr/paeyE2wkxWTvqb26Sb8CdMAZmwFyRoYFJuCHFxa05uJ9M3LFjC 6GmnrO9C0i4xtbyD6XNjTdJrTEa9/ZywTn5u7Jg4jxDI+/IEcUpI= Received: (qmail 121178 invoked by alias); 27 Oct 2015 20:22:12 -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 121169 invoked by uid 89); 27 Oct 2015 20:22:11 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.8 required=5.0 tests=BAYES_00, FREEMAIL_FROM, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=no version=3.3.2 X-HELO: mail-pa0-f44.google.com Received: from mail-pa0-f44.google.com (HELO mail-pa0-f44.google.com) (209.85.220.44) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Tue, 27 Oct 2015 20:22:08 +0000 Received: by pasz6 with SMTP id z6so231970171pas.2 for ; Tue, 27 Oct 2015 13:22:06 -0700 (PDT) X-Received: by 10.66.170.238 with SMTP id ap14mr29374885pac.128.1445977326299; Tue, 27 Oct 2015 13:22:06 -0700 (PDT) Received: from ?IPv6:2600:1012:b115:101e:a2a8:cdff:fe3e:b48? ([2600:1012:b115:101e:a2a8:cdff:fe3e:b48]) by smtp.googlemail.com with ESMTPSA id wq1sm6807283pbc.49.2015.10.27.13.22.04 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 27 Oct 2015 13:22:05 -0700 (PDT) Subject: Re: [OpenACC 4/11] C FE changes To: Cesar Philippidis , Jakub Jelinek References: <20151022082249.GF478@tucnak.redhat.com> <562A95C3.2040100@mentor.com> <20151023203155.GJ478@tucnak.redhat.com> <562AA73D.6010809@mentor.com> <562AED97.5070803@mentor.com> <20151024080356.GL478@tucnak.redhat.com> <562BF3C2.4060901@mentor.com> <20151026085949.GM478@tucnak.redhat.com> <562EA8E9.50102@mentor.com> Cc: GCC Patches , Bernd Schmidt , Jason Merrill , "Joseph S. Myers" From: Nathan Sidwell Message-ID: <562FDCEB.1060205@acm.org> Date: Tue, 27 Oct 2015 13:22:03 -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: <562EA8E9.50102@mentor.com> On 10/26/15 15:27, Cesar Philippidis wrote: > On 10/26/2015 01:59 AM, Jakub Jelinek wrote: > >> Ok for trunk with those changes fixed. > > Here's the patch with those changes. Nathan will commit this patch the > rest of the openacc execution model patches. This is the patch I've committed. nathan 2015-10-27 Cesar Philippidis Thomas Schwinge James Norris Joseph Myers Julian Brown Nathan Sidwell Bernd Schmidt gcc/cp/ * parser.c (cp_parser_omp_clause_name): Add auto, gang, seq, vector, worker. (cp_parser_oacc_simple_clause): New. (cp_parser_oacc_shape_clause): New. (cp_parser_oacc_all_clauses): Add auto, gang, seq, vector, worker. (OACC_LOOP_CLAUSE_MASK): Likewise. * semantics.c (finish_omp_clauses): Add auto, gang, seq, vector, worker. Unify the handling of teams, tasks and vector_length with the other loop shape clauses. 2015-10-27 Nathan Sidwell Cesar Philippidis gcc/testsuite/ * g++.dg/g++.dg/gomp/pr33372-1.C: Adjust diagnostic. * gcc/testsuite/g++.dg/gomp/pr33372-3.C: Likewise. Index: gcc/cp/semantics.c =================================================================== --- gcc/cp/semantics.c (revision 229443) +++ gcc/cp/semantics.c (working copy) @@ -5965,14 +5965,76 @@ finish_omp_clauses (tree clauses, bool a OMP_CLAUSE_FINAL_EXPR (c) = t; break; + case OMP_CLAUSE_GANG: + /* Operand 1 is the gang static: argument. */ + t = OMP_CLAUSE_OPERAND (c, 1); + if (t != NULL_TREE) + { + if (t == error_mark_node) + remove = true; + else if (!type_dependent_expression_p (t) + && !INTEGRAL_TYPE_P (TREE_TYPE (t))) + { + error ("% static expression must be integral"); + remove = true; + } + else + { + t = mark_rvalue_use (t); + if (!processing_template_decl) + { + t = maybe_constant_value (t); + if (TREE_CODE (t) == INTEGER_CST + && tree_int_cst_sgn (t) != 1 + && t != integer_minus_one_node) + { + warning_at (OMP_CLAUSE_LOCATION (c), 0, + "% static value must be" + "positive"); + t = integer_one_node; + } + } + t = fold_build_cleanup_point_expr (TREE_TYPE (t), t); + } + OMP_CLAUSE_OPERAND (c, 1) = t; + } + /* Check operand 0, the num argument. */ + + case OMP_CLAUSE_WORKER: + case OMP_CLAUSE_VECTOR: + if (OMP_CLAUSE_OPERAND (c, 0) == NULL_TREE) + break; + + case OMP_CLAUSE_NUM_TASKS: + case OMP_CLAUSE_NUM_TEAMS: case OMP_CLAUSE_NUM_THREADS: - t = OMP_CLAUSE_NUM_THREADS_EXPR (c); + case OMP_CLAUSE_NUM_GANGS: + case OMP_CLAUSE_NUM_WORKERS: + case OMP_CLAUSE_VECTOR_LENGTH: + t = OMP_CLAUSE_OPERAND (c, 0); if (t == error_mark_node) remove = true; else if (!type_dependent_expression_p (t) && !INTEGRAL_TYPE_P (TREE_TYPE (t))) { - error ("num_threads expression must be integral"); + switch (OMP_CLAUSE_CODE (c)) + { + case OMP_CLAUSE_GANG: + error_at (OMP_CLAUSE_LOCATION (c), + "% num expression must be integral"); break; + case OMP_CLAUSE_VECTOR: + error_at (OMP_CLAUSE_LOCATION (c), + "% length expression must be integral"); + break; + case OMP_CLAUSE_WORKER: + error_at (OMP_CLAUSE_LOCATION (c), + "% num expression must be integral"); + break; + default: + error_at (OMP_CLAUSE_LOCATION (c), + "%qs expression must be integral", + omp_clause_code_name[OMP_CLAUSE_CODE (c)]); + } remove = true; } else @@ -5984,13 +6046,33 @@ finish_omp_clauses (tree clauses, bool a if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) != 1) { - warning_at (OMP_CLAUSE_LOCATION (c), 0, - "% value must be positive"); + switch (OMP_CLAUSE_CODE (c)) + { + case OMP_CLAUSE_GANG: + warning_at (OMP_CLAUSE_LOCATION (c), 0, + "% num value must be positive"); + break; + case OMP_CLAUSE_VECTOR: + warning_at (OMP_CLAUSE_LOCATION (c), 0, + "% length value must be" + "positive"); + break; + case OMP_CLAUSE_WORKER: + warning_at (OMP_CLAUSE_LOCATION (c), 0, + "% num value must be" + "positive"); + break; + default: + warning_at (OMP_CLAUSE_LOCATION (c), 0, + "%qs value must be positive", + omp_clause_code_name + [OMP_CLAUSE_CODE (c)]); + } t = integer_one_node; } t = fold_build_cleanup_point_expr (TREE_TYPE (t), t); } - OMP_CLAUSE_NUM_THREADS_EXPR (c) = t; + OMP_CLAUSE_OPERAND (c, 0) = t; } break; @@ -6062,35 +6144,6 @@ finish_omp_clauses (tree clauses, bool a } break; - case OMP_CLAUSE_NUM_TEAMS: - t = OMP_CLAUSE_NUM_TEAMS_EXPR (c); - if (t == error_mark_node) - remove = true; - else if (!type_dependent_expression_p (t) - && !INTEGRAL_TYPE_P (TREE_TYPE (t))) - { - error ("% expression must be integral"); - remove = true; - } - else - { - t = mark_rvalue_use (t); - if (!processing_template_decl) - { - t = maybe_constant_value (t); - if (TREE_CODE (t) == INTEGER_CST - && tree_int_cst_sgn (t) != 1) - { - warning_at (OMP_CLAUSE_LOCATION (c), 0, - "% value must be positive"); - t = integer_one_node; - } - t = fold_build_cleanup_point_expr (TREE_TYPE (t), t); - } - OMP_CLAUSE_NUM_TEAMS_EXPR (c) = t; - } - break; - case OMP_CLAUSE_ASYNC: t = OMP_CLAUSE_ASYNC_EXPR (c); if (t == error_mark_node) @@ -6110,16 +6163,6 @@ finish_omp_clauses (tree clauses, bool a } break; - case OMP_CLAUSE_VECTOR_LENGTH: - t = OMP_CLAUSE_VECTOR_LENGTH_EXPR (c); - t = maybe_convert_cond (t); - if (t == error_mark_node) - remove = true; - else if (!processing_template_decl) - t = fold_build_cleanup_point_expr (TREE_TYPE (t), t); - OMP_CLAUSE_VECTOR_LENGTH_EXPR (c) = t; - break; - case OMP_CLAUSE_WAIT: t = OMP_CLAUSE_WAIT_EXPR (c); if (t == error_mark_node) @@ -6547,35 +6590,6 @@ finish_omp_clauses (tree clauses, bool a } goto check_dup_generic; - case OMP_CLAUSE_NUM_TASKS: - t = OMP_CLAUSE_NUM_TASKS_EXPR (c); - if (t == error_mark_node) - remove = true; - else if (!type_dependent_expression_p (t) - && !INTEGRAL_TYPE_P (TREE_TYPE (t))) - { - error ("% expression must be integral"); - remove = true; - } - else - { - t = mark_rvalue_use (t); - if (!processing_template_decl) - { - t = maybe_constant_value (t); - if (TREE_CODE (t) == INTEGER_CST - && tree_int_cst_sgn (t) != 1) - { - warning_at (OMP_CLAUSE_LOCATION (c), 0, - "% value must be positive"); - t = integer_one_node; - } - t = fold_build_cleanup_point_expr (TREE_TYPE (t), t); - } - OMP_CLAUSE_NUM_TASKS_EXPR (c) = t; - } - break; - case OMP_CLAUSE_GRAINSIZE: t = OMP_CLAUSE_GRAINSIZE_EXPR (c); if (t == error_mark_node) @@ -6694,6 +6708,8 @@ finish_omp_clauses (tree clauses, bool a case OMP_CLAUSE_SIMD: case OMP_CLAUSE_DEFAULTMAP: case OMP_CLAUSE__CILK_FOR_COUNT_: + case OMP_CLAUSE_AUTO: + case OMP_CLAUSE_SEQ: break; case OMP_CLAUSE_INBRANCH: Index: gcc/cp/parser.c =================================================================== --- gcc/cp/parser.c (revision 229443) +++ gcc/cp/parser.c (working copy) @@ -29064,7 +29064,9 @@ cp_parser_omp_clause_name (cp_parser *pa { pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE; - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF)) + if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO)) + result = PRAGMA_OACC_CLAUSE_AUTO; + else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF)) result = PRAGMA_OMP_CLAUSE_IF; else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT)) result = PRAGMA_OMP_CLAUSE_DEFAULT; @@ -29122,7 +29124,9 @@ cp_parser_omp_clause_name (cp_parser *pa result = PRAGMA_OMP_CLAUSE_FROM; break; case 'g': - if (!strcmp ("grainsize", p)) + if (!strcmp ("gang", p)) + result = PRAGMA_OACC_CLAUSE_GANG; + else if (!strcmp ("grainsize", p)) result = PRAGMA_OMP_CLAUSE_GRAINSIZE; break; case 'h': @@ -29212,6 +29216,8 @@ cp_parser_omp_clause_name (cp_parser *pa result = PRAGMA_OMP_CLAUSE_SECTIONS; else if (!strcmp ("self", p)) result = PRAGMA_OACC_CLAUSE_SELF; + else if (!strcmp ("seq", p)) + result = PRAGMA_OACC_CLAUSE_SEQ; else if (!strcmp ("shared", p)) result = PRAGMA_OMP_CLAUSE_SHARED; else if (!strcmp ("simd", p)) @@ -29238,7 +29244,9 @@ cp_parser_omp_clause_name (cp_parser *pa result = PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR; break; case 'v': - if (!strcmp ("vector_length", p)) + if (!strcmp ("vector", p)) + result = PRAGMA_OACC_CLAUSE_VECTOR; + else if (!strcmp ("vector_length", p)) result = PRAGMA_OACC_CLAUSE_VECTOR_LENGTH; else if (flag_cilkplus && !strcmp ("vectorlength", p)) result = PRAGMA_CILK_CLAUSE_VECTORLENGTH; @@ -29246,6 +29254,8 @@ cp_parser_omp_clause_name (cp_parser *pa case 'w': if (!strcmp ("wait", p)) result = PRAGMA_OACC_CLAUSE_WAIT; + else if (!strcmp ("worker", p)) + result = PRAGMA_OACC_CLAUSE_WORKER; break; } } @@ -29582,6 +29592,146 @@ cp_parser_oacc_data_clause_deviceptr (cp return list; } +/* OpenACC 2.0: + auto + independent + nohost + seq */ + +static tree +cp_parser_oacc_simple_clause (cp_parser * /* parser */, + enum omp_clause_code code, + tree list, location_t location) +{ + check_no_duplicate_clause (list, code, omp_clause_code_name[code], location); + tree c = build_omp_clause (location, code); + OMP_CLAUSE_CHAIN (c) = list; + return c; +} + +/* 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 +cp_parser_oacc_shape_clause (cp_parser *parser, omp_clause_code kind, + const char *str, tree list) +{ + const char *id = "num"; + cp_lexer *lexer = parser->lexer; + tree ops[2] = { NULL_TREE, NULL_TREE }, c; + location_t loc = cp_lexer_peek_token (lexer)->location; + + if (kind == OMP_CLAUSE_VECTOR) + id = "length"; + + if (cp_lexer_next_token_is (lexer, CPP_OPEN_PAREN)) + { + cp_lexer_consume_token (lexer); + + do + { + cp_token *next = cp_lexer_peek_token (lexer); + int idx = 0; + + /* Gang static argument. */ + if (kind == OMP_CLAUSE_GANG + && cp_lexer_next_token_is_keyword (lexer, RID_STATIC)) + { + cp_lexer_consume_token (lexer); + + if (!cp_parser_require (parser, CPP_COLON, RT_COLON)) + goto cleanup_error; + + idx = 1; + if (ops[idx] != NULL) + { + cp_parser_error (parser, "too many % arguments"); + goto cleanup_error; + } + + /* Check for the '*' argument. */ + if (cp_lexer_next_token_is (lexer, CPP_MULT)) + { + cp_lexer_consume_token (lexer); + ops[idx] = integer_minus_one_node; + + if (cp_lexer_next_token_is (lexer, CPP_COMMA)) + { + cp_lexer_consume_token (lexer); + continue; + } + else break; + } + } + /* Worker num: argument and vector length: arguments. */ + else if (cp_lexer_next_token_is (lexer, CPP_NAME) + && strcmp (id, IDENTIFIER_POINTER (next->u.value)) == 0 + && cp_lexer_nth_token_is (lexer, 2, CPP_COLON)) + { + cp_lexer_consume_token (lexer); /* id */ + cp_lexer_consume_token (lexer); /* ':' */ + } + + /* Now collect the actual argument. */ + if (ops[idx] != NULL_TREE) + { + cp_parser_error (parser, "unexpected argument"); + goto cleanup_error; + } + + tree expr = cp_parser_assignment_expression (parser, NULL, false, + false); + if (expr == error_mark_node) + goto cleanup_error; + + mark_exp_read (expr); + ops[idx] = expr; + + if (kind == OMP_CLAUSE_GANG + && cp_lexer_next_token_is (lexer, CPP_COMMA)) + { + cp_lexer_consume_token (lexer); + continue; + } + break; + } + while (1); + + if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN)) + goto cleanup_error; + } + + check_no_duplicate_clause (list, kind, str, loc); + + c = build_omp_clause (loc, kind); + + if (ops[1]) + OMP_CLAUSE_OPERAND (c, 1) = ops[1]; + + OMP_CLAUSE_OPERAND (c, 0) = ops[0]; + OMP_CLAUSE_CHAIN (c) = list; + + return c; + + cleanup_error: + cp_parser_skip_to_closing_parenthesis (parser, false, false, true); + return list; +} + /* OpenACC: vector_length ( expression ) */ @@ -31306,6 +31456,11 @@ cp_parser_oacc_all_clauses (cp_parser *p clauses = cp_parser_oacc_clause_async (parser, clauses); c_name = "async"; break; + case PRAGMA_OACC_CLAUSE_AUTO: + clauses = cp_parser_oacc_simple_clause (parser, OMP_CLAUSE_AUTO, + clauses, here); + c_name = "auto"; + break; case PRAGMA_OACC_CLAUSE_COLLAPSE: clauses = cp_parser_omp_clause_collapse (parser, clauses, here); c_name = "collapse"; @@ -31338,6 +31493,11 @@ cp_parser_oacc_all_clauses (cp_parser *p clauses = cp_parser_oacc_data_clause_deviceptr (parser, clauses); c_name = "deviceptr"; break; + case PRAGMA_OACC_CLAUSE_GANG: + c_name = "gang"; + clauses = cp_parser_oacc_shape_clause (parser, OMP_CLAUSE_GANG, + c_name, clauses); + break; case PRAGMA_OACC_CLAUSE_HOST: clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses); c_name = "host"; @@ -31382,6 +31542,16 @@ cp_parser_oacc_all_clauses (cp_parser *p clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses); c_name = "self"; break; + case PRAGMA_OACC_CLAUSE_SEQ: + clauses = cp_parser_oacc_simple_clause (parser, OMP_CLAUSE_SEQ, + clauses, here); + c_name = "seq"; + break; + case PRAGMA_OACC_CLAUSE_VECTOR: + c_name = "vector"; + clauses = cp_parser_oacc_shape_clause (parser, OMP_CLAUSE_VECTOR, + c_name, clauses); + break; case PRAGMA_OACC_CLAUSE_VECTOR_LENGTH: clauses = cp_parser_oacc_clause_vector_length (parser, clauses); c_name = "vector_length"; @@ -31390,6 +31560,11 @@ cp_parser_oacc_all_clauses (cp_parser *p clauses = cp_parser_oacc_clause_wait (parser, clauses); c_name = "wait"; break; + case PRAGMA_OACC_CLAUSE_WORKER: + c_name = "worker"; + clauses = cp_parser_oacc_shape_clause (parser, OMP_CLAUSE_WORKER, + c_name, clauses); + break; default: cp_parser_error (parser, "expected %<#pragma acc%> clause"); goto saw_error; @@ -34303,6 +34478,11 @@ cp_parser_oacc_enter_exit_data (cp_parse #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_VECTOR) \ + | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \ + | (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 Index: gcc/testsuite/g++.dg/gomp/pr33372-3.C =================================================================== --- gcc/testsuite/g++.dg/gomp/pr33372-3.C (revision 229443) +++ gcc/testsuite/g++.dg/gomp/pr33372-3.C (working copy) @@ -6,7 +6,7 @@ template void f () { T n = 6; -#pragma omp parallel num_threads(n) // { dg-error "num_threads expression must be integral" } +#pragma omp parallel num_threads(n) // { dg-error "'num_threads' expression must be integral" } ; #pragma omp parallel for schedule(static, n) for (int i = 0; i < 10; i++) // { dg-error "chunk size expression must be integral" } Index: gcc/testsuite/g++.dg/gomp/pr33372-1.C =================================================================== --- gcc/testsuite/g++.dg/gomp/pr33372-1.C (revision 229443) +++ gcc/testsuite/g++.dg/gomp/pr33372-1.C (working copy) @@ -6,7 +6,7 @@ template void f () { extern T n (); -#pragma omp parallel num_threads(n) // { dg-error "num_threads expression must be integral" } +#pragma omp parallel num_threads(n) // { dg-error "'num_threads' expression must be integral" } ; #pragma omp parallel for schedule(static, n) for (int i = 0; i < 10; i++) // { dg-error "chunk size expression must be integral" }