diff options
author | Alexey Bataev <a.bataev@hotmail.com> | 2014-06-26 12:05:45 +0000 |
---|---|---|
committer | Alexey Bataev <a.bataev@hotmail.com> | 2014-06-26 12:05:45 +0000 |
commit | f0a57f4453809e08ae1b4feaeec2c91c5257af48 (patch) | |
tree | 63157d4916525a53de363118a4a7aad768dadd1e /test | |
parent | 0eca5e96c1b22228c8efe6a99df123186bfb340b (diff) | |
download | clang-f0a57f4453809e08ae1b4feaeec2c91c5257af48.tar.gz clang-f0a57f4453809e08ae1b4feaeec2c91c5257af48.tar.bz2 clang-f0a57f4453809e08ae1b4feaeec2c91c5257af48.tar.xz |
[OPENMP] Initial parsing and sema analysis for 'single' directive.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@211774 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'test')
-rw-r--r-- | test/OpenMP/nesting_of_regions.cpp | 112 | ||||
-rw-r--r-- | test/OpenMP/single_ast_print.cpp | 38 | ||||
-rw-r--r-- | test/OpenMP/single_firstprivate_messages.cpp | 239 | ||||
-rw-r--r-- | test/OpenMP/single_misc_messages.c | 151 | ||||
-rw-r--r-- | test/OpenMP/single_private_messages.cpp | 140 |
5 files changed, 680 insertions, 0 deletions
diff --git a/test/OpenMP/nesting_of_regions.cpp b/test/OpenMP/nesting_of_regions.cpp index 9d0ee29ec3..79f3cd6782 100644 --- a/test/OpenMP/nesting_of_regions.cpp +++ b/test/OpenMP/nesting_of_regions.cpp @@ -22,6 +22,9 @@ void foo() { { bar(); } +#pragma omp parallel +#pragma omp single + bar(); #pragma omp simd for (int i = 0; i < 10; ++i) { #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}} @@ -54,6 +57,13 @@ void foo() { bar(); } } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } #pragma omp for for (int i = 0; i < 10; ++i) { #pragma omp for // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} @@ -86,6 +96,13 @@ void foo() { bar(); } } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } + } #pragma omp sections { #pragma omp for // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} @@ -118,10 +135,50 @@ void foo() { bar(); } } +#pragma omp sections + { +#pragma omp section + { +#pragma omp single // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + bar(); + } + } #pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}} { bar(); } +#pragma omp single + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { +#pragma omp single // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp single + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } } void foo() { @@ -143,6 +200,14 @@ void foo() { { bar(); } +#pragma omp parallel +#pragma omp sections + { + bar(); + } +#pragma omp parallel +#pragma omp single + bar(); #pragma omp simd for (int i = 0; i < 10; ++i) { #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}} @@ -175,6 +240,11 @@ void foo() { bar(); } } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } #pragma omp for for (int i = 0; i < 10; ++i) { #pragma omp for // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} @@ -207,6 +277,11 @@ void foo() { bar(); } } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + bar(); + } #pragma omp sections { #pragma omp for // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} @@ -239,10 +314,47 @@ void foo() { bar(); } } +#pragma omp sections + { +#pragma omp single // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + bar(); + } #pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}} { bar(); } +#pragma omp single + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { +#pragma omp single // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp single + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } return foo<int>(); } diff --git a/test/OpenMP/single_ast_print.cpp b/test/OpenMP/single_ast_print.cpp new file mode 100644 index 0000000000..eaae114960 --- /dev/null +++ b/test/OpenMP/single_ast_print.cpp @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ast-print %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +void foo() {} + +template <class T, int N> +T tmain(T argc) { + T b = argc, c, d, e, f, g; + static T a; +// CHECK: static T a; +#pragma omp parallel +#pragma omp single private(argc, b), firstprivate(c, d), nowait + foo(); + // CHECK-NEXT: #pragma omp parallel + // CHECK-NEXT: #pragma omp single private(argc,b) firstprivate(c,d) nowait + // CHECK-NEXT: foo(); + return T(); +} + +int main(int argc, char **argv) { + int b = argc, c, d, e, f, g; + static int a; +// CHECK: static int a; +#pragma omp parallel +#pragma omp single private(argc, b), firstprivate(argv, c), nowait + foo(); + // CHECK-NEXT: #pragma omp parallel + // CHECK-NEXT: #pragma omp single private(argc,b) firstprivate(argv,c) nowait + // CHECK-NEXT: foo(); + return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0])); +} + +#endif diff --git a/test/OpenMP/single_firstprivate_messages.cpp b/test/OpenMP/single_firstprivate_messages.cpp new file mode 100644 index 0000000000..6d4988254f --- /dev/null +++ b/test/OpenMP/single_firstprivate_messages.cpp @@ -0,0 +1,239 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; + static const float S2sc; +}; +const float S2::S2sc = 0; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; +const S3 ca[5]; +extern const int f; +class S4 { // expected-note 2 {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note 4 {{'S5' declared here}} + int a; + S5(const S5 &s5) : a(s5.a) {} + +public: + S5() : a(0) {} + S5(int v) : a(v) {} +}; +class S6 { + int a; + S6() : a(0) {} + +public: + S6(const S6 &s6) : a(s6.a) {} + S6(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class I, class C> +int foomain(int argc, char **argv) { + I e(4); // expected-note {{'e' defined here}} + C g(5); // expected-note 2 {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp single firstprivate // expected-error {{expected '(' after 'firstprivate'}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate() // expected-error {{expected expression}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argc) + foo(); +#pragma omp parallel +#pragma omp single firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(a, b) // expected-error {{firstprivate variable with incomplete type 'S1'}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argv[1]) // expected-error {{expected variable name}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + foo(); +#pragma omp parallel +#pragma omp single linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp single'}} + foo(); +#pragma omp parallel + { + int v = 0; + int i; // expected-note {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp single' directive into a parallel or another task region?}} +#pragma omp single firstprivate(i) // expected-error {{private variable cannot be firstprivate}} + foo(); + v += i; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp single firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(i) + foo(); +#pragma omp parallel +#pragma omp single firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} + foo(); +#pragma omp parallel private(i) // expected-note {{defined as private}} +#pragma omp single firstprivate(i) // expected-error {{firstprivate variable must be shared}} + foo(); +#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}} +#pragma omp single firstprivate(i) // expected-error {{firstprivate variable must be shared}} + foo(); + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; + const int da[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note 2 {{'g' defined here}} + S3 m; + S6 n(2); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp single firstprivate // expected-error {{expected '(' after 'firstprivate'}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate() // expected-error {{expected expression}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argc) + foo(); +#pragma omp parallel +#pragma omp single firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(argv[1]) // expected-error {{expected variable name}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(2 * 2) // expected-error {{expected variable name}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(ba) // OK + foo(); +#pragma omp parallel +#pragma omp single firstprivate(ca) // OK + foo(); +#pragma omp parallel +#pragma omp single firstprivate(da) // OK + foo(); + int xa; +#pragma omp parallel +#pragma omp single firstprivate(xa) // OK + foo(); +#pragma omp parallel +#pragma omp single firstprivate(S2::S2s) // OK + foo(); +#pragma omp parallel +#pragma omp single firstprivate(S2::S2sc) // OK + foo(); +#pragma omp parallel +#pragma omp single safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp single'}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(m) // OK + foo(); +#pragma omp parallel +#pragma omp single firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + foo(); +#pragma omp parallel +#pragma omp single private(xa), firstprivate(xa) // expected-error {{private variable cannot be firstprivate}} expected-note {{defined as private}} + foo(); +#pragma omp parallel shared(xa) +#pragma omp single firstprivate(xa) // OK: may be firstprivate + foo(); +#pragma omp parallel +#pragma omp single firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(n) // OK + foo(); +#pragma omp parallel + { + int v = 0; + int i; // expected-note {{variable with automatic storage duration is predetermined as private; perhaps you forget to enclose 'omp single' directive into a parallel or another task region?}} +#pragma omp single firstprivate(i) // expected-error {{private variable cannot be firstprivate}} + foo(); + v += i; + } +#pragma omp parallel private(i) // expected-note {{defined as private}} +#pragma omp single firstprivate(i) // expected-error {{firstprivate variable must be shared}} + foo(); +#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}} +#pragma omp single firstprivate(i) // expected-error {{firstprivate variable must be shared}} + foo(); + + return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}} +} diff --git a/test/OpenMP/single_misc_messages.c b/test/OpenMP/single_misc_messages.c new file mode 100644 index 0000000000..8667b50469 --- /dev/null +++ b/test/OpenMP/single_misc_messages.c @@ -0,0 +1,151 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s + +void foo(); + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp single'}} +#pragma omp single + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp single'}} +#pragma omp single foo + +void test_no_clause() { + int i; +#pragma omp single + foo(); + +#pragma omp single + ++i; +} + +void test_branch_protected_scope() { + int i = 0; +L1: + ++i; + + int x[24]; + +#pragma omp parallel +#pragma omp single + { + if (i == 5) + goto L1; // expected-error {{use of undeclared label 'L1'}} + else if (i == 6) + return; // expected-error {{cannot return from OpenMP region}} + else if (i == 7) + goto L2; + else if (i == 8) { + L2: + x[i]++; + } + } + + if (x[0] == 0) + goto L2; // expected-error {{use of undeclared label 'L2'}} + else if (x[1] == 1) + goto L1; +} + +void test_invalid_clause() { + int i; +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp single' are ignored}} +#pragma omp single foo bar + foo(); +} + +void test_non_identifiers() { + int i, x; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp single' are ignored}} +#pragma omp single; + foo(); +#pragma omp parallel +// expected-error@+2 {{unexpected OpenMP clause 'linear' in directive '#pragma omp single'}} +// expected-warning@+1 {{extra tokens at the end of '#pragma omp single' are ignored}} +#pragma omp single linear(x); + foo(); + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp single' are ignored}} +#pragma omp single private(x); + foo(); + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp single' are ignored}} +#pragma omp single, private(x); + foo(); +} + +void test_private() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp single private( + foo(); +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp single private(, + foo(); +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp single private(, ) + foo(); +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp single private() + foo(); +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp single private(int) + foo(); +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp single private(0) + foo(); + + int x, y, z; +#pragma omp parallel +#pragma omp single private(x) + foo(); +#pragma omp parallel +#pragma omp single private(x, y) + foo(); +#pragma omp parallel +#pragma omp single private(x, y, z) + foo(); +} + +void test_firstprivate() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp single firstprivate( + foo(); + +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp single firstprivate(, + foo(); +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp single firstprivate(, ) + foo(); +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp single firstprivate() + foo(); +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp single firstprivate(int) + foo(); +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp single firstprivate(0) + foo(); +} + diff --git a/test/OpenMP/single_private_messages.cpp b/test/OpenMP/single_private_messages.cpp new file mode 100644 index 0000000000..1414a92ee0 --- /dev/null +++ b/test/OpenMP/single_private_messages.cpp @@ -0,0 +1,140 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} +}; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + +public: + S3() : a(0) {} +}; +const S3 ca[5]; +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + +public: + S5(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class I, class C> +int foomain(I argc, C **argv) { + I e(4); + I g(5); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp single private // expected-error {{expected '(' after 'private'}} + foo(); +#pragma omp single private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp single private() // expected-error {{expected expression}} + foo(); +#pragma omp single private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp single private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp single private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); +#pragma omp single private(argc) + foo(); +#pragma omp single private(S1) // expected-error {{'S1' does not refer to a value}} + foo(); +#pragma omp single private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + foo(); +#pragma omp single private(argv[1]) // expected-error {{expected variable name}} + foo(); +#pragma omp single private(e, g) + foo(); +#pragma omp single private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + foo(); +#pragma omp single shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp single'}} + foo(); +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp single private(i) + foo(); + v += i; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp single private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + foo(); +#pragma omp single private(i) + foo(); + return 0; +} + +int main(int argc, char **argv) { + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp single private // expected-error {{expected '(' after 'private'}} + foo(); +#pragma omp single private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp single private() // expected-error {{expected expression}} + foo(); +#pragma omp single private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp single private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp single private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); +#pragma omp single private(argc) + foo(); +#pragma omp single private(S1) // expected-error {{'S1' does not refer to a value}} + foo(); +#pragma omp single private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + foo(); +#pragma omp single private(argv[1]) // expected-error {{expected variable name}} + foo(); +#pragma omp single private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} + foo(); +#pragma omp single private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + foo(); +#pragma omp single shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp single'}} + foo(); +#pragma omp parallel + { + int i; +#pragma omp single private(i) + foo(); + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp single private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + foo(); +#pragma omp single private(i) + foo(); + + return 0; +} + |