diff options
Diffstat (limited to 'test/OpenMP')
99 files changed, 16352 insertions, 57 deletions
diff --git a/test/OpenMP/barrier_ast_print.cpp b/test/OpenMP/barrier_ast_print.cpp new file mode 100644 index 000000000000..0ce344f6d992 --- /dev/null +++ b/test/OpenMP/barrier_ast_print.cpp @@ -0,0 +1,32 @@ +// 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> +T tmain(T argc) { + static T a; +#pragma omp barrier + return a + argc; +} +// CHECK: static int a; +// CHECK-NEXT: #pragma omp barrier +// CHECK: static char a; +// CHECK-NEXT: #pragma omp barrier +// CHECK: static T a; +// CHECK-NEXT: #pragma omp barrier + +int main(int argc, char **argv) { + static int a; +// CHECK: static int a; +#pragma omp barrier + // CHECK-NEXT: #pragma omp barrier + return tmain(argc) + tmain(argv[0][0]) + a; +} + +#endif diff --git a/test/OpenMP/barrier_messages.cpp b/test/OpenMP/barrier_messages.cpp new file mode 100644 index 000000000000..81ff84eab746 --- /dev/null +++ b/test/OpenMP/barrier_messages.cpp @@ -0,0 +1,110 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +template <class T> +T tmain(T argc) { +#pragma omp barrier + ; +#pragma omp barrier untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp barrier'}} +#pragma omp barrier unknown // expected-warning {{extra tokens at the end of '#pragma omp barrier' are ignored}} + if (argc) +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + if (argc) { +#pragma omp barrier + } + while (argc) +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + while (argc) { +#pragma omp barrier + } + do +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp barrier + } while (argc); + switch (argc) +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp barrier + } + switch (argc) { +#pragma omp barrier + case 1: +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + break; + default: { +#pragma omp barrier + } break; + } + for (;;) +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + for (;;) { +#pragma omp barrier + } +label: +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} +label1 : { +#pragma omp barrier +} + + return T(); +} + +int main(int argc, char **argv) { +#pragma omp barrier + ; +#pragma omp barrier untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp barrier'}} +#pragma omp barrier unknown // expected-warning {{extra tokens at the end of '#pragma omp barrier' are ignored}} + if (argc) +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + if (argc) { +#pragma omp barrier + } + while (argc) +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + while (argc) { +#pragma omp barrier + } + do +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp barrier + } while (argc); + switch (argc) +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp barrier + } + switch (argc) { +#pragma omp barrier + case 1: +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + break; + default: { +#pragma omp barrier + } break; + } + for (;;) +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} + for (;;) { +#pragma omp barrier + } +label: +#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}} +label1 : { +#pragma omp barrier +} + + return tmain(argc); +} diff --git a/test/OpenMP/critical_ast_print.cpp b/test/OpenMP/critical_ast_print.cpp new file mode 100644 index 000000000000..98ece88e0f71 --- /dev/null +++ b/test/OpenMP/critical_ast_print.cpp @@ -0,0 +1,29 @@ +// 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() {} + +int main (int argc, char **argv) { + int b = argc, c, d, e, f, g; + static int a; +// CHECK: static int a; +#pragma omp critical + a=2; +// CHECK-NEXT: #pragma omp critical +// CHECK-NEXT: a = 2; +// CHECK-NEXT: ++a; + ++a; +#pragma omp critical (the_name) + foo(); +// CHECK-NEXT: #pragma omp critical (the_name) +// CHECK-NEXT: foo(); +// CHECK-NEXT: return 0; + return 0; +} + +#endif diff --git a/test/OpenMP/critical_messages.cpp b/test/OpenMP/critical_messages.cpp new file mode 100644 index 000000000000..08df9e0666e4 --- /dev/null +++ b/test/OpenMP/critical_messages.cpp @@ -0,0 +1,72 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +int foo(); + +int main() { + #pragma omp critical + ; + #pragma omp critical untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp critical'}} + #pragma omp critical unknown // expected-warning {{extra tokens at the end of '#pragma omp critical' are ignored}} + #pragma omp critical ( // expected-error {{expected identifier}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp critical ( + // expected-error {{expected identifier}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp critical (name // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp critical (name1) + foo(); + { + #pragma omp critical + } // expected-error {{expected statement}} + #pragma omp critical (name) // expected-note {{previous 'critical' region starts here}} + #pragma omp critical + for (int i = 0; i < 10; ++i) { + foo(); + #pragma omp parallel + #pragma omp for + for (int j = 0; j < 10; j++) { + foo(); + #pragma omp critical(name) // expected-error {{cannot nest 'critical' regions having the same name 'name'}} + foo(); + } + } + #pragma omp critical (name) + #pragma omp critical + for (int i = 0; i < 10; ++i) { + foo(); + #pragma omp parallel + #pragma omp for + for (int j = 0; j < 10; j++) { + #pragma omp critical + foo(); + } + } + #pragma omp critical (name) + #pragma omp critical + for (int i = 0; i < 10; ++i) { + foo(); + #pragma omp parallel + #pragma omp for + for (int j = 0; j < 10; j++) { + #pragma omp critical (nam) + foo(); + } + } + + return 0; +} + +int foo() { + L1: + foo(); + #pragma omp critical + { + foo(); + goto L1; // expected-error {{use of undeclared label 'L1'}} + } + goto L2; // expected-error {{use of undeclared label 'L2'}} + #pragma omp critical + { + L2: + foo(); + } + + return 0; +} diff --git a/test/OpenMP/flush_ast_print.cpp b/test/OpenMP/flush_ast_print.cpp new file mode 100644 index 000000000000..7eb18f0c17f2 --- /dev/null +++ b/test/OpenMP/flush_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> +T tmain(T argc) { + static T a; +#pragma omp flush +#pragma omp flush(a) + return a + argc; +} +// CHECK: static int a; +// CHECK-NEXT: #pragma omp flush +// CHECK-NEXT: #pragma omp flush (a) +// CHECK: static char a; +// CHECK-NEXT: #pragma omp flush +// CHECK-NEXT: #pragma omp flush (a) +// CHECK: static T a; +// CHECK-NEXT: #pragma omp flush +// CHECK-NEXT: #pragma omp flush (a) + +int main(int argc, char **argv) { + static int a; +// CHECK: static int a; +#pragma omp flush +#pragma omp flush(a) +// CHECK-NEXT: #pragma omp flush +// CHECK-NEXT: #pragma omp flush (a) + return tmain(argc) + tmain(argv[0][0]) + a; +} + +#endif diff --git a/test/OpenMP/flush_messages.cpp b/test/OpenMP/flush_messages.cpp new file mode 100644 index 000000000000..8c61680929ab --- /dev/null +++ b/test/OpenMP/flush_messages.cpp @@ -0,0 +1,134 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +struct S1 { // expected-note 2 {{declared here}} + int a; +}; + +template <class T> +T tmain(T argc) { +#pragma omp flush + ; +#pragma omp flush untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp flush'}} +#pragma omp flush unknown // expected-warning {{extra tokens at the end of '#pragma omp flush' are ignored}} + if (argc) +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + if (argc) { +#pragma omp flush + } + while (argc) +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + while (argc) { +#pragma omp flush + } + do +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp flush + } while (argc); + switch (argc) +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp flush + } + switch (argc) { +#pragma omp flush + case 1: +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + break; + default: { +#pragma omp flush + } break; + } + for (;;) +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + for (;;) { +#pragma omp flush + } +label: +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} +label1 : { +#pragma omp flush +} + +#pragma omp flush +#pragma omp flush( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp flush() // expected-error {{expected expression}} +#pragma omp flush(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp flush(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp flush(argc) +#pragma omp flush(S1) // expected-error {{'S1' does not refer to a value}} +#pragma omp flush(argc) flush(argc) // expected-warning {{extra tokens at the end of '#pragma omp flush' are ignored}} +#pragma omp parallel flush(argc) // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + ; + return T(); +} + +int main(int argc, char **argv) { +#pragma omp flush + ; +#pragma omp flush untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp flush'}} +#pragma omp flush unknown // expected-warning {{extra tokens at the end of '#pragma omp flush' are ignored}} + if (argc) +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + if (argc) { +#pragma omp flush + } + while (argc) +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + while (argc) { +#pragma omp flush + } + do +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp flush + } while (argc); + switch (argc) +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp flush + } + switch (argc) { +#pragma omp flush + case 1: +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + break; + default: { +#pragma omp flush + } break; + } + for (;;) +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} + for (;;) { +#pragma omp flush + } +label: +#pragma omp flush // expected-error {{'#pragma omp flush' cannot be an immediate substatement}} +label1 : { +#pragma omp flush +} + +#pragma omp flush +#pragma omp flush( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp flush() // expected-error {{expected expression}} +#pragma omp flush(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp flush(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp flush(argc) +#pragma omp flush(S1) // expected-error {{'S1' does not refer to a value}} +#pragma omp flush(argc) flush(argc) // expected-warning {{extra tokens at the end of '#pragma omp flush' are ignored}} +#pragma omp parallel flush(argc) // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + ; + return tmain(argc); +} diff --git a/test/OpenMP/for_ast_print.cpp b/test/OpenMP/for_ast_print.cpp new file mode 100644 index 000000000000..8802237b2574 --- /dev/null +++ b/test/OpenMP/for_ast_print.cpp @@ -0,0 +1,64 @@ +// 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 for schedule(dynamic) + // CHECK-NEXT: #pragma omp for schedule(dynamic) + for (int i = 0; i < 2; ++i) + a = 2; +// CHECK-NEXT: for (int i = 0; i < 2; ++i) +// CHECK-NEXT: a = 2; +#pragma omp parallel +#pragma omp for private(argc, b), firstprivate(c, d), lastprivate(d, f) collapse(N) schedule(static, N) ordered nowait + for (int i = 0; i < 10; ++i) + for (int j = 0; j < 10; ++j) + for (int j = 0; j < 10; ++j) + for (int j = 0; j < 10; ++j) + for (int j = 0; j < 10; ++j) + foo(); + // CHECK-NEXT: #pragma omp parallel + // CHECK-NEXT: #pragma omp for private(argc,b) firstprivate(c,d) lastprivate(d,f) collapse(N) schedule(static, N) ordered nowait + // CHECK-NEXT: for (int i = 0; i < 10; ++i) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // 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 for schedule(guided, argc) + // CHECK-NEXT: #pragma omp for schedule(guided, argc) + for (int i = 0; i < 2; ++i) + a = 2; +// CHECK-NEXT: for (int i = 0; i < 2; ++i) +// CHECK-NEXT: a = 2; +#pragma omp parallel +#pragma omp for private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(2) schedule(auto) ordered nowait + for (int i = 0; i < 10; ++i) + for (int j = 0; j < 10; ++j) + foo(); + // CHECK-NEXT: #pragma omp parallel + // CHECK-NEXT: #pragma omp for private(argc,b) firstprivate(argv,c) lastprivate(d,f) collapse(2) schedule(auto) ordered nowait + // CHECK-NEXT: for (int i = 0; i < 10; ++i) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // CHECK-NEXT: foo(); + return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0])); +} + +#endif diff --git a/test/OpenMP/for_collapse_messages.cpp b/test/OpenMP/for_collapse_messages.cpp new file mode 100644 index 000000000000..9e14234e0723 --- /dev/null +++ b/test/OpenMP/for_collapse_messages.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { //expected-note 2 {{declared here}} + #pragma omp for collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for collapse () // expected-error {{expected expression}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 2 {{expression is not an integral constant expression}} + // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}} + #pragma omp for collapse (argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp for collapse (ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for collapse (1)) // expected-warning {{extra tokens at the end of '#pragma omp for' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for collapse ((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'collapse' clause}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp for', but found only 1}} + // expected-error@+3 2 {{directive '#pragma omp for' cannot contain more than one 'collapse' clause}} + // expected-error@+2 2 {{argument to 'collapse' clause must be a positive integer value}} + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp for collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for collapse (S) // expected-error {{'S' does not refer to a value}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp for collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for collapse (1) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for collapse (N) // expected-error {{argument to 'collapse' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp for'}} + return argc; +} + +int main(int argc, char **argv) { + #pragma omp for collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for collapse () // expected-error {{expected expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for collapse (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp for', but found only 1}} + #pragma omp for collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp for' are ignored}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp for', but found only 1}} + #pragma omp for collapse (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{expression is not an integral constant expression}} + // expected-error@+2 2 {{directive '#pragma omp for' cannot contain more than one 'collapse' clause}} + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp for collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for collapse (S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp for collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp for' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp for collapse(collapse(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} + foo(); + #pragma omp for collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp for'}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}} + return tmain<int, char, 1, 0>(argc, argv); +} + diff --git a/test/OpenMP/for_firstprivate_messages.cpp b/test/OpenMP/for_firstprivate_messages.cpp new file mode 100644 index 000000000000..f1d21b8ce5af --- /dev/null +++ b/test/OpenMP/for_firstprivate_messages.cpp @@ -0,0 +1,293 @@ +// 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 for firstprivate // expected-error {{expected '(' after 'firstprivate'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(a, b) // expected-error {{firstprivate variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp for'}} + for (int k = 0; k < argc; ++k) + ++k; +#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 for' directive into a parallel or another task region?}} +#pragma omp for firstprivate(i) // expected-error {{private variable cannot be firstprivate}} + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp for firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for firstprivate(i) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel private(i) // expected-note {{defined as private}} +#pragma omp for firstprivate(i) // expected-error {{firstprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}} +#pragma omp for firstprivate(i) // expected-error {{firstprivate variable must be shared}} + for (i = 0; i < argc; ++i) + 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 for firstprivate // expected-error {{expected '(' after 'firstprivate'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(argc) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(2 * 2) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(ba) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(ca) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(da) // OK + for (i = 0; i < argc; ++i) + foo(); + int xa; +#pragma omp parallel +#pragma omp for firstprivate(xa) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(S2::S2s) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(S2::S2sc) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp for'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(m) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for private(xa), firstprivate(xa) // expected-error {{private variable cannot be firstprivate}} expected-note {{defined as private}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp for' directive may not be firstprivate, predetermined as private}} + foo(); +#pragma omp parallel shared(xa) +#pragma omp for firstprivate(xa) // OK: may be firstprivate + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(n) firstprivate(n) // OK + for (i = 0; i < argc; ++i) + 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 for' directive into a parallel or another task region?}} +#pragma omp for firstprivate(i) // expected-error {{private variable cannot be firstprivate}} + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel private(i) // expected-note {{defined as private}} +#pragma omp for firstprivate(i) // expected-error {{firstprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}} +#pragma omp for firstprivate(i) // expected-error {{firstprivate variable must be shared}} + for (i = 0; i < argc; ++i) + 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/for_lastprivate_messages.cpp b/test/OpenMP/for_lastprivate_messages.cpp new file mode 100644 index 000000000000..a3a1c4b34ed8 --- /dev/null +++ b/test/OpenMP/for_lastprivate_messages.cpp @@ -0,0 +1,266 @@ +// 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; // expected-note {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}} +const S2 b; +const S2 ba[5]; +class S3 { // expected-note 2 {{'S3' declared here}} + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} +class S4 { // expected-note 3 {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + +public: + S5(const S5 &s5) : a(s5.a) {} + 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}} + I g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp for lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp for'}} + for (int k = 0; k < argc; ++k) + ++k; +#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 for' directive into a parallel or another task region?}} +#pragma omp for lastprivate(i) // expected-error {{lastprivate variable must be shared}} + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp for lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel +#pragma omp for lastprivate(i) + for (int k = 0; k < argc; ++k) + ++k; + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}} + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + S3 m; // expected-note 2 {{'m' defined here}} + S6 n(2); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp for lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(argc) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(a, b, c, d, f) // expected-error {{lastprivate variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(2 * 2) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(ba) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(ca) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(da) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); + int xa; +#pragma omp parallel +#pragma omp for lastprivate(xa) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp for'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(i) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel private(xa) // expected-note {{defined as private}} +#pragma omp for lastprivate(xa) // expected-error {{lastprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel reduction(+ : xa) // expected-note {{defined as reduction}} +#pragma omp for lastprivate(xa) // expected-error {{lastprivate variable must be shared}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp for lastprivate(n) firstprivate(n) // OK + for (i = 0; i < argc; ++i) + 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/for_loop_messages.cpp b/test/OpenMP/for_loop_messages.cpp new file mode 100644 index 000000000000..8cc882e13a9f --- /dev/null +++ b/test/OpenMP/for_loop_messages.cpp @@ -0,0 +1,694 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify %s + +class S { + int a; + S() : a(0) {} + +public: + S(int v) : a(v) {} + S(const S &s) : a(s.a) {} +}; + +static int sii; +#pragma omp threadprivate(sii) // expected-note {{defined as threadprivate or thread local}} + +int test_iteration_spaces() { + const int N = 100; + float a[N], b[N], c[N]; + int ii, jj, kk; + float fii; + double dii; +#pragma omp parallel +#pragma omp for + for (int i = 0; i < 10; i += 1) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +#pragma omp for + for (char i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +#pragma omp for + for (char i = 0; i < 10; i += '\1') { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +#pragma omp for + for (long long i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'double'}} +#pragma omp for + for (long long i = 0; i < 10; i += 1.5) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +#pragma omp for + for (long long i = 0; i < 'z'; i += 1u) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp for + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp for + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp for + for (int &ref = ii; ref < 10; ref++) { + } +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for + for (int i; i < 10; i++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for + for (int i = 0, j = 0; i < 10; ++i) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for + for (; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-warning@+3 {{expression result unused}} +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for + for (ii + 1; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for + for (c[ii] = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// Ok to skip parenthesises. +#pragma omp for + for (((ii)) = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp for + for (int i = 0; i; i++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+3 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'i'}} +#pragma omp for + for (int i = 0; jj < kk; ii++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp for + for (int i = 0; !!i; i++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp for + for (int i = 0; i != 1; i++) + c[i] = a[i]; + +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp for + for (int i = 0;; i++) + c[i] = a[i]; + +#pragma omp parallel +// Ok. +#pragma omp for + for (int i = 11; i > 10; i--) + c[i] = a[i]; + +#pragma omp parallel +// Ok. +#pragma omp for + for (int i = 0; i < 10; ++i) + c[i] = a[i]; + +#pragma omp parallel +// Ok. +#pragma omp for + for (ii = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for + for (ii = 0; ii < 10; ++jj) + c[ii] = a[jj]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for + for (ii = 0; ii < 10; ++++ii) + c[ii] = a[ii]; + +#pragma omp parallel +// Ok but undefined behavior (in general, cannot check that incr +// is really loop-invariant). +#pragma omp for + for (ii = 0; ii < 10; ii = ii + ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'float'}} +#pragma omp for + for (ii = 0; ii < 10; ii = ii + 1.0f) + c[ii] = a[ii]; + +#pragma omp parallel +// Ok - step was converted to integer type. +#pragma omp for + for (ii = 0; ii < 10; ii = ii + (int)1.1f) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for + for (ii = 0; ii < 10; jj = ii + 2) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-warning@+3 {{relational comparison result unused}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for + for (ii = 0; ii<10; jj> kk + 2) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for + for (ii = 0; ii < 10;) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-warning@+3 {{expression result unused}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for + for (ii = 0; ii < 10; !ii) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for + for (ii = 0; ii < 10; ii ? ++ii : ++jj) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp for + for (ii = 0; ii < 10; ii = ii < 10) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for + for (ii = 0; ii < 10; ii = ii + 0) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for + for (ii = 0; ii < 10; ii = ii + (int)(0.8 - 0.45)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for + for (ii = 0; (ii) < 10; ii -= 25) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for + for (ii = 0; (ii < 10); ii -= 0) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} +#pragma omp for + for (ii = 0; ii > 10; (ii += 0)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for + for (ii = 0; ii < 10; (ii) = (1 - 1) + (ii)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} +#pragma omp for + for ((ii = 0); ii > 10; (ii -= 0)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp for + for (ii = 0; (ii < 10); (ii -= 0)) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-note@+2 {{defined as firstprivate}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for' directive may not be firstprivate, predetermined as private}} +#pragma omp for firstprivate(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel +// expected-error@+3 {{unexpected OpenMP clause 'linear' in directive '#pragma omp for'}} +// expected-note@+2 {{defined as linear}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for' directive may not be linear, predetermined as private}} +#pragma omp for linear(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel +#pragma omp for private(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel +#pragma omp for lastprivate(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel + { +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp for' directive may not be threadprivate or thread local, predetermined as private}} +#pragma omp for + for (sii = 0; sii < 10; sii += 1) + c[sii] = a[sii]; + } + +#pragma omp parallel +// expected-error@+2 {{statement after '#pragma omp for' must be a for loop}} +#pragma omp for + for (auto &item : a) { + item = item + 1; + } + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'i' to increase on each iteration of OpenMP for loop}} +#pragma omp for + for (unsigned i = 9; i < 10; i--) { + c[i] = a[i] + b[i]; + } + + int(*lb)[4] = nullptr; +#pragma omp parallel +#pragma omp for + for (int(*p)[4] = lb; p < lb + 8; ++p) { + } + +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for + for (int a{0}; a < 10; ++a) { + } + + return 0; +} + +// Iterators allowed in openmp for-loops. +namespace std { +struct random_access_iterator_tag {}; +template <class Iter> +struct iterator_traits { + typedef typename Iter::difference_type difference_type; + typedef typename Iter::iterator_category iterator_category; +}; +template <class Iter> +typename iterator_traits<Iter>::difference_type +distance(Iter first, Iter last) { return first - last; } +} +class Iter0 { +public: + Iter0() {} + Iter0(const Iter0 &) {} + Iter0 operator++() { return *this; } + Iter0 operator--() { return *this; } + bool operator<(Iter0 a) { return true; } +}; +int operator-(Iter0 a, Iter0 b) { return 0; } +class Iter1 { +public: + Iter1(float f = 0.0f, double d = 0.0) {} + Iter1(const Iter1 &) {} + Iter1 operator++() { return *this; } + Iter1 operator--() { return *this; } + bool operator<(Iter1 a) { return true; } + bool operator>=(Iter1 a) { return false; } +}; +class GoodIter { +public: + GoodIter() {} + GoodIter(const GoodIter &) {} + GoodIter(int fst, int snd) {} + GoodIter &operator=(const GoodIter &that) { return *this; } + GoodIter &operator=(const Iter0 &that) { return *this; } + GoodIter &operator+=(int x) { return *this; } + explicit GoodIter(void *) {} + GoodIter operator++() { return *this; } + GoodIter operator--() { return *this; } + bool operator!() { return true; } + bool operator<(GoodIter a) { return true; } + bool operator<=(GoodIter a) { return true; } + bool operator>=(GoodIter a) { return false; } + typedef int difference_type; + typedef std::random_access_iterator_tag iterator_category; +}; +int operator-(GoodIter a, GoodIter b) { return 0; } +GoodIter operator-(GoodIter a) { return a; } +GoodIter operator-(GoodIter a, int v) { return GoodIter(); } +GoodIter operator+(GoodIter a, int v) { return GoodIter(); } +GoodIter operator-(int v, GoodIter a) { return GoodIter(); } +GoodIter operator+(int v, GoodIter a) { return GoodIter(); } + +int test_with_random_access_iterator() { + GoodIter begin, end; + Iter0 begin0, end0; +#pragma omp parallel +#pragma omp for + for (GoodIter I = begin; I < end; ++I) + ++I; +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp for + for (GoodIter &I = begin; I < end; ++I) + ++I; +#pragma omp parallel +#pragma omp for + for (GoodIter I = begin; I >= end; --I) + ++I; +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for + for (GoodIter I(begin); I < end; ++I) + ++I; +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for + for (GoodIter I(nullptr); I < end; ++I) + ++I; +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for + for (GoodIter I(0); I < end; ++I) + ++I; +#pragma omp parallel +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for + for (GoodIter I(1, 2); I < end; ++I) + ++I; +#pragma omp parallel +#pragma omp for + for (begin = GoodIter(0); begin < end; ++begin) + ++begin; +#pragma omp parallel +#pragma omp for + for (begin = begin0; begin < end; ++begin) + ++begin; +#pragma omp parallel +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp for + for (++begin; begin < end; ++begin) + ++begin; +#pragma omp parallel +#pragma omp for + for (begin = end; begin < end; ++begin) + ++begin; +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp for + for (GoodIter I = begin; I - I; ++I) + ++I; +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp for + for (GoodIter I = begin; begin < end; ++I) + ++I; +#pragma omp parallel +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp for + for (GoodIter I = begin; !I; ++I) + ++I; +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for + for (GoodIter I = begin; I >= end; I = I + 1) + ++I; +#pragma omp parallel +#pragma omp for + for (GoodIter I = begin; I >= end; I = I - 1) + ++I; +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} +#pragma omp for + for (GoodIter I = begin; I >= end; I = -I) + ++I; +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for + for (GoodIter I = begin; I >= end; I = 2 + I) + ++I; +#pragma omp parallel +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} +#pragma omp for + for (GoodIter I = begin; I >= end; I = 2 - I) + ++I; +#pragma omp parallel +#pragma omp for + for (Iter0 I = begin0; I < end0; ++I) + ++I; +#pragma omp parallel +// Initializer is constructor without params. +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for + for (Iter0 I; I < end0; ++I) + ++I; + Iter1 begin1, end1; +#pragma omp parallel +#pragma omp for + for (Iter1 I = begin1; I < end1; ++I) + ++I; +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for + for (Iter1 I = begin1; I >= end1; ++I) + ++I; +#pragma omp parallel +// Initializer is constructor with all default params. +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp for + for (Iter1 I; I < end1; ++I) { + } + return 0; +} + +template <typename IT, int ST> +class TC { +public: + int dotest_lt(IT begin, IT end) { +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} +#pragma omp for + for (IT I = begin; I < end; I = I + ST) { + ++I; + } +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} +#pragma omp for + for (IT I = begin; I <= end; I += ST) { + ++I; + } +#pragma omp parallel +#pragma omp for + for (IT I = begin; I < end; ++I) { + ++I; + } + } + + static IT step() { + return IT(ST); + } +}; +template <typename IT, int ST = 0> +int dotest_gt(IT begin, IT end) { +#pragma omp parallel +// expected-note@+3 2 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for + for (IT I = begin; I >= end; I = I + ST) { + ++I; + } +#pragma omp parallel +// expected-note@+3 2 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for + for (IT I = begin; I >= end; I += ST) { + ++I; + } + +#pragma omp parallel +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp for + for (IT I = begin; I >= end; ++I) { + ++I; + } + +#pragma omp parallel +#pragma omp for + for (IT I = begin; I < end; I += TC<int, ST>::step()) { + ++I; + } +} + +void test_with_template() { + GoodIter begin, end; + TC<GoodIter, 100> t1; + TC<GoodIter, -100> t2; + t1.dotest_lt(begin, end); + t2.dotest_lt(begin, end); // expected-note {{in instantiation of member function 'TC<GoodIter, -100>::dotest_lt' requested here}} + dotest_gt(begin, end); // expected-note {{in instantiation of function template specialization 'dotest_gt<GoodIter, 0>' requested here}} + dotest_gt<unsigned, -10>(0, 100); // expected-note {{in instantiation of function template specialization 'dotest_gt<unsigned int, -10>' requested here}} +} + +void test_loop_break() { + const int N = 100; + float a[N], b[N], c[N]; +#pragma omp parallel +#pragma omp for + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + break; // OK in nested loop + } + switch (i) { + case 1: + b[i]++; + break; + default: + break; + } + if (c[i] > 10) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + + if (c[i] > 11) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + } + +#pragma omp parallel +#pragma omp for + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 10; j++) { + c[i] = a[i] + b[i]; + if (c[i] > 10) { + if (c[i] < 20) { + break; // OK + } + } + } + } +} + +void test_loop_eh() { + const int N = 100; + float a[N], b[N], c[N]; +#pragma omp parallel +#pragma omp for + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + try { + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + throw a[i]; + } + throw a[i]; + } catch (float f) { + if (f > 0.1) + throw a[i]; + return; // expected-error {{cannot return from OpenMP region}} + } + switch (i) { + case 1: + b[i]++; + break; + default: + break; + } + for (int j = 0; j < 10; j++) { + if (c[i] > 10) + throw c[i]; + } + } + if (c[9] > 10) + throw c[9]; // OK + +#pragma omp parallel +#pragma omp for + for (int i = 0; i < 10; ++i) { + struct S { + void g() { throw 0; } + }; + } +} + +void test_loop_firstprivate_lastprivate() { + S s(4); +#pragma omp parallel +#pragma omp for lastprivate(s) firstprivate(s) + for (int i = 0; i < 16; ++i) + ; +} + +void test_ordered() { +#pragma omp parallel +#pragma omp for ordered ordered // expected-error {{directive '#pragma omp for' cannot contain more than one 'ordered' clause}} + for (int i = 0; i < 16; ++i) + ; +} + +void test_nowait() { +#pragma omp parallel +#pragma omp for nowait nowait // expected-error {{directive '#pragma omp for' cannot contain more than one 'nowait' clause}} + for (int i = 0; i < 16; ++i) + ; +} diff --git a/test/OpenMP/for_misc_messages.c b/test/OpenMP/for_misc_messages.c new file mode 100644 index 000000000000..854898c04432 --- /dev/null +++ b/test/OpenMP/for_misc_messages.c @@ -0,0 +1,363 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp for'}} +#pragma omp for + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp for'}} +#pragma omp for foo + +void test_no_clause() { + int i; +#pragma omp for + for (i = 0; i < 16; ++i) + ; + +// expected-error@+2 {{statement after '#pragma omp for' must be a for loop}} +#pragma omp for + ++i; +} + +void test_branch_protected_scope() { + int i = 0; +L1: + ++i; + + int x[24]; + +#pragma omp parallel +#pragma omp for + for (i = 0; i < 16; ++i) { + 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 for' are ignored}} +#pragma omp for foo bar + for (i = 0; i < 16; ++i) + ; +} + +void test_non_identifiers() { + int i, x; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp for' are ignored}} +#pragma omp for; + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+2 {{unexpected OpenMP clause 'linear' in directive '#pragma omp for'}} +// expected-warning@+1 {{extra tokens at the end of '#pragma omp for' are ignored}} +#pragma omp for linear(x); + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp for' are ignored}} +#pragma omp for private(x); + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp for' are ignored}} +#pragma omp for, private(x); + for (i = 0; i < 16; ++i) + ; +} + +extern int foo(); + +void test_collapse() { + int i; +#pragma omp parallel +// expected-error@+1 {{expected '('}} +#pragma omp for collapse + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for collapse( + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for collapse() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for collapse(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp for collapse(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-warning@+2 {{extra tokens at the end of '#pragma omp for' are ignored}} +// expected-error@+1 {{expected '('}} +#pragma omp for collapse 4) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for collapse(4 + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for collapse(4, + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for collapse(4, ) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for', but found only 1}} +#pragma omp parallel +// expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for collapse(4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for collapse(4 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for', but found only 1}} +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for collapse(4, , 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for', but found only 1}} +#pragma omp parallel +#pragma omp for collapse(4) + for (int i1 = 0; i1 < 16; ++i1) + for (int i2 = 0; i2 < 16; ++i2) + for (int i3 = 0; i3 < 16; ++i3) + for (int i4 = 0; i4 < 16; ++i4) + foo(); +#pragma omp parallel +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp for collapse(4, 8) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp for', but found only 1}} +#pragma omp parallel +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp for collapse(2.5) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp for collapse(foo()) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp for collapse(-5) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp for collapse(0) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp for collapse(5 - 5) + for (i = 0; i < 16; ++i) + ; +} + +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 for private( + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp for private(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp for private(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for private() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for private(int) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp for private(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel +#pragma omp for private(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for private(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for private(x, y, z) + for (i = 0; i < 16; ++i) { + x = y * i + z; + } +} + +void test_lastprivate() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp for lastprivate( + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp for lastprivate(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp for lastprivate(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for lastprivate() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for lastprivate(int) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp for lastprivate(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel +#pragma omp for lastprivate(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for lastprivate(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for lastprivate(x, y, z) + for (i = 0; i < 16; ++i) + ; +} + +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 for firstprivate( + for (i = 0; i < 16; ++i) + ; + +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp for firstprivate(, + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp for firstprivate(, ) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for firstprivate() + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp for firstprivate(int) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp for firstprivate(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel +#pragma omp for lastprivate(x) firstprivate(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for lastprivate(x, y) firstprivate(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel +#pragma omp for lastprivate(x, y, z) firstprivate(x, y, z) + for (i = 0; i < 16; ++i) + ; +} + +void test_loop_messages() { + float a[100], b[100], c[100]; +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp for + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +#pragma omp parallel +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp for + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +} + diff --git a/test/OpenMP/for_private_messages.cpp b/test/OpenMP/for_private_messages.cpp new file mode 100644 index 000000000000..f7a497930d01 --- /dev/null +++ b/test/OpenMP/for_private_messages.cpp @@ -0,0 +1,173 @@ +// 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 for private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(e, g) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp for'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp for private(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp for private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(i) + for (int k = 0; k < argc; ++k) + ++k; + 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 for private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp for'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int i; +#pragma omp for private(i) + for (int k = 0; k < argc; ++k) + ++k; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp for private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp for private(i) + for (int k = 0; k < argc; ++k) + ++k; + + return 0; +} + diff --git a/test/OpenMP/for_reduction_messages.cpp b/test/OpenMP/for_reduction_messages.cpp new file mode 100644 index 000000000000..62fee52e4903 --- /dev/null +++ b/test/OpenMP/for_reduction_messages.cpp @@ -0,0 +1,350 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + S2 &operator+=(const S2 &arg) { return (*this); } + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note 2 {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}} +S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; // expected-note 2 {{'ba' defined here}} +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} + S3 operator+=(const S3 &arg1) { return arg1; } +}; +int operator+=(const S3 &arg1, const S3 &arg2) { return 5; } +S3 c; // expected-note 2 {{'c' defined here}} +const S3 ca[5]; // expected-note 2 {{'ca' defined here}} +extern const int f; // expected-note 4 {{'f' declared here}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + S4 &operator+=(const S4 &arg) { return (*this); } + +public: + S4(int v) : a(v) {} +}; +S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; } +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + S5 &operator+=(const S5 &arg); + +public: + S5(int v) : a(v) {} +}; +class S6 { + int a; + +public: + S6() : a(6) {} + operator int() { return 6; } +} o; // expected-note 2 {{'o' defined here}} + +S3 h, k; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class T> // expected-note {{declared here}} +T tmain(T argc) { // expected-note 2 {{'argc' defined here}} + const T d = T(); // expected-note 4 {{'d' defined here}} + const T da[5] = {T()}; // expected-note 2 {{'da' defined here}} + T qa[5] = {T()}; + T i; + T &j = i; // expected-note 4 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}} + T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}} + T fl; // expected-note {{'fl' defined here}} +#pragma omp parallel +#pragma omp for reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp for' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(^ : T) // expected-error {{'T' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(max : qa[1]) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp for reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp for reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) // expected-note 2 {{defined as private}} +#pragma omp for reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) // expected-note 2 {{defined as reduction}} +#pragma omp for reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}} + for (int i = 0; i < 10; ++i) + foo(); + + return T(); +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note 2 {{'d' defined here}} + const int da[5] = {0}; // expected-note {{'da' defined here}} + int qa[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note 2 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const int &r = da[i]; // expected-note {{'r' defined here}} + int &q = qa[i]; // expected-note {{'q' defined here}} + float fl; // expected-note {{'fl' defined here}} +#pragma omp parallel +#pragma omp for reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp for' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(~ : argc) // expected-error {{expected unqualified-id}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(^ : S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(max : argv[1]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp for reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel +#pragma omp for reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp for reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) // expected-note {{defined as private}} +#pragma omp for reduction(+ : fl) // expected-error {{reduction variable must be shared}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) // expected-note {{defined as reduction}} +#pragma omp for reduction(+ : fl) // expected-error {{reduction variable must be shared}} + for (int i = 0; i < 10; ++i) + foo(); + + return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}} +} diff --git a/test/OpenMP/for_schedule_messages.cpp b/test/OpenMP/for_schedule_messages.cpp new file mode 100644 index 000000000000..be4ff4f70349 --- /dev/null +++ b/test/OpenMP/for_schedule_messages.cpp @@ -0,0 +1,91 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { + #pragma omp for schedule // expected-error {{expected '(' after 'schedule'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule ( // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule () // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule (auto // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule (auto_dynamic // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule (auto, // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule (runtime, 3) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp for schedule (guided argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp for schedule (static, ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule (dynamic, 1)) // expected-warning {{extra tokens at the end of '#pragma omp for' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule (guided, (ST > 0) ? 1 + ST : 2) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+2 2 {{directive '#pragma omp for' cannot contain more than one 'schedule' clause}} + // expected-error@+1 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp for schedule (static, foobool(argc)), schedule (dynamic, true), schedule (guided, -5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule (static, S) // expected-error {{'S' does not refer to a value}} expected-warning {{extra tokens at the end of '#pragma omp for' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp for schedule (guided, argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule (dynamic, 1) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp for schedule (static, N) // expected-error {{argument to 'schedule' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + return argc; +} + +int main(int argc, char **argv) { + #pragma omp for schedule // expected-error {{expected '(' after 'schedule'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule ( // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule () // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule (auto // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule (auto_dynamic // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule (auto, // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule (runtime, 3) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule (guided, 4 // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule (static, 2+2)) // expected-warning {{extra tokens at the end of '#pragma omp for' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule (dynamic, foobool(1) > 0 ? 1 : 2) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+2 2 {{directive '#pragma omp for' cannot contain more than one 'schedule' clause}} + // expected-error@+1 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp for schedule (guided, foobool(argc)), schedule (static, true), schedule (dynamic, -5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp for schedule (guided, S1) // expected-error {{'S1' does not refer to a value}} expected-warning {{extra tokens at the end of '#pragma omp for' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp for schedule (static, argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp for' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp for schedule(dynamic, schedule(tmain<int, char, -1, -2>(argc, argv) // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}} + return tmain<int, char, 1, 0>(argc, argv); +} + diff --git a/test/OpenMP/linking.c b/test/OpenMP/linking.c index 31fd57de9267..979ba1f4e41e 100644 --- a/test/OpenMP/linking.c +++ b/test/OpenMP/linking.c @@ -1,5 +1,5 @@ // Test the that the driver produces reasonable linker invocations with -// -fopenmp. +// -fopenmp or -fopenmp=libiomp5|libgomp. // // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ // RUN: -fopenmp -target i386-unknown-linux \ @@ -14,3 +14,58 @@ // CHECK-LD-64: "{{.*}}ld{{(.exe)?}}" // CHECK-LD-64: "-lgomp" "-lrt" "-lgcc" // CHECK-LD-64: "-lpthread" "-lc" +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: -fopenmp=libgomp -target i386-unknown-linux \ +// RUN: | FileCheck --check-prefix=CHECK-GOMP-LD-32 %s +// CHECK-GOMP-LD-32: "{{.*}}ld{{(.exe)?}}" +// CHECK-GOMP-LD-32: "-lgomp" "-lrt" "-lgcc" +// CHECK-GOMP-LD-32: "-lpthread" "-lc" +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: -fopenmp=libgomp -target x86_64-unknown-linux \ +// RUN: | FileCheck --check-prefix=CHECK-GOMP-LD-64 %s +// CHECK-GOMP-LD-64: "{{.*}}ld{{(.exe)?}}" +// CHECK-GOMP-LD-64: "-lgomp" "-lrt" "-lgcc" +// CHECK-GOMP-LD-64: "-lpthread" "-lc" +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: -fopenmp=libiomp5 -target i386-unknown-linux \ +// RUN: | FileCheck --check-prefix=CHECK-IOMP5-LD-32 %s +// CHECK-IOMP5-LD-32: "{{.*}}ld{{(.exe)?}}" +// CHECK-IOMP5-LD-32: "-liomp5" "-lgcc" +// CHECK-IOMP5-LD-32: "-lpthread" "-lc" +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: -fopenmp=libiomp5 -target x86_64-unknown-linux \ +// RUN: | FileCheck --check-prefix=CHECK-IOMP5-LD-64 %s +// CHECK-IOMP5-LD-64: "{{.*}}ld{{(.exe)?}}" +// CHECK-IOMP5-LD-64: "-liomp5" "-lgcc" +// CHECK-IOMP5-LD-64: "-lpthread" "-lc" +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: -fopenmp=lib -target i386-unknown-linux \ +// RUN: | FileCheck --check-prefix=CHECK-LIB-LD-32 %s +// CHECK-LIB-LD-32: error: unsupported argument 'lib' to option 'fopenmp=' +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: -fopenmp=lib -target x86_64-unknown-linux \ +// RUN: | FileCheck --check-prefix=CHECK-LIB-LD-64 %s +// CHECK-LIB-LD-64: error: unsupported argument 'lib' to option 'fopenmp=' +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: -fopenmp -fopenmp=libiomp5 -target i386-unknown-linux \ +// RUN: | FileCheck --check-prefix=CHECK-LD-WARN-32 %s +// CHECK-LD-WARN-32: warning: argument unused during compilation: '-fopenmp=libiomp5' +// CHECK-LD-WARN-32: "{{.*}}ld{{(.exe)?}}" +// CHECK-LD-WARN-32: "-lgomp" "-lrt" "-lgcc" +// CHECK-LD-WARN-32: "-lpthread" "-lc" +// +// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +// RUN: -fopenmp -fopenmp=libiomp5 -target x86_64-unknown-linux \ +// RUN: | FileCheck --check-prefix=CHECK-LD-WARN-64 %s +// CHECK-LD-WARN-64: warning: argument unused during compilation: '-fopenmp=libiomp5' +// CHECK-LD-WARN-64: "{{.*}}ld{{(.exe)?}}" +// CHECK-LD-WARN-64: "-lgomp" "-lrt" "-lgcc" +// CHECK-LD-WARN-64: "-lpthread" "-lc" +// diff --git a/test/OpenMP/master_ast_print.cpp b/test/OpenMP/master_ast_print.cpp new file mode 100644 index 000000000000..7ce4c10020c0 --- /dev/null +++ b/test/OpenMP/master_ast_print.cpp @@ -0,0 +1,32 @@ +// 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() {} + +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 master +{ + a=2; +} +} +// CHECK-NEXT: #pragma omp parallel +// CHECK-NEXT: { +// CHECK-NEXT: #pragma omp master +// CHECK-NEXT: { +// CHECK-NEXT: a = 2; +// CHECK-NEXT: } +// CHECK-NEXT: } + return (0); +} + +#endif diff --git a/test/OpenMP/master_messages.cpp b/test/OpenMP/master_messages.cpp new file mode 100644 index 000000000000..fbe35ac68e4a --- /dev/null +++ b/test/OpenMP/master_messages.cpp @@ -0,0 +1,64 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +int foo(); + +int main() { + #pragma omp master + ; + #pragma omp master nowait // expected-error {{unexpected OpenMP clause 'nowait' in directive '#pragma omp master'}} + #pragma omp master unknown // expected-warning {{extra tokens at the end of '#pragma omp master' are ignored}} + foo(); + { + #pragma omp master + } // expected-error {{expected statement}} + #pragma omp for + for (int i = 0; i < 10; ++i) { + foo(); + #pragma omp master // expected-error {{region cannot be closely nested inside 'for' region}} + foo(); + } + #pragma omp sections + { + foo(); + #pragma omp master // expected-error {{region cannot be closely nested inside 'sections' region}} + foo(); + } + #pragma omp single + for (int i = 0; i < 10; ++i) { + foo(); + #pragma omp master // expected-error {{region cannot be closely nested inside 'single' region}} + foo(); + } + #pragma omp master + for (int i = 0; i < 10; ++i) { + foo(); + #pragma omp master + foo(); + } + #pragma omp for ordered + for (int i = 0; i < 10; ++i) + #pragma omp master // expected-error {{region cannot be closely nested inside 'for' region}} + { + foo(); + } + + return 0; +} + +int foo() { + L1: + foo(); + #pragma omp master + { + foo(); + goto L1; // expected-error {{use of undeclared label 'L1'}} + } + goto L2; // expected-error {{use of undeclared label 'L2'}} + #pragma omp master + { + L2: + foo(); + } + + return 0; +} diff --git a/test/OpenMP/nesting_of_regions.cpp b/test/OpenMP/nesting_of_regions.cpp new file mode 100644 index 000000000000..d8dcec5edf2e --- /dev/null +++ b/test/OpenMP/nesting_of_regions.cpp @@ -0,0 +1,2278 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s + +void bar(); + +template <class T> +void foo() { +// PARALLEL DIRECTIVE +#pragma omp parallel +#pragma omp for + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel +#pragma omp sections + { + bar(); + } +#pragma omp parallel +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel region}} + { + bar(); + } +#pragma omp parallel +#pragma omp single + bar(); + +#pragma omp parallel +#pragma omp master + { + bar(); + } +#pragma omp parallel +#pragma omp critical + { + bar(); + } +#pragma omp parallel +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel +#pragma omp parallel sections + { + bar(); + } +#pragma omp parallel +#pragma omp task + { + bar(); + } +#pragma omp parallel + { +#pragma omp taskyield + bar(); + } +#pragma omp parallel + { +#pragma omp barrier + bar(); + } +#pragma omp parallel + { +#pragma omp taskwait + bar(); + } +#pragma omp parallel + { +#pragma omp flush + bar(); + } + +// SIMD DIRECTIVE +#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}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + 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 simd + for (int i = 0; i < 10; ++i) { +#pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } + +// FOR DIRECTIVE +#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?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a for region}} + { + 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 for + for (int i = 0; i < 10; ++i) { +#pragma omp master // expected-error {{region cannot be closely nested inside 'for' region}} + { + bar(); + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp critical + { + bar(); + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp task + { + bar(); + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'for' region}} + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp flush + bar(); + } + +// SECTIONS DIRECTIVE +#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?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { + bar(); + } + } +#pragma omp sections + { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp sections + { +#pragma omp parallel + { +#pragma omp master // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp master // OK + { + bar(); + } + } +#pragma omp master // expected-error {{region cannot be closely nested inside 'sections' region}} + bar(); + } +#pragma omp sections + { +#pragma omp parallel + { +#pragma omp critical(A) // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp critical // OK + { + bar(); + } + } +#pragma omp critical(A) // expected-error {{statement in 'omp sections' directive must be enclosed into a section region}} + bar(); + } +#pragma omp sections + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp sections + { +#pragma omp task + { + bar(); + } + } +#pragma omp sections + { +#pragma omp taskyield + } +#pragma omp sections + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'sections' region}} + } +#pragma omp sections + { +#pragma omp taskwait + } +#pragma omp sections + { +#pragma omp flush + } + +// SECTION DIRECTIVE +#pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}} + { + bar(); + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a section region}} + { + 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 master // expected-error {{region cannot be closely nested inside 'section' region}} + bar(); +#pragma omp critical + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp parallel sections + { + bar(); + } + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp task + { + bar(); + } + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp taskyield + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'section' region}} + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp taskwait + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp flush + bar(); + } + } + +// SINGLE DIRECTIVE +#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 master // expected-error {{region cannot be closely nested inside 'single' region}} + { + bar(); + } + } +#pragma omp single + { +#pragma omp critical + { + 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(); + } + } +#pragma omp single + { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp single + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp single + { +#pragma omp task + { + bar(); + } + } +#pragma omp single + { +#pragma omp taskyield + bar(); + } +#pragma omp single + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'single' region}} + bar(); + } +#pragma omp single + { +#pragma omp taskwait + bar(); + } +#pragma omp single + { +#pragma omp flush + bar(); + } + +// MASTER DIRECTIVE +#pragma omp master + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { +#pragma omp single // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp master + { +#pragma omp master // OK, though second 'master' is redundant + { + bar(); + } + } +#pragma omp master + { +#pragma omp critical + { + bar(); + } + } +#pragma omp master + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp master + { +#pragma omp parallel + { +#pragma omp master // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp master + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp master + { +#pragma omp task + { + bar(); + } + } +#pragma omp master + { +#pragma omp taskyield + bar(); + } +#pragma omp master + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'master' region}} + bar(); + } +#pragma omp master + { +#pragma omp taskwait + bar(); + } +#pragma omp master + { +#pragma omp flush + bar(); + } + +// CRITICAL DIRECTIVE +#pragma omp critical + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { +#pragma omp single // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp critical + { +#pragma omp master // OK, though second 'master' is redundant + { + bar(); + } + } +#pragma omp critical + { +#pragma omp critical + { + bar(); + } + } +#pragma omp critical + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp critical + { +#pragma omp parallel + { +#pragma omp master // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp critical + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp critical + { +#pragma omp task + { + bar(); + } + } +#pragma omp critical + { +#pragma omp taskyield + bar(); + } +#pragma omp critical + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'critical' region}} + bar(); + } +#pragma omp critical + { +#pragma omp taskwait + bar(); + } +#pragma omp critical(Tuzik) + { +#pragma omp critical(grelka) + bar(); + } +#pragma omp critical(Belka)// expected-note {{previous 'critical' region starts here}} + { +#pragma omp critical(Belka) // expected-error {{cannot nest 'critical' regions having the same name 'Belka'}} + { +#pragma omp critical(Tuzik) + { +#pragma omp parallel +#pragma omp critical(grelka) + { + bar(); + } + } + } + } + +// PARALLEL FOR DIRECTIVE +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp for // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel for region}} + { + bar(); + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } + } + +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp master // expected-error {{region cannot be closely nested inside 'parallel for' region}} + { + bar(); + } + } + +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp critical + { + bar(); + } + } + +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp task + { + bar(); + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield + bar(); + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel for' region}} + bar(); + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait + bar(); + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp flush + bar(); + } + +// PARALLEL SECTIONS DIRECTIVE +#pragma omp parallel sections + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp parallel sections + { +#pragma omp section + { + bar(); + } + } +#pragma omp parallel 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 parallel sections + { +#pragma omp section + { +#pragma omp master // expected-error {{region cannot be closely nested inside 'section' region}} + bar(); + } + } +#pragma omp parallel sections + { +#pragma omp section + { +#pragma omp critical + bar(); + } + } +#pragma omp parallel sections + { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp parallel sections + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp parallel sections + { +#pragma omp task + { + bar(); + } + } +#pragma omp parallel sections + { +#pragma omp taskyield + } +#pragma omp parallel sections + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel sections' region}} + } +#pragma omp parallel sections + { +#pragma omp taskwait + } +#pragma omp parallel sections + { +#pragma omp flush + } + +// TASK DIRECTIVE +#pragma omp task +#pragma omp for // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp task +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp task +#pragma omp sections // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } +#pragma omp task +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a task region}} + { + bar(); + } +#pragma omp task +#pragma omp single // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + bar(); +#pragma omp task +#pragma omp master // expected-error {{region cannot be closely nested inside 'task' region}} + bar(); +#pragma omp task +#pragma omp critical + bar(); + +#pragma omp task +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; +#pragma omp task +#pragma omp parallel sections + { + bar(); + } +#pragma omp task +#pragma omp task + { + bar(); + } +#pragma omp task + { +#pragma omp taskyield + bar(); + } +#pragma omp task + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'task' region}} + bar(); + } +#pragma omp task + { +#pragma omp taskwait + bar(); + } +#pragma omp task + { +#pragma omp flush + bar(); + } +} + +void foo() { +// PARALLEL DIRECTIVE +#pragma omp parallel +#pragma omp for + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel +#pragma omp sections + { + bar(); + } +#pragma omp parallel +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel region}} + { + bar(); + } +#pragma omp parallel +#pragma omp sections + { + bar(); + } +#pragma omp parallel +#pragma omp single + bar(); +#pragma omp parallel +#pragma omp master + bar(); +#pragma omp parallel +#pragma omp critical + bar(); +#pragma omp parallel +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; +#pragma omp parallel +#pragma omp parallel sections + { + bar(); + } +#pragma omp parallel +#pragma omp task + { + bar(); + } +#pragma omp parallel + { +#pragma omp taskyield + bar(); + } +#pragma omp parallel + { +#pragma omp barrier + bar(); + } +#pragma omp parallel + { +#pragma omp taskwait + bar(); + } +#pragma omp parallel + { +#pragma omp flush + bar(); + } + +// SIMD DIRECTIVE +#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}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + 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 master // expected-error {{OpenMP constructs may not be nested inside a simd region}} + 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 critical // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}} + bar(); + } + +// FOR DIRECTIVE +#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?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a for region}} + { + 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 master // expected-error {{region cannot be closely nested inside 'for' region}} + bar(); +#pragma omp critical + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp task + { + bar(); + } + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'for' region}} + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait + bar(); + } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp flush + bar(); + } + +// SECTIONS DIRECTIVE +#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?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { + bar(); + } + } +#pragma omp sections + { +#pragma omp critical + bar(); +#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 master // expected-error {{region cannot be closely nested inside 'sections' region}} + bar(); + } +#pragma omp sections + { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp sections + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp sections + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp sections + { +#pragma omp task + { + bar(); + } + } +#pragma omp sections + { +#pragma omp taskyield + } +#pragma omp sections + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'sections' region}} + bar(); + } +#pragma omp sections + { +#pragma omp taskwait + } +#pragma omp sections + { +#pragma omp flush + } + +// SECTION DIRECTIVE +#pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}} + { + bar(); + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a section region}} + { + 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 master // expected-error {{region cannot be closely nested inside 'section' region}} + bar(); +#pragma omp critical + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp parallel sections + { + bar(); + } + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp task + { + bar(); + } + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp taskyield + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'section' region}} + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp taskwait + bar(); + } + } +#pragma omp sections + { +#pragma omp section + { +#pragma omp flush + bar(); + } + } + +// SINGLE DIRECTIVE +#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 master // expected-error {{region cannot be closely nested inside 'single' region}} + bar(); +#pragma omp critical + 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(); + } + } +#pragma omp single + { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp single + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp single + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp single + { +#pragma omp task + { + bar(); + } + } +#pragma omp single + { +#pragma omp taskyield + bar(); + } +#pragma omp single + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'single' region}} + bar(); + } +#pragma omp single + { +#pragma omp taskwait + bar(); + } +#pragma omp single + { +#pragma omp flush + bar(); + } + +// MASTER DIRECTIVE +#pragma omp master + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { +#pragma omp single // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp master + { +#pragma omp master // OK, though second 'master' is redundant + { + bar(); + } + } +#pragma omp master + { +#pragma omp critical + { + bar(); + } + } +#pragma omp master + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp master + { +#pragma omp parallel + { +#pragma omp master // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp master + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp master + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp master + { +#pragma omp task + { + bar(); + } + } +#pragma omp master + { +#pragma omp taskyield + bar(); + } +#pragma omp master + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'master' region}} + bar(); + } +#pragma omp master + { +#pragma omp taskwait + bar(); + } +#pragma omp master + { +#pragma omp flush + bar(); + } + +// CRITICAL DIRECTIVE +#pragma omp critical + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { +#pragma omp single // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp critical + { +#pragma omp master // OK, though second 'master' is redundant + { + bar(); + } + } +#pragma omp critical + { +#pragma omp critical + { + bar(); + } + } +#pragma omp critical + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp critical + { +#pragma omp parallel + { +#pragma omp master // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp critical + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp critical + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp critical + { +#pragma omp task + { + bar(); + } + } +#pragma omp critical + { +#pragma omp taskyield + bar(); + } +#pragma omp critical + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'critical' region}} + bar(); + } +#pragma omp critical + { +#pragma omp taskwait + bar(); + } +#pragma omp critical(Belka) + { +#pragma omp critical(Strelka) + bar(); + } +#pragma omp critical(Tuzik)// expected-note {{previous 'critical' region starts here}} + { +#pragma omp critical(grelka) // expected-note {{previous 'critical' region starts here}} + { +#pragma omp critical(Tuzik) // expected-error {{cannot nest 'critical' regions having the same name 'Tuzik'}} + { +#pragma omp parallel +#pragma omp critical(grelka) // expected-error {{cannot nest 'critical' regions having the same name 'grelka'}} + { + bar(); + } + } + } + } + +// PARALLEL FOR DIRECTIVE +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp for // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel for region}} + { + bar(); + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp single // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + { + bar(); + } +#pragma omp master // expected-error {{region cannot be closely nested inside 'parallel for' region}} + { + bar(); + } +#pragma omp critical + { + bar(); + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp master // OK + { + bar(); + } +#pragma omp critical // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp task + { + bar(); + } + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp taskyield + bar(); + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel for' region}} + bar(); + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp taskwait + bar(); + } +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { +#pragma omp flush + bar(); + } + +// PARALLEL SECTIONS DIRECTIVE +#pragma omp parallel sections + { +#pragma omp for // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { +#pragma omp parallel + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { +#pragma omp sections // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } + } +#pragma omp parallel sections + { +#pragma omp section + { + bar(); + } + } +#pragma omp parallel 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 master // expected-error {{region cannot be closely nested inside 'section' region}} + bar(); +#pragma omp critical + bar(); + } + } +#pragma omp parallel sections + { +#pragma omp parallel + { +#pragma omp single // OK + { + bar(); + } +#pragma omp master // OK + { + bar(); + } +#pragma omp critical // OK + { + bar(); + } +#pragma omp for // OK + for (int i = 0; i < 10; ++i) + ; +#pragma omp sections // OK + { + bar(); + } + } + } +#pragma omp parallel sections + { +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; + } +#pragma omp parallel sections + { +#pragma omp parallel sections + { + bar(); + } + } +#pragma omp parallel sections + { +#pragma omp task + { + bar(); + } + } +#pragma omp parallel sections + { +#pragma omp taskyield + } +#pragma omp parallel sections + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel sections' region}} + } +#pragma omp parallel sections + { +#pragma omp taskwait + } +#pragma omp parallel sections + { +#pragma omp flush + } + +// TASK DIRECTIVE +#pragma omp task +#pragma omp for // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} + for (int i = 0; i < 10; ++i) + ; +#pragma omp task +#pragma omp simd + for (int i = 0; i < 10; ++i) + ; +#pragma omp task +#pragma omp sections // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}} + { + bar(); + } +#pragma omp task +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a task region}} + { + bar(); + } +#pragma omp task +#pragma omp single // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}} + bar(); +#pragma omp task +#pragma omp master // expected-error {{region cannot be closely nested inside 'task' region}} + bar(); +#pragma omp task +#pragma omp critical + bar(); +#pragma omp task +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + ; +#pragma omp task +#pragma omp parallel sections + { + bar(); + } +#pragma omp task +#pragma omp task + { + bar(); + } +#pragma omp task + { +#pragma omp taskyield + bar(); + } +#pragma omp task + { +#pragma omp barrier // expected-error {{region cannot be closely nested inside 'task' region}} + bar(); + } +#pragma omp task + { +#pragma omp taskwait + bar(); + } +#pragma omp task + { +#pragma omp flush + bar(); + } + return foo<int>(); +} + diff --git a/test/OpenMP/no_option.c b/test/OpenMP/no_option.c index 4acc8d0656b3..8a65b039fc9f 100644 --- a/test/OpenMP/no_option.c +++ b/test/OpenMP/no_option.c @@ -2,5 +2,5 @@ // expected-no-diagnostics int a; -#pragma omp threadprivate(a,b) +#pragma omp threadprivate(a, b) #pragma omp parallel diff --git a/test/OpenMP/no_option_no_warn.c b/test/OpenMP/no_option_no_warn.c index c989991371f4..10778c0b1e35 100644 --- a/test/OpenMP/no_option_no_warn.c +++ b/test/OpenMP/no_option_no_warn.c @@ -2,5 +2,5 @@ // expected-no-diagnostics int a; -#pragma omp threadprivate(a,b) +#pragma omp threadprivate(a, b) #pragma omp parallel diff --git a/test/OpenMP/openmp_common.c b/test/OpenMP/openmp_common.c index 3765f4c5dc14..3131b3045b6f 100644 --- a/test/OpenMP/openmp_common.c +++ b/test/OpenMP/openmp_common.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -o - %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s #pragma omp // expected-error {{expected an OpenMP directive}} #pragma omp unknown_directive // expected-error {{expected an OpenMP directive}} diff --git a/test/OpenMP/parallel_ast_print.cpp b/test/OpenMP/parallel_ast_print.cpp index f2fd2f7b69f9..0415c0ca555c 100644 --- a/test/OpenMP/parallel_ast_print.cpp +++ b/test/OpenMP/parallel_ast_print.cpp @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s -// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s -// RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// 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 @@ -8,53 +8,89 @@ void foo() {} +template <class T> +struct S { + operator T() {return T();} + static T TS; + #pragma omp threadprivate(TS) +}; -template <typename T> +// CHECK: template <class T = int> struct S { +// CHECK: static int TS; +// CHECK-NEXT: #pragma omp threadprivate(S<int>::TS) +// CHECK-NEXT: } +// CHECK: template <class T = long> struct S { +// CHECK: static long TS; +// CHECK-NEXT: #pragma omp threadprivate(S<long>::TS) +// CHECK-NEXT: } +// CHECK: template <class T> struct S { +// CHECK: static T TS; +// CHECK-NEXT: #pragma omp threadprivate(S::TS) +// CHECK: }; + +template <typename T, int C> T tmain(T argc, T *argv) { T b = argc, c, d, e, f, g; static T a; + S<T> s; #pragma omp parallel a=2; -#pragma omp parallel default(none), private(argc,b) firstprivate(argv) shared (d) +#pragma omp parallel default(none), private(argc,b) firstprivate(argv) shared (d) if (argc > 0) num_threads(C) copyin(S<T>::TS) proc_bind(master) reduction(+:c) reduction(max:e) + foo(); +#pragma omp parallel if (C) num_threads(s) proc_bind(close) reduction(^:e, f) reduction(&& : g) foo(); return 0; } -// CHECK: template <typename T = int> int tmain(int argc, int *argv) { + +// CHECK: template <typename T = int, int C = 5> int tmain(int argc, int *argv) { // CHECK-NEXT: int b = argc, c, d, e, f, g; // CHECK-NEXT: static int a; +// CHECK-NEXT: S<int> s; // CHECK-NEXT: #pragma omp parallel // CHECK-NEXT: a = 2; -// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) +// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) num_threads(5) copyin(S<int>::TS) proc_bind(master) reduction(+: c) reduction(max: e) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp parallel if(5) num_threads(s) proc_bind(close) reduction(^: e,f) reduction(&&: g) // CHECK-NEXT: foo() -// CHECK: template <typename T = float> float tmain(float argc, float *argv) { -// CHECK-NEXT: float b = argc, c, d, e, f, g; -// CHECK-NEXT: static float a; +// CHECK: template <typename T = long, int C = 1> long tmain(long argc, long *argv) { +// CHECK-NEXT: long b = argc, c, d, e, f, g; +// CHECK-NEXT: static long a; +// CHECK-NEXT: S<long> s; // CHECK-NEXT: #pragma omp parallel // CHECK-NEXT: a = 2; -// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) +// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) num_threads(1) copyin(S<long>::TS) proc_bind(master) reduction(+: c) reduction(max: e) // CHECK-NEXT: foo() -// CHECK: template <typename T> T tmain(T argc, T *argv) { +// CHECK-NEXT: #pragma omp parallel if(1) num_threads(s) proc_bind(close) reduction(^: e,f) reduction(&&: g) +// CHECK-NEXT: foo() +// CHECK: template <typename T, int C> T tmain(T argc, T *argv) { // CHECK-NEXT: T b = argc, c, d, e, f, g; // CHECK-NEXT: static T a; +// CHECK-NEXT: S<T> s; // CHECK-NEXT: #pragma omp parallel // CHECK-NEXT: a = 2; -// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) +// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) num_threads(C) copyin(S<T>::TS) proc_bind(master) reduction(+: c) reduction(max: e) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp parallel if(C) num_threads(s) proc_bind(close) reduction(^: e,f) reduction(&&: g) // CHECK-NEXT: foo() +enum Enum { }; + int main (int argc, char **argv) { - float x; + long x; int b = argc, c, d, e, f, g; static int a; -// CHECK: static int a; + #pragma omp threadprivate(a) + Enum ee; +// CHECK: Enum ee; #pragma omp parallel // CHECK-NEXT: #pragma omp parallel a=2; // CHECK-NEXT: a = 2; -#pragma omp parallel default(none), private(argc,b) firstprivate(argv) -// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) +#pragma omp parallel default(none), private(argc,b) firstprivate(argv) if (argc > 0) num_threads(ee) copyin(a) proc_bind(spread) reduction(| : c, d) reduction(* : e) +// CHECK-NEXT: #pragma omp parallel default(none) private(argc,b) firstprivate(argv) if(argc > 0) num_threads(ee) copyin(a) proc_bind(spread) reduction(|: c,d) reduction(*: e) foo(); // CHECK-NEXT: foo(); - return tmain(b, &b) + tmain(x, &x); + return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x); } #endif diff --git a/test/OpenMP/parallel_codegen.cpp b/test/OpenMP/parallel_codegen.cpp new file mode 100644 index 000000000000..d9ff5ac02333 --- /dev/null +++ b/test/OpenMP/parallel_codegen.cpp @@ -0,0 +1,145 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -emit-llvm %s -fexceptions -fcxx-exceptions -o - | FileCheck %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -g -std=c++11 -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-DEBUG %s +// expected-no-diagnostics +#ifndef HEADER +#define HEADER + +// CHECK-DAG: %ident_t = type { i32, i32, i32, i32, i8* } +// CHECK-DAG: %struct.anon = type { i32* } +// CHECK-DAG: %struct.anon.0 = type { i8*** } +// CHECK-DAG: [[STR:@.+]] = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00" +// CHECK-DAG: [[DEF_LOC_2:@.+]] = private unnamed_addr constant %ident_t { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8]* [[STR]], i32 0, i32 0) } +// CHECK-DEBUG-DAG: %ident_t = type { i32, i32, i32, i32, i8* } +// CHECK-DEBUG-DAG: %struct.anon = type { i32* } +// CHECK-DEBUG-DAG: %struct.anon.0 = type { i8*** } +// CHECK-DEBUG-DAG: [[STR:@.+]] = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00" +// CHECK-DEBUG-DAG: [[DEF_LOC_2:@.+]] = private unnamed_addr constant %ident_t { i32 0, i32 2, i32 0, i32 0, i8* getelementptr inbounds ([23 x i8]* [[STR]], i32 0, i32 0) } +// CHECK-DEBUG-DAG: [[LOC1:@.+]] = private unnamed_addr constant [{{.+}} x i8] c";{{.*}}parallel_codegen.cpp;main;[[@LINE+14]];9;;\00" +// CHECK-DEBUG-DAG: [[LOC2:@.+]] = private unnamed_addr constant [{{.+}} x i8] c";{{.*}}parallel_codegen.cpp;tmain;[[@LINE+7]];9;;\00" + +template <class T> +void foo(T argc) {} + +template <typename T> +int tmain(T argc) { +#pragma omp parallel + foo(argc); + return 0; +} + +int main (int argc, char **argv) { +#pragma omp parallel + foo(argc); + return tmain(argv); +} + +// CHECK-LABEL: define {{[a-z]*[ ]?i32}} @main({{i32[ ]?[a-z]*}} %argc, i8** %argv) +// CHECK: [[AGG_CAPTURED:%.+]] = alloca %struct.anon +// CHECK: [[ARGC_REF:%.+]] = getelementptr inbounds %struct.anon* [[AGG_CAPTURED]], i32 0, i32 0 +// CHECK-NEXT: store i32* {{%[a-z0-9.]+}}, i32** [[ARGC_REF]] +// CHECK-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon* [[AGG_CAPTURED]] to i8* +// CHECK-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon*)* @__captured_stmt to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-NEXT: [[ARGV:%.+]] = load i8*** {{%[a-z0-9.]+}} +// CHECK-NEXT: [[RET:%.+]] = call {{[a-z]*[ ]?i32}} [[TMAIN:@.+tmain.+]](i8** [[ARGV]]) +// CHECK-NEXT: ret i32 [[RET]] +// CHECK-NEXT: } +// CHECK-DEBUG-LABEL: define i32 @main(i32 %argc, i8** %argv) +// CHECK-DEBUG-DAG: [[AGG_CAPTURED:%.+]] = alloca %struct.anon +// CHECK-DEBUG-DAG: [[LOC_2_ADDR:%.+]] = alloca %ident_t +// CHECK-DEBUG: [[KMPC_LOC_VOIDPTR:%.+]] = bitcast %ident_t* [[LOC_2_ADDR]] to i8* +// CHECK-DEBUG-NEXT: [[KMPC_DEFAULT_LOC_VOIDPTR:%.+]] = bitcast %ident_t* [[DEF_LOC_2]] to i8* +// CHECK-DEBUG-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[KMPC_LOC_VOIDPTR]], i8* [[KMPC_DEFAULT_LOC_VOIDPTR]], i64 ptrtoint (%ident_t* getelementptr (%ident_t* null, i32 1) to i64), i32 8, i1 false) +// CHECK-DEBUG: [[ARGC_REF:%.+]] = getelementptr inbounds %struct.anon* [[AGG_CAPTURED]], i32 0, i32 0 +// CHECK-DEBUG-NEXT: store i32* {{%[a-z0-9.]+}}, i32** [[ARGC_REF]] +// CHECK-DEBUG-NEXT: [[KMPC_LOC_PSOURCE_REF:%.+]] = getelementptr inbounds %ident_t* [[LOC_2_ADDR]], i32 0, i32 4 +// CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.+}} x i8]* [[LOC1]], i32 0, i32 0), i8** [[KMPC_LOC_PSOURCE_REF]] +// CHECK-DEBUG-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon* [[AGG_CAPTURED]] to i8* +// CHECK-DEBUG-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[LOC_2_ADDR]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon*)* @__captured_stmt to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-DEBUG-NEXT: [[ARGV:%.+]] = load i8*** {{%[a-z0-9.]+}} +// CHECK-DEBUG-NEXT: [[RET:%.+]] = call i32 [[TMAIN:@.+tmain.+]](i8** [[ARGV]]) +// CHECK-DEBUG-NEXT: ret i32 [[RET]] +// CHECK-DEBUG-NEXT: } + +// CHECK-LABEL: define internal void @__captured_stmt(i32* %.global_tid., i32* %.bound_tid., %struct.anon* %__context) +// CHECK: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon* +// CHECK: store %struct.anon* %__context, %struct.anon** [[CONTEXT_ADDR]] +// CHECK: [[CONTEXT_PTR:%.+]] = load %struct.anon** [[CONTEXT_ADDR]] +// CHECK-NEXT: [[ARGC_PTR_REF:%.+]] = getelementptr inbounds %struct.anon* [[CONTEXT_PTR]], i32 0, i32 0 +// CHECK-NEXT: [[ARGC_REF:%.+]] = load i32** [[ARGC_PTR_REF]] +// CHECK-NEXT: [[ARGC:%.+]] = load i32* [[ARGC_REF]] +// CHECK-NEXT: invoke void [[FOO:@.+foo.+]](i32{{[ ]?[a-z]*}} [[ARGC]]) +// CHECK: ret void +// CHECK: call void @{{.+terminate.*}}( +// CHECK-NEXT: unreachable +// CHECK-NEXT: } +// CHECK-DEBUG-LABEL: define internal void @__captured_stmt(i32* %.global_tid., i32* %.bound_tid., %struct.anon* %__context) +// CHECK-DEBUG: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon* +// CHECK-DEBUG: store %struct.anon* %__context, %struct.anon** [[CONTEXT_ADDR]] +// CHECK-DEBUG: [[CONTEXT_PTR:%.+]] = load %struct.anon** [[CONTEXT_ADDR]] +// CHECK-DEBUG-NEXT: [[ARGC_PTR_REF:%.+]] = getelementptr inbounds %struct.anon* [[CONTEXT_PTR]], i32 0, i32 0 +// CHECK-DEBUG-NEXT: [[ARGC_REF:%.+]] = load i32** [[ARGC_PTR_REF]] +// CHECK-DEBUG-NEXT: [[ARGC:%.+]] = load i32* [[ARGC_REF]] +// CHECK-DEBUG-NEXT: invoke void [[FOO:@.+foo.+]](i32 [[ARGC]]) +// CHECK-DEBUG: ret void +// CHECK-DEBUG: call void @{{.+terminate.*}}( +// CHECK-DEBUG-NEXT: unreachable +// CHECK-DEBUG-NEXT: } + +// CHECK-DAG: define linkonce_odr void [[FOO]]({{i32[ ]?[a-z]*}} %argc) +// CHECK-DAG: declare void @__kmpc_fork_call(%ident_t*, i32, void (i32*, i32*, ...)*, ...) +// CHECK-DEBUG-DAG: define linkonce_odr void [[FOO]](i32 %argc) +// CHECK-DEBUG-DAG: declare void @__kmpc_fork_call(%ident_t*, i32, void (i32*, i32*, ...)*, ...) + +// CHECK: define linkonce_odr {{[a-z]*[ ]?i32}} [[TMAIN]](i8** %argc) +// CHECK: [[AGG_CAPTURED:%.+]] = alloca %struct.anon.0 +// CHECK: [[ARGC_REF:%.+]] = getelementptr inbounds %struct.anon.0* [[AGG_CAPTURED]], i32 0, i32 0 +// CHECK-NEXT: store i8*** {{%[a-z0-9.]+}}, i8**** [[ARGC_REF]] +// CHECK-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon.0* [[AGG_CAPTURED]] to i8* +// CHECK-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[DEF_LOC_2]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon.0*)* @__captured_stmt1 to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-NEXT: ret i32 0 +// CHECK-NEXT: } +// CHECK-DEBUG: define linkonce_odr i32 [[TMAIN]](i8** %argc) +// CHECK-DEBUG-DAG: [[AGG_CAPTURED:%.+]] = alloca %struct.anon.0 +// CHECK-DEBUG-DAG: [[LOC_2_ADDR:%.+]] = alloca %ident_t +// CHECK-DEBUG: [[KMPC_LOC_VOIDPTR:%.+]] = bitcast %ident_t* [[LOC_2_ADDR]] to i8* +// CHECK-DEBUG-NEXT: [[KMPC_DEFAULT_LOC_VOIDPTR:%.+]] = bitcast %ident_t* [[DEF_LOC_2]] to i8* +// CHECK-DEBUG-NEXT: call void @llvm.memcpy.p0i8.p0i8.i64(i8* [[KMPC_LOC_VOIDPTR]], i8* [[KMPC_DEFAULT_LOC_VOIDPTR]], i64 ptrtoint (%ident_t* getelementptr (%ident_t* null, i32 1) to i64), i32 8, i1 false) +// CHECK-DEBUG: [[ARGC_REF:%.+]] = getelementptr inbounds %struct.anon.0* [[AGG_CAPTURED]], i32 0, i32 0 +// CHECK-DEBUG-NEXT: store i8*** {{%[a-z0-9.]+}}, i8**** [[ARGC_REF]] +// CHECK-DEBUG-NEXT: [[KMPC_LOC_PSOURCE_REF:%.+]] = getelementptr inbounds %ident_t* [[LOC_2_ADDR]], i32 0, i32 4 +// CHECK-DEBUG-NEXT: store i8* getelementptr inbounds ([{{.+}} x i8]* [[LOC2]], i32 0, i32 0), i8** [[KMPC_LOC_PSOURCE_REF]] +// CHECK-DEBUG-NEXT: [[BITCAST:%.+]] = bitcast %struct.anon.0* [[AGG_CAPTURED]] to i8* +// CHECK-DEBUG-NEXT: call void (%ident_t*, i32, void (i32*, i32*, ...)*, ...)* @__kmpc_fork_call(%ident_t* [[LOC_2_ADDR]], i32 1, void (i32*, i32*, ...)* bitcast (void (i32*, i32*, %struct.anon.0*)* @__captured_stmt1 to void (i32*, i32*, ...)*), i8* [[BITCAST]]) +// CHECK-DEBUG-NEXT: ret i32 0 +// CHECK-DEBUG-NEXT: } + +// CHECK-LABEL: define internal void @__captured_stmt1(i32* %.global_tid., i32* %.bound_tid., %struct.anon.0* %__context) +// CHECK: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon.0* +// CHECK: store %struct.anon.0* %__context, %struct.anon.0** [[CONTEXT_ADDR]] +// CHECK: [[CONTEXT_PTR:%.+]] = load %struct.anon.0** [[CONTEXT_ADDR]] +// CHECK-NEXT: [[ARGC_PTR_REF:%.+]] = getelementptr inbounds %struct.anon.0* [[CONTEXT_PTR]], i32 0, i32 0 +// CHECK-NEXT: [[ARGC_REF:%.+]] = load i8**** [[ARGC_PTR_REF]] +// CHECK-NEXT: [[ARGC:%.+]] = load i8*** [[ARGC_REF]] +// CHECK-NEXT: invoke void [[FOO1:@.+foo.+]](i8** [[ARGC]]) +// CHECK: ret void +// CHECK: call void @{{.+terminate.*}}( +// CHECK-NEXT: unreachable +// CHECK-NEXT: } +// CHECK-DEBUG-LABEL: define internal void @__captured_stmt1(i32* %.global_tid., i32* %.bound_tid., %struct.anon.0* %__context) +// CHECK-DEBUG: [[CONTEXT_ADDR:%.+]] = alloca %struct.anon.0* +// CHECK-DEBUG: store %struct.anon.0* %__context, %struct.anon.0** [[CONTEXT_ADDR]] +// CHECK-DEBUG: [[CONTEXT_PTR:%.+]] = load %struct.anon.0** [[CONTEXT_ADDR]] +// CHECK-DEBUG-NEXT: [[ARGC_PTR_REF:%.+]] = getelementptr inbounds %struct.anon.0* [[CONTEXT_PTR]], i32 0, i32 0 +// CHECK-DEBUG-NEXT: [[ARGC_REF:%.+]] = load i8**** [[ARGC_PTR_REF]] +// CHECK-DEBUG-NEXT: [[ARGC:%.+]] = load i8*** [[ARGC_REF]] +// CHECK-DEBUG-NEXT: invoke void [[FOO1:@.+foo.+]](i8** [[ARGC]]) +// CHECK-DEBUG: ret void +// CHECK-DEBUG: call void @{{.+terminate.*}}( +// CHECK-DEBUG-NEXT: unreachable +// CHECK-DEBUG-NEXT: } + +// CHECK: define linkonce_odr void [[FOO1]](i8** %argc) +// CHECK-DEBUG: define linkonce_odr void [[FOO1]](i8** %argc) + +#endif diff --git a/test/OpenMP/parallel_copyin_messages.cpp b/test/OpenMP/parallel_copyin_messages.cpp new file mode 100644 index 000000000000..c1ce363b47bd --- /dev/null +++ b/test/OpenMP/parallel_copyin_messages.cpp @@ -0,0 +1,67 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} +class S2 { + mutable int a; +public: + S2():a(0) { } + S2 & operator =(S2 &s2) { return *this; } +}; +class S3 { + int a; +public: + S3():a(0) { } + S3 &operator =(S3 &s3) { return *this; } +}; +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4 &operator =(const S4 &s4); +public: + S4(int v):a(v) { } +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5():a(0) {} + S5 &operator =(const S5 &s5) { return *this; } +public: + S5(int v):a(v) { } +}; +template <class T> +class ST { +public: + static T s; +}; + + +S2 k; +S3 h; +S4 l(3); // expected-note {{'l' defined here}} +S5 m(4); // expected-note {{'m' defined here}} +#pragma omp threadprivate(h, k, l, m) + +int main(int argc, char **argv) { + int i; + #pragma omp parallel copyin // expected-error {{expected '(' after 'copyin'}} + #pragma omp parallel copyin ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel copyin () // expected-error {{expected expression}} + #pragma omp parallel copyin (k // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel copyin (h, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel copyin (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + #pragma omp parallel copyin (l) // expected-error {{copyin variable must have an accessible, unambiguous copy assignment operator}} + #pragma omp parallel copyin (S1) // expected-error {{'S1' does not refer to a value}} + #pragma omp parallel copyin (argv[1]) // expected-error {{expected variable name}} + #pragma omp parallel copyin(i) // expected-error {{copyin variable must be threadprivate}} + #pragma omp parallel copyin(m) // expected-error {{copyin variable must have an accessible, unambiguous copy assignment operator}} + #pragma omp parallel copyin(ST<int>::s) // expected-error {{copyin variable must be threadprivate}} + foo(); + + return 0; +} diff --git a/test/OpenMP/parallel_default_messages.cpp b/test/OpenMP/parallel_default_messages.cpp index cbc6a73fe35d..6014cdfd4bcc 100644 --- a/test/OpenMP/parallel_default_messages.cpp +++ b/test/OpenMP/parallel_default_messages.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -o - %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s void foo(); diff --git a/test/OpenMP/parallel_firstprivate_messages.cpp b/test/OpenMP/parallel_firstprivate_messages.cpp index 780059e282bf..9df45c60e708 100644 --- a/test/OpenMP/parallel_firstprivate_messages.cpp +++ b/test/OpenMP/parallel_firstprivate_messages.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s void foo() { } diff --git a/test/OpenMP/parallel_for_ast_print.cpp b/test/OpenMP/parallel_for_ast_print.cpp new file mode 100644 index 000000000000..375664f4243d --- /dev/null +++ b/test/OpenMP/parallel_for_ast_print.cpp @@ -0,0 +1,64 @@ +// 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, h; + static T a; +// CHECK: static T a; + static T g; +#pragma omp threadprivate(g) +#pragma omp parallel for schedule(dynamic) default(none) copyin(g) + // CHECK: #pragma omp parallel for schedule(dynamic) default(none) copyin(g) + for (int i = 0; i < 2; ++i) + a = 2; +// CHECK-NEXT: for (int i = 0; i < 2; ++i) +// CHECK-NEXT: a = 2; +#pragma omp parallel for private(argc, b), firstprivate(c, d), lastprivate(d, f) collapse(N) schedule(static, N) ordered if (argc) num_threads(N) default(shared) shared(e) reduction(+ : h) + for (int i = 0; i < 10; ++i) + for (int j = 0; j < 10; ++j) + for (int j = 0; j < 10; ++j) + for (int j = 0; j < 10; ++j) + for (int j = 0; j < 10; ++j) + foo(); + // CHECK-NEXT: #pragma omp parallel for private(argc,b) firstprivate(c,d) lastprivate(d,f) collapse(N) schedule(static, N) ordered if(argc) num_threads(N) default(shared) shared(e) reduction(+: h) + // CHECK-NEXT: for (int i = 0; i < 10; ++i) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // CHECK-NEXT: foo(); + return T(); +} + +int main(int argc, char **argv) { + int b = argc, c, d, e, f, h; + static int a; +// CHECK: static int a; + static float g; +#pragma omp threadprivate(g) +#pragma omp parallel for schedule(guided, argc) default(none) copyin(g) + // CHECK: #pragma omp parallel for schedule(guided, argc) default(none) copyin(g) + for (int i = 0; i < 2; ++i) + a = 2; +// CHECK-NEXT: for (int i = 0; i < 2; ++i) +// CHECK-NEXT: a = 2; +#pragma omp parallel for private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(2) schedule(auto) ordered if (argc) num_threads(a) default(shared) shared(e) reduction(+ : h) + for (int i = 0; i < 10; ++i) + for (int j = 0; j < 10; ++j) + foo(); + // CHECK-NEXT: #pragma omp parallel for private(argc,b) firstprivate(argv,c) lastprivate(d,f) collapse(2) schedule(auto) ordered if(argc) num_threads(a) default(shared) shared(e) reduction(+: h) + // CHECK-NEXT: for (int i = 0; i < 10; ++i) + // CHECK-NEXT: for (int j = 0; j < 10; ++j) + // CHECK-NEXT: foo(); + return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0])); +} + +#endif diff --git a/test/OpenMP/parallel_for_collapse_messages.cpp b/test/OpenMP/parallel_for_collapse_messages.cpp new file mode 100644 index 000000000000..06dfe0f77721 --- /dev/null +++ b/test/OpenMP/parallel_for_collapse_messages.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { //expected-note 2 {{declared here}} + #pragma omp parallel for collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for collapse () // expected-error {{expected expression}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 2 {{expression is not an integral constant expression}} + // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}} + #pragma omp parallel for collapse (argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp parallel for collapse (ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for collapse (1)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for collapse ((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'collapse' clause}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp parallel for', but found only 1}} + // expected-error@+3 2 {{directive '#pragma omp parallel for' cannot contain more than one 'collapse' clause}} + // expected-error@+2 2 {{argument to 'collapse' clause must be a positive integer value}} + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp parallel for collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for collapse (S) // expected-error {{'S' does not refer to a value}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp parallel for collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for collapse (1) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for collapse (N) // expected-error {{argument to 'collapse' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp parallel for'}} + return argc; +} + +int main(int argc, char **argv) { + #pragma omp parallel for collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for collapse () // expected-error {{expected expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for collapse (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp parallel for', but found only 1}} + #pragma omp parallel for collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp parallel for', but found only 1}} + #pragma omp parallel for collapse (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{expression is not an integral constant expression}} + // expected-error@+2 2 {{directive '#pragma omp parallel for' cannot contain more than one 'collapse' clause}} + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp parallel for collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for collapse (S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp parallel for collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp parallel for' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp parallel for collapse(collapse(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} + foo(); + #pragma omp parallel for collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp parallel for'}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}} + return tmain<int, char, 1, 0>(argc, argv); +} + diff --git a/test/OpenMP/parallel_for_copyin_messages.cpp b/test/OpenMP/parallel_for_copyin_messages.cpp new file mode 100644 index 000000000000..2ebc2ded7387 --- /dev/null +++ b/test/OpenMP/parallel_for_copyin_messages.cpp @@ -0,0 +1,93 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2 &operator=(S2 &s2) { return *this; } +}; +class S3 { + int a; + +public: + S3() : a(0) {} + S3 &operator=(S3 &s3) { return *this; } +}; +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4 &operator=(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + S5 &operator=(const S5 &s5) { return *this; } + +public: + S5(int v) : a(v) {} +}; +template <class T> +class ST { +public: + static T s; +}; + +S2 k; +S3 h; +S4 l(3); // expected-note {{'l' defined here}} +S5 m(4); // expected-note {{'m' defined here}} +#pragma omp threadprivate(h, k, l, m) + +int main(int argc, char **argv) { + int i; +#pragma omp parallel for copyin // expected-error {{expected '(' after 'copyin'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin(k // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin(h, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin(l) // expected-error {{copyin variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin(i) // expected-error {{copyin variable must be threadprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin(m) // expected-error {{copyin variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for copyin(ST < int > ::s) // expected-error {{copyin variable must be threadprivate}} + for (i = 0; i < argc; ++i) + foo(); + + return 0; +} diff --git a/test/OpenMP/parallel_for_default_messages.cpp b/test/OpenMP/parallel_for_default_messages.cpp new file mode 100644 index 000000000000..ed478a8c9721 --- /dev/null +++ b/test/OpenMP/parallel_for_default_messages.cpp @@ -0,0 +1,36 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo(); + +int main(int argc, char **argv) { + int i; +#pragma omp parallel for default // expected-error {{expected '(' after 'default'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for default( // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for default() // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for default(none // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + foo(); +#pragma omp parallel for default(shared), default(shared) // expected-error {{directive '#pragma omp parallel for' cannot contain more than one 'default' clause}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for default(x) // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} + for (i = 0; i < argc; ++i) + foo(); + +#pragma omp parallel for default(none) + for (i = 0; i < argc; ++i) // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + foo(); + +#pragma omp parallel default(none) +#pragma omp parallel for default(shared) + for (i = 0; i < argc; ++i) + foo(); + + return 0; +} diff --git a/test/OpenMP/parallel_for_firstprivate_messages.cpp b/test/OpenMP/parallel_for_firstprivate_messages.cpp new file mode 100644 index 000000000000..99dd68f3cbfa --- /dev/null +++ b/test/OpenMP/parallel_for_firstprivate_messages.cpp @@ -0,0 +1,252 @@ +// 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 for firstprivate // expected-error {{expected '(' after 'firstprivate'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(a, b) // expected-error {{firstprivate variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel for'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel for firstprivate(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel for firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for firstprivate(i) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel private(i) +#pragma omp parallel for firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be firstprivate, predetermined as private}} + foo(); +#pragma omp parallel reduction(+ : i) +#pragma omp parallel for firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be firstprivate, predetermined as private}} + 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 for firstprivate // expected-error {{expected '(' after 'firstprivate'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(argc) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(2 * 2) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(ba) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(ca) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(da) // OK + for (i = 0; i < argc; ++i) + foo(); + int xa; +#pragma omp parallel for firstprivate(xa) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(S2::S2s) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(S2::S2sc) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp parallel for'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(m) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for private(xa), firstprivate(xa) // expected-error {{private variable cannot be firstprivate}} expected-note {{defined as private}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be firstprivate, predetermined as private}} + foo(); +#pragma omp parallel shared(xa) +#pragma omp parallel for firstprivate(xa) // OK: may be firstprivate + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(n) firstprivate(n) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel for firstprivate(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel private(i) +#pragma omp parallel for firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be firstprivate, predetermined as private}} + foo(); +#pragma omp parallel reduction(+ : i) +#pragma omp parallel for firstprivate(i) // expected-note {{defined as firstprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be firstprivate, predetermined as private}} + 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/parallel_for_if_messages.cpp b/test/OpenMP/parallel_for_if_messages.cpp new file mode 100644 index 000000000000..295d7398b839 --- /dev/null +++ b/test/OpenMP/parallel_for_if_messages.cpp @@ -0,0 +1,69 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, class S> // expected-note {{declared here}} +int tmain(T argc, S **argv) { + T i; + #pragma omp parallel for if // expected-error {{expected '(' after 'if'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if () // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argc > 0 ? argv[1] : argv[2]) + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp parallel for' cannot contain more than one 'if' clause}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (S) // expected-error {{'S' does not refer to a value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if(argc) + for (i = 0; i < argc; ++i) foo(); + + return 0; +} + +int main(int argc, char **argv) { + int i; + #pragma omp parallel for if // expected-error {{expected '(' after 'if'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if () // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argc > 0 ? argv[1] : argv[2]) + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp parallel for' cannot contain more than one 'if' clause}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for if(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + + return tmain(argc, argv); +} diff --git a/test/OpenMP/parallel_for_lastprivate_messages.cpp b/test/OpenMP/parallel_for_lastprivate_messages.cpp new file mode 100644 index 000000000000..bd1dd4b52768 --- /dev/null +++ b/test/OpenMP/parallel_for_lastprivate_messages.cpp @@ -0,0 +1,226 @@ +// 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; // expected-note {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}} +const S2 b; +const S2 ba[5]; +class S3 { // expected-note 2 {{'S3' declared here}} + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} +class S4 { // expected-note 3 {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + +public: + S5(const S5 &s5) : a(s5.a) {} + 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}} + I g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel for lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel for'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel for lastprivate(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel for lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for lastprivate(i) + for (int k = 0; k < argc; ++k) + ++k; + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}} + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + S3 m; // expected-note 2 {{'m' defined here}} + S6 n(2); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel for lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(argc) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(a, b, c, d, f) // expected-error {{lastprivate variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(2 * 2) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(ba) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(ca) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(da) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); + int xa; +#pragma omp parallel for lastprivate(xa) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp parallel for'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(i) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel private(xa) +#pragma omp parallel for lastprivate(xa) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel reduction(+ : xa) +#pragma omp parallel for lastprivate(xa) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for lastprivate(n) firstprivate(n) // OK + for (i = 0; i < argc; ++i) + 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/parallel_for_loop_messages.cpp b/test/OpenMP/parallel_for_loop_messages.cpp new file mode 100644 index 000000000000..f029ef4d76cb --- /dev/null +++ b/test/OpenMP/parallel_for_loop_messages.cpp @@ -0,0 +1,593 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify %s + +class S { + int a; + S() : a(0) {} + +public: + S(int v) : a(v) {} + S(const S &s) : a(s.a) {} +}; + +static int sii; +#pragma omp threadprivate(sii) // expected-note {{defined as threadprivate or thread local}} + +int test_iteration_spaces() { + const int N = 100; + float a[N], b[N], c[N]; + int ii, jj, kk; + float fii; + double dii; +#pragma omp parallel for + for (int i = 0; i < 10; i += 1) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel for + for (char i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel for + for (char i = 0; i < 10; i += '\1') { + c[i] = a[i] + b[i]; + } +#pragma omp parallel for + for (long long i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } +// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'double'}} +#pragma omp parallel for + for (long long i = 0; i < 10; i += 1.5) { + c[i] = a[i] + b[i]; + } +#pragma omp parallel for + for (long long i = 0; i < 'z'; i += 1u) { + c[i] = a[i] + b[i]; + } +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp parallel for + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp parallel for + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp parallel for + for (int &ref = ii; ref < 10; ref++) { + } +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for + for (int i; i < 10; i++) + c[i] = a[i]; + +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for + for (int i = 0, j = 0; i < 10; ++i) + c[i] = a[i]; + +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for + for (; ii < 10; ++ii) + c[ii] = a[ii]; + +// expected-warning@+3 {{expression result unused}} +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for + for (ii + 1; ii < 10; ++ii) + c[ii] = a[ii]; + +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for + for (c[ii] = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +// Ok to skip parenthesises. +#pragma omp parallel for + for (((ii)) = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp parallel for + for (int i = 0; i; i++) + c[i] = a[i]; + +// expected-error@+3 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'i'}} +#pragma omp parallel for + for (int i = 0; jj < kk; ii++) + c[i] = a[i]; + +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp parallel for + for (int i = 0; !!i; i++) + c[i] = a[i]; + +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp parallel for + for (int i = 0; i != 1; i++) + c[i] = a[i]; + +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} +#pragma omp parallel for + for (int i = 0;; i++) + c[i] = a[i]; + +// Ok. +#pragma omp parallel for + for (int i = 11; i > 10; i--) + c[i] = a[i]; + +// Ok. +#pragma omp parallel for + for (int i = 0; i < 10; ++i) + c[i] = a[i]; + +// Ok. +#pragma omp parallel for + for (ii = 0; ii < 10; ++ii) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for + for (ii = 0; ii < 10; ++jj) + c[ii] = a[jj]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for + for (ii = 0; ii < 10; ++++ii) + c[ii] = a[ii]; + +// Ok but undefined behavior (in general, cannot check that incr +// is really loop-invariant). +#pragma omp parallel for + for (ii = 0; ii < 10; ii = ii + ii) + c[ii] = a[ii]; + +// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'float'}} +#pragma omp parallel for + for (ii = 0; ii < 10; ii = ii + 1.0f) + c[ii] = a[ii]; + +// Ok - step was converted to integer type. +#pragma omp parallel for + for (ii = 0; ii < 10; ii = ii + (int)1.1f) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for + for (ii = 0; ii < 10; jj = ii + 2) + c[ii] = a[ii]; + +// expected-warning@+3 {{relational comparison result unused}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for + for (ii = 0; ii<10; jj> kk + 2) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for + for (ii = 0; ii < 10;) + c[ii] = a[ii]; + +// expected-warning@+3 {{expression result unused}} +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for + for (ii = 0; ii < 10; !ii) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for + for (ii = 0; ii < 10; ii ? ++ii : ++jj) + c[ii] = a[ii]; + +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} +#pragma omp parallel for + for (ii = 0; ii < 10; ii = ii < 10) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (ii = 0; ii < 10; ii = ii + 0) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (ii = 0; ii < 10; ii = ii + (int)(0.8 - 0.45)) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (ii = 0; (ii) < 10; ii -= 25) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (ii = 0; (ii < 10); ii -= 0) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (ii = 0; ii > 10; (ii += 0)) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (ii = 0; ii < 10; (ii) = (1 - 1) + (ii)) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for + for ((ii = 0); ii > 10; (ii -= 0)) + c[ii] = a[ii]; + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (ii = 0; (ii < 10); (ii -= 0)) + c[ii] = a[ii]; + +// expected-note@+2 {{defined as firstprivate}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be firstprivate, predetermined as private}} +#pragma omp parallel for firstprivate(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +// expected-error@+3 {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel for'}} +// expected-note@+2 {{defined as linear}} +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be linear, predetermined as private}} +#pragma omp parallel for linear(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel for private(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + +#pragma omp parallel for lastprivate(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + + { +// expected-error@+2 {{loop iteration variable in the associated loop of 'omp parallel for' directive may not be threadprivate or thread local, predetermined as private}} +#pragma omp parallel for + for (sii = 0; sii < 10; sii += 1) + c[sii] = a[sii]; + } + +// expected-error@+2 {{statement after '#pragma omp parallel for' must be a for loop}} +#pragma omp parallel for + for (auto &item : a) { + item = item + 1; + } + +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'i' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (unsigned i = 9; i < 10; i--) { + c[i] = a[i] + b[i]; + } + + int(*lb)[4] = nullptr; +#pragma omp parallel for + for (int(*p)[4] = lb; p < lb + 8; ++p) { + } + +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for + for (int a{0}; a < 10; ++a) { + } + + return 0; +} + +// Iterators allowed in openmp for-loops. +namespace std { +struct random_access_iterator_tag {}; +template <class Iter> +struct iterator_traits { + typedef typename Iter::difference_type difference_type; + typedef typename Iter::iterator_category iterator_category; +}; +template <class Iter> +typename iterator_traits<Iter>::difference_type +distance(Iter first, Iter last) { return first - last; } +} +class Iter0 { +public: + Iter0() {} + Iter0(const Iter0 &) {} + Iter0 operator++() { return *this; } + Iter0 operator--() { return *this; } + bool operator<(Iter0 a) { return true; } +}; +int operator-(Iter0 a, Iter0 b) { return 0; } +class Iter1 { +public: + Iter1(float f = 0.0f, double d = 0.0) {} + Iter1(const Iter1 &) {} + Iter1 operator++() { return *this; } + Iter1 operator--() { return *this; } + bool operator<(Iter1 a) { return true; } + bool operator>=(Iter1 a) { return false; } +}; +class GoodIter { +public: + GoodIter() {} + GoodIter(const GoodIter &) {} + GoodIter(int fst, int snd) {} + GoodIter &operator=(const GoodIter &that) { return *this; } + GoodIter &operator=(const Iter0 &that) { return *this; } + GoodIter &operator+=(int x) { return *this; } + explicit GoodIter(void *) {} + GoodIter operator++() { return *this; } + GoodIter operator--() { return *this; } + bool operator!() { return true; } + bool operator<(GoodIter a) { return true; } + bool operator<=(GoodIter a) { return true; } + bool operator>=(GoodIter a) { return false; } + typedef int difference_type; + typedef std::random_access_iterator_tag iterator_category; +}; +int operator-(GoodIter a, GoodIter b) { return 0; } +GoodIter operator-(GoodIter a) { return a; } +GoodIter operator-(GoodIter a, int v) { return GoodIter(); } +GoodIter operator+(GoodIter a, int v) { return GoodIter(); } +GoodIter operator-(int v, GoodIter a) { return GoodIter(); } +GoodIter operator+(int v, GoodIter a) { return GoodIter(); } + +int test_with_random_access_iterator() { + GoodIter begin, end; + Iter0 begin0, end0; +#pragma omp parallel for + for (GoodIter I = begin; I < end; ++I) + ++I; +// expected-error@+2 {{variable must be of integer or random access iterator type}} +#pragma omp parallel for + for (GoodIter &I = begin; I < end; ++I) + ++I; +#pragma omp parallel for + for (GoodIter I = begin; I >= end; --I) + ++I; +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for + for (GoodIter I(begin); I < end; ++I) + ++I; +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for + for (GoodIter I(nullptr); I < end; ++I) + ++I; +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for + for (GoodIter I(0); I < end; ++I) + ++I; +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for + for (GoodIter I(1, 2); I < end; ++I) + ++I; +#pragma omp parallel for + for (begin = GoodIter(0); begin < end; ++begin) + ++begin; +#pragma omp parallel for + for (begin = begin0; begin < end; ++begin) + ++begin; +// expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} +#pragma omp parallel for + for (++begin; begin < end; ++begin) + ++begin; +#pragma omp parallel for + for (begin = end; begin < end; ++begin) + ++begin; +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp parallel for + for (GoodIter I = begin; I - I; ++I) + ++I; +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp parallel for + for (GoodIter I = begin; begin < end; ++I) + ++I; +// expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} +#pragma omp parallel for + for (GoodIter I = begin; !I; ++I) + ++I; +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (GoodIter I = begin; I >= end; I = I + 1) + ++I; +#pragma omp parallel for + for (GoodIter I = begin; I >= end; I = I - 1) + ++I; +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} +#pragma omp parallel for + for (GoodIter I = begin; I >= end; I = -I) + ++I; +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (GoodIter I = begin; I >= end; I = 2 + I) + ++I; +// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} +#pragma omp parallel for + for (GoodIter I = begin; I >= end; I = 2 - I) + ++I; +#pragma omp parallel for + for (Iter0 I = begin0; I < end0; ++I) + ++I; +// Initializer is constructor without params. +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for + for (Iter0 I; I < end0; ++I) + ++I; + Iter1 begin1, end1; +#pragma omp parallel for + for (Iter1 I = begin1; I < end1; ++I) + ++I; +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (Iter1 I = begin1; I >= end1; ++I) + ++I; +// Initializer is constructor with all default params. +// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} +#pragma omp parallel for + for (Iter1 I; I < end1; ++I) { + } + return 0; +} + +template <typename IT, int ST> +class TC { +public: + int dotest_lt(IT begin, IT end) { +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (IT I = begin; I < end; I = I + ST) { + ++I; + } +// expected-note@+3 {{loop step is expected to be positive due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (IT I = begin; I <= end; I += ST) { + ++I; + } +#pragma omp parallel for + for (IT I = begin; I < end; ++I) { + ++I; + } + } + + static IT step() { + return IT(ST); + } +}; +template <typename IT, int ST = 0> +int dotest_gt(IT begin, IT end) { +// expected-note@+3 2 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (IT I = begin; I >= end; I = I + ST) { + ++I; + } +// expected-note@+3 2 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (IT I = begin; I >= end; I += ST) { + ++I; + } + +// expected-note@+3 {{loop step is expected to be negative due to this condition}} +// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} +#pragma omp parallel for + for (IT I = begin; I >= end; ++I) { + ++I; + } + +#pragma omp parallel for + for (IT I = begin; I < end; I += TC<int, ST>::step()) { + ++I; + } +} + +void test_with_template() { + GoodIter begin, end; + TC<GoodIter, 100> t1; + TC<GoodIter, -100> t2; + t1.dotest_lt(begin, end); + t2.dotest_lt(begin, end); // expected-note {{in instantiation of member function 'TC<GoodIter, -100>::dotest_lt' requested here}} + dotest_gt(begin, end); // expected-note {{in instantiation of function template specialization 'dotest_gt<GoodIter, 0>' requested here}} + dotest_gt<unsigned, -10>(0, 100); // expected-note {{in instantiation of function template specialization 'dotest_gt<unsigned int, -10>' requested here}} +} + +void test_loop_break() { + const int N = 100; + float a[N], b[N], c[N]; +#pragma omp parallel for + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + break; // OK in nested loop + } + switch (i) { + case 1: + b[i]++; + break; + default: + break; + } + if (c[i] > 10) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + + if (c[i] > 11) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + } + +#pragma omp parallel for + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 10; j++) { + c[i] = a[i] + b[i]; + if (c[i] > 10) { + if (c[i] < 20) { + break; // OK + } + } + } + } +} + +void test_loop_eh() { + const int N = 100; + float a[N], b[N], c[N]; +#pragma omp parallel for + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + try { + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + throw a[i]; + } + throw a[i]; + } catch (float f) { + if (f > 0.1) + throw a[i]; + return; // expected-error {{cannot return from OpenMP region}} + } + switch (i) { + case 1: + b[i]++; + break; + default: + break; + } + for (int j = 0; j < 10; j++) { + if (c[i] > 10) + throw c[i]; + } + } + if (c[9] > 10) + throw c[9]; // OK + +#pragma omp parallel for + for (int i = 0; i < 10; ++i) { + struct S { + void g() { throw 0; } + }; + } +} + +void test_loop_firstprivate_lastprivate() { + S s(4); +#pragma omp parallel for lastprivate(s) firstprivate(s) + for (int i = 0; i < 16; ++i) + ; +} diff --git a/test/OpenMP/parallel_for_messages.cpp b/test/OpenMP/parallel_for_messages.cpp new file mode 100644 index 000000000000..e4ea0d5e2d93 --- /dev/null +++ b/test/OpenMP/parallel_for_messages.cpp @@ -0,0 +1,86 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -std=c++11 -o - %s + +void foo() { +} + +#pragma omp parallel for // expected-error {{unexpected OpenMP directive '#pragma omp parallel for'}} + +int main(int argc, char **argv) { +#pragma omp parallel for { // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for ( // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for[ // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for] // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for) // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for } // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for + for (int i = 0; i < argc; ++i) + foo(); +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for' are ignored}} +#pragma omp parallel for unknown() + for (int i = 0; i < argc; ++i) + foo(); +L1: + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for + for (int i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for + for (int i = 0; i < argc; ++i) { + goto L1; // expected-error {{use of undeclared label 'L1'}} + argc++; + } + + for (int i = 0; i < 10; ++i) { + switch (argc) { + case (0): +#pragma omp parallel for + for (int i = 0; i < argc; ++i) { + foo(); + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + continue; + } + default: + break; + } + } +#pragma omp parallel for default(none) + for (int i = 0; i < 10; ++i) + ++argc; // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + + goto L2; // expected-error {{use of undeclared label 'L2'}} +#pragma omp parallel for + for (int i = 0; i < argc; ++i) + L2: + foo(); +#pragma omp parallel for + for (int i = 0; i < argc; ++i) { + return 1; // expected-error {{cannot return from OpenMP region}} + } + + [[]] // expected-error {{an attribute list cannot appear here}} +#pragma omp parallel for + for (int n = 0; n < 100; ++n) { + } + + return 0; +} + +void test_ordered() { +#pragma omp parallel for ordered ordered // expected-error {{directive '#pragma omp parallel for' cannot contain more than one 'ordered' clause}} + for (int i = 0; i < 16; ++i) + ; +} + diff --git a/test/OpenMP/parallel_for_misc_messages.c b/test/OpenMP/parallel_for_misc_messages.c new file mode 100644 index 000000000000..b236a613c319 --- /dev/null +++ b/test/OpenMP/parallel_for_misc_messages.c @@ -0,0 +1,309 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp parallel for'}} +#pragma omp parallel for + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp parallel for'}} +#pragma omp parallel for foo + +void test_no_clause() { + int i; +#pragma omp parallel for + for (i = 0; i < 16; ++i) + ; + +// expected-error@+2 {{statement after '#pragma omp parallel for' must be a for loop}} +#pragma omp parallel for + ++i; +} + +void test_branch_protected_scope() { + int i = 0; +L1: + ++i; + + int x[24]; + +#pragma omp parallel for + for (i = 0; i < 16; ++i) { + 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; +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for' are ignored}} +#pragma omp parallel for foo bar + for (i = 0; i < 16; ++i) + ; +} + +void test_non_identifiers() { + int i, x; + +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for' are ignored}} +#pragma omp parallel for; + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel for'}} +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for' are ignored}} +#pragma omp parallel for linear(x); + for (i = 0; i < 16; ++i) + ; + +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for' are ignored}} +#pragma omp parallel for private(x); + for (i = 0; i < 16; ++i) + ; + +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel for' are ignored}} +#pragma omp parallel for, private(x); + for (i = 0; i < 16; ++i) + ; +} + +extern int foo(); + +void test_collapse() { + int i; +// expected-error@+1 {{expected '('}} +#pragma omp parallel for collapse + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for collapse( + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for collapse() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for collapse(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for collapse(, ) + for (i = 0; i < 16; ++i) + ; +// expected-warning@+2 {{extra tokens at the end of '#pragma omp parallel for' are ignored}} +// expected-error@+1 {{expected '('}} +#pragma omp parallel for collapse 4) + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for collapse(4 + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for', but found only 1}} +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for collapse(4, + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for', but found only 1}} +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for collapse(4, ) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for', but found only 1}} +// expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for collapse(4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for', but found only 1}} +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for collapse(4 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for', but found only 1}} +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for collapse(4, , 4) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for', but found only 1}} +#pragma omp parallel for collapse(4) + for (int i1 = 0; i1 < 16; ++i1) + for (int i2 = 0; i2 < 16; ++i2) + for (int i3 = 0; i3 < 16; ++i3) + for (int i4 = 0; i4 < 16; ++i4) + foo(); +// expected-error@+2 {{expected ')'}} +// expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} +#pragma omp parallel for collapse(4, 8) + for (i = 0; i < 16; ++i) + ; // expected-error {{expected 4 for loops after '#pragma omp parallel for', but found only 1}} +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp parallel for collapse(2.5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expression is not an integer constant expression}} +#pragma omp parallel for collapse(foo()) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp parallel for collapse(-5) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp parallel for collapse(0) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} +#pragma omp parallel for collapse(5 - 5) + for (i = 0; i < 16; ++i) + ; +} + +void test_private() { + int i; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel for private( + for (i = 0; i < 16; ++i) + ; +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for private(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for private(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for private() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for private(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp parallel for private(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel for private(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for private(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for private(x, y, z) + for (i = 0; i < 16; ++i) { + x = y * i + z; + } +} + +void test_lastprivate() { + int i; +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp parallel for lastprivate( + for (i = 0; i < 16; ++i) + ; + +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for lastprivate(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for lastprivate(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for lastprivate() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for lastprivate(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp parallel for lastprivate(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel for lastprivate(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for lastprivate(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for lastprivate(x, y, z) + for (i = 0; i < 16; ++i) + ; +} + +void test_firstprivate() { + int i; +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp parallel for firstprivate( + for (i = 0; i < 16; ++i) + ; + +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for firstprivate(, + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel for firstprivate(, ) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for firstprivate() + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected expression}} +#pragma omp parallel for firstprivate(int) + for (i = 0; i < 16; ++i) + ; +// expected-error@+1 {{expected variable name}} +#pragma omp parallel for firstprivate(0) + for (i = 0; i < 16; ++i) + ; + + int x, y, z; +#pragma omp parallel for lastprivate(x) firstprivate(x) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for lastprivate(x, y) firstprivate(x, y) + for (i = 0; i < 16; ++i) + ; +#pragma omp parallel for lastprivate(x, y, z) firstprivate(x, y, z) + for (i = 0; i < 16; ++i) + ; +} + +void test_loop_messages() { + float a[100], b[100], c[100]; +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp parallel for + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +// expected-error@+2 {{variable must be of integer or pointer type}} +#pragma omp parallel for + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +} + diff --git a/test/OpenMP/parallel_for_num_threads_messages.cpp b/test/OpenMP/parallel_for_num_threads_messages.cpp new file mode 100644 index 000000000000..e1928982ad1a --- /dev/null +++ b/test/OpenMP/parallel_for_num_threads_messages.cpp @@ -0,0 +1,65 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N> // expected-note {{declared here}} +T tmain(T argc, S **argv) { + T i; + #pragma omp parallel for num_threads // expected-error {{expected '(' after 'num_threads'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads () // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads ((argc > 0) ? argv[1] : argv[2]) // expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (foobool(argc)), num_threads (true), num_threads (-5) // expected-error 2 {{directive '#pragma omp parallel for' cannot contain more than one 'num_threads' clause}} expected-error {{argument to 'num_threads' clause must be a positive integer value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (S) // expected-error {{'S' does not refer to a value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (argc) + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (N) // expected-error {{argument to 'num_threads' clause must be a positive integer value}} + for (i = 0; i < argc; ++i) foo(); + + return argc; +} + +int main(int argc, char **argv) { + int i; + #pragma omp parallel for num_threads // expected-error {{expected '(' after 'num_threads'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads () // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (argc > 0 ? argv[1] : argv[2]) // expected-error {{integral }} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (foobool(argc)), num_threads (true), num_threads (-5) // expected-error 2 {{directive '#pragma omp parallel for' cannot contain more than one 'num_threads' clause}} expected-error {{argument to 'num_threads' clause must be a positive integer value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expression must have integral or unscoped enumeration type, not 'char *'}} + for (i = 0; i < argc; ++i) foo(); + #pragma omp parallel for num_threads (num_threads(tmain<int, char, -1>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} expected-note {{in instantiation of function template specialization 'tmain<int, char, -1>' requested here}} + for (i = 0; i < argc; ++i) foo(); + + return tmain<int, char, 3>(argc, argv); // expected-note {{in instantiation of function template specialization 'tmain<int, char, 3>' requested here}} +} diff --git a/test/OpenMP/parallel_for_private_messages.cpp b/test/OpenMP/parallel_for_private_messages.cpp new file mode 100644 index 000000000000..7366fe8c47c5 --- /dev/null +++ b/test/OpenMP/parallel_for_private_messages.cpp @@ -0,0 +1,173 @@ +// 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 parallel for private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(e, g) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for nowait // expected-error {{unexpected OpenMP clause 'nowait' in directive '#pragma omp parallel for'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel for private(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel for private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(i) + for (int k = 0; k < argc; ++k) + ++k; + 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 parallel for private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for nowait // expected-error {{unexpected OpenMP clause 'nowait' in directive '#pragma omp parallel for'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int i; +#pragma omp parallel for private(i) + for (int k = 0; k < argc; ++k) + ++k; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel for private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel for private(i) + for (int k = 0; k < argc; ++k) + ++k; + + return 0; +} + diff --git a/test/OpenMP/parallel_for_proc_bind_messages.cpp b/test/OpenMP/parallel_for_proc_bind_messages.cpp new file mode 100644 index 000000000000..0347caf68b02 --- /dev/null +++ b/test/OpenMP/parallel_for_proc_bind_messages.cpp @@ -0,0 +1,35 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo(); + +int main(int argc, char **argv) { + int i; +#pragma omp parallel for proc_bind // expected-error {{expected '(' after 'proc_bind'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for proc_bind( // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for proc_bind() // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for proc_bind(master // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for proc_bind(close), proc_bind(spread) // expected-error {{directive '#pragma omp parallel for' cannot contain more than one 'proc_bind' clause}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel for proc_bind(x) // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} + for (i = 0; i < argc; ++i) + foo(); + +#pragma omp parallel for proc_bind(master) + for (i = 0; i < argc; ++i) + foo(); + +#pragma omp parallel proc_bind(close) +#pragma omp parallel for proc_bind(spread) + for (i = 0; i < argc; ++i) + foo(); + return 0; +} diff --git a/test/OpenMP/parallel_for_reduction_messages.cpp b/test/OpenMP/parallel_for_reduction_messages.cpp new file mode 100644 index 000000000000..8e482ef73536 --- /dev/null +++ b/test/OpenMP/parallel_for_reduction_messages.cpp @@ -0,0 +1,295 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + S2 &operator+=(const S2 &arg) { return (*this); } + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note 2 {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}} +S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; // expected-note 2 {{'ba' defined here}} +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} + S3 operator+=(const S3 &arg1) { return arg1; } +}; +int operator+=(const S3 &arg1, const S3 &arg2) { return 5; } +S3 c; // expected-note 2 {{'c' defined here}} +const S3 ca[5]; // expected-note 2 {{'ca' defined here}} +extern const int f; // expected-note 4 {{'f' declared here}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + S4 &operator+=(const S4 &arg) { return (*this); } + +public: + S4(int v) : a(v) {} +}; +S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; } +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + S5 &operator+=(const S5 &arg); + +public: + S5(int v) : a(v) {} +}; +class S6 { + int a; + +public: + S6() : a(6) {} + operator int() { return 6; } +} o; // expected-note 2 {{'o' defined here}} + +S3 h, k; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class T> // expected-note {{declared here}} +T tmain(T argc) { // expected-note 2 {{'argc' defined here}} + const T d = T(); // expected-note 4 {{'d' defined here}} + const T da[5] = {T()}; // expected-note 2 {{'da' defined here}} + T qa[5] = {T()}; + T i; + T &j = i; // expected-note 4 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}} + T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}} + T fl; // expected-note {{'fl' defined here}} +#pragma omp parallel for reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(^ : T) // expected-error {{'T' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(max : qa[1]) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp parallel for reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp parallel for reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) +#pragma omp parallel for reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) +#pragma omp parallel for reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); + + return T(); +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note 2 {{'d' defined here}} + const int da[5] = {0}; // expected-note {{'da' defined here}} + int qa[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note 2 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const int &r = da[i]; // expected-note {{'r' defined here}} + int &q = qa[i]; // expected-note {{'q' defined here}} + float fl; // expected-note {{'fl' defined here}} +#pragma omp parallel for reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(~ : argc) // expected-error {{expected unqualified-id}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(^ : S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(max : argv[1]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp parallel for reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel for reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp parallel for reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) +#pragma omp parallel for reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) +#pragma omp parallel for reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); + + return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}} +} diff --git a/test/OpenMP/parallel_for_schedule_messages.cpp b/test/OpenMP/parallel_for_schedule_messages.cpp new file mode 100644 index 000000000000..b03758a10d66 --- /dev/null +++ b/test/OpenMP/parallel_for_schedule_messages.cpp @@ -0,0 +1,91 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { + #pragma omp parallel for schedule // expected-error {{expected '(' after 'schedule'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule ( // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule () // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule (auto // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule (auto_dynamic // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule (auto, // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule (runtime, 3) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp parallel for schedule (guided argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp parallel for schedule (static, ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule (dynamic, 1)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule (guided, (ST > 0) ? 1 + ST : 2) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+2 2 {{directive '#pragma omp parallel for' cannot contain more than one 'schedule' clause}} + // expected-error@+1 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp parallel for schedule (static, foobool(argc)), schedule (dynamic, true), schedule (guided, -5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule (static, S) // expected-error {{'S' does not refer to a value}} expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp parallel for schedule (guided, argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule (dynamic, 1) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp parallel for schedule (static, N) // expected-error {{argument to 'schedule' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + return argc; +} + +int main(int argc, char **argv) { + #pragma omp parallel for schedule // expected-error {{expected '(' after 'schedule'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule ( // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule () // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule (auto // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule (auto_dynamic // expected-error {{expected 'static', 'dynamic', 'guided', 'auto' or 'runtime' in OpenMP clause 'schedule'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule (auto, // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule (runtime, 3) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule (guided, 4 // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule (static, 2+2)) // expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule (dynamic, foobool(1) > 0 ? 1 : 2) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+2 2 {{directive '#pragma omp parallel for' cannot contain more than one 'schedule' clause}} + // expected-error@+1 {{argument to 'schedule' clause must be a positive integer value}} + #pragma omp parallel for schedule (guided, foobool(argc)), schedule (static, true), schedule (dynamic, -5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp parallel for schedule (guided, S1) // expected-error {{'S1' does not refer to a value}} expected-warning {{extra tokens at the end of '#pragma omp parallel for' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp parallel for schedule (static, argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp parallel for' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp parallel for schedule(dynamic, schedule(tmain<int, char, -1, -2>(argc, argv) // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}} + return tmain<int, char, 1, 0>(argc, argv); +} + diff --git a/test/OpenMP/parallel_if_messages.cpp b/test/OpenMP/parallel_if_messages.cpp new file mode 100644 index 000000000000..1559692a989d --- /dev/null +++ b/test/OpenMP/parallel_if_messages.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, class S> // expected-note {{declared here}} +int tmain(T argc, S **argv) { + #pragma omp parallel if // expected-error {{expected '(' after 'if'}} + #pragma omp parallel if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel if () // expected-error {{expected expression}} + #pragma omp parallel if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + #pragma omp parallel if (argc > 0 ? argv[1] : argv[2]) + #pragma omp parallel if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp parallel' cannot contain more than one 'if' clause}} + #pragma omp parallel if (S) // expected-error {{'S' does not refer to a value}} + #pragma omp parallel if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel if(argc) + foo(); + + return 0; +} + +int main(int argc, char **argv) { + #pragma omp parallel if // expected-error {{expected '(' after 'if'}} + #pragma omp parallel if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel if () // expected-error {{expected expression}} + #pragma omp parallel if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + #pragma omp parallel if (argc > 0 ? argv[1] : argv[2]) + #pragma omp parallel if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp parallel' cannot contain more than one 'if' clause}} + #pragma omp parallel if (S1) // expected-error {{'S1' does not refer to a value}} + #pragma omp parallel if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel if (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel if(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + + return tmain(argc, argv); +} diff --git a/test/OpenMP/parallel_messages.cpp b/test/OpenMP/parallel_messages.cpp index d991ccfc3806..1e0edbc6f808 100644 --- a/test/OpenMP/parallel_messages.cpp +++ b/test/OpenMP/parallel_messages.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 -std=c++11 -o - %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -std=c++11 -o - %s void foo() { } @@ -6,8 +6,21 @@ void foo() { #pragma omp parallel // expected-error {{unexpected OpenMP directive '#pragma omp parallel'}} int main(int argc, char **argv) { + #pragma omp parallel { // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + foo(); + #pragma omp parallel ( // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + foo(); + #pragma omp parallel [ // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + foo(); + #pragma omp parallel ] // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + foo(); + #pragma omp parallel ) // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + foo(); + #pragma omp parallel } // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + foo(); #pragma omp parallel - #pragma omp parallel unknown() // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + // expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel' are ignored}} + #pragma omp parallel unknown() foo(); L1: foo(); diff --git a/test/OpenMP/parallel_num_threads_messages.cpp b/test/OpenMP/parallel_num_threads_messages.cpp new file mode 100644 index 000000000000..facca5e35879 --- /dev/null +++ b/test/OpenMP/parallel_num_threads_messages.cpp @@ -0,0 +1,44 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N> // expected-note {{declared here}} +T tmain(T argc, S **argv) { + #pragma omp parallel num_threads // expected-error {{expected '(' after 'num_threads'}} + #pragma omp parallel num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel num_threads () // expected-error {{expected expression}} + #pragma omp parallel num_threads (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel num_threads (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + #pragma omp parallel num_threads ((argc > 0) ? argv[1] : argv[2]) // expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp parallel num_threads (foobool(argc)), num_threads (true), num_threads (-5) // expected-error 2 {{directive '#pragma omp parallel' cannot contain more than one 'num_threads' clause}} expected-error {{argument to 'num_threads' clause must be a positive integer value}} + #pragma omp parallel num_threads (S) // expected-error {{'S' does not refer to a value}} + #pragma omp parallel num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp parallel num_threads (argc) + #pragma omp parallel num_threads (N) // expected-error {{argument to 'num_threads' clause must be a positive integer value}} + foo(); + + return argc; +} + +int main(int argc, char **argv) { + #pragma omp parallel num_threads // expected-error {{expected '(' after 'num_threads'}} + #pragma omp parallel num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel num_threads () // expected-error {{expected expression}} + #pragma omp parallel num_threads (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel num_threads (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + #pragma omp parallel num_threads (argc > 0 ? argv[1] : argv[2]) // expected-error {{integral }} + #pragma omp parallel num_threads (foobool(argc)), num_threads (true), num_threads (-5) // expected-error 2 {{directive '#pragma omp parallel' cannot contain more than one 'num_threads' clause}} expected-error {{argument to 'num_threads' clause must be a positive integer value}} + #pragma omp parallel num_threads (S1) // expected-error {{'S1' does not refer to a value}} + #pragma omp parallel num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expression must have integral or unscoped enumeration type, not 'char *'}} + #pragma omp parallel num_threads (num_threads(tmain<int, char, -1>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} expected-note {{in instantiation of function template specialization 'tmain<int, char, -1>' requested here}} + foo(); + + return tmain<int, char, 3>(argc, argv); // expected-note {{in instantiation of function template specialization 'tmain<int, char, 3>' requested here}} +} diff --git a/test/OpenMP/parallel_private_messages.cpp b/test/OpenMP/parallel_private_messages.cpp index 2037d56daf0c..1cd86d2b5fbc 100644 --- a/test/OpenMP/parallel_private_messages.cpp +++ b/test/OpenMP/parallel_private_messages.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s void foo() { } @@ -13,7 +13,7 @@ class S2 { mutable int a; public: S2():a(0) { } - static float S2s; // expected-note {{predetermined as shared}} + static float S2s; // expected-note {{static data member is predetermined as shared}} }; const S2 b; const S2 ba[5]; @@ -22,9 +22,9 @@ class S3 { public: S3():a(0) { } }; -const S3 c; // expected-note {{predetermined as shared}} -const S3 ca[5]; // expected-note {{predetermined as shared}} -extern const int f; // expected-note {{predetermined as shared}} +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} class S4 { // expected-note {{'S4' declared here}} int a; S4(); @@ -42,8 +42,8 @@ int threadvar; #pragma omp threadprivate(threadvar) // expected-note {{defined as threadprivate or thread local}} int main(int argc, char **argv) { - const int d = 5; // expected-note {{predetermined as shared}} - const int da[5] = { 0 }; // expected-note {{predetermined as shared}} + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = { 0 }; // expected-note {{constant variable is predetermined as shared}} S4 e(4); // expected-note {{'e' defined here}} S5 g(5); // expected-note {{'g' defined here}} int i; diff --git a/test/OpenMP/parallel_proc_bind_messages.cpp b/test/OpenMP/parallel_proc_bind_messages.cpp new file mode 100644 index 000000000000..0bb9fc7db626 --- /dev/null +++ b/test/OpenMP/parallel_proc_bind_messages.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo(); + +int main(int argc, char **argv) { + #pragma omp parallel proc_bind // expected-error {{expected '(' after 'proc_bind'}} + #pragma omp parallel proc_bind ( // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel proc_bind () // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} + #pragma omp parallel proc_bind (master // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp parallel proc_bind (close), proc_bind(spread) // expected-error {{directive '#pragma omp parallel' cannot contain more than one 'proc_bind' clause}} + #pragma omp parallel proc_bind (x) // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} + foo(); + + #pragma omp parallel proc_bind(master) + ++argc; + + #pragma omp parallel proc_bind(close) + #pragma omp parallel proc_bind(spread) + ++argc; + return 0; +} diff --git a/test/OpenMP/parallel_reduction_messages.cpp b/test/OpenMP/parallel_reduction_messages.cpp new file mode 100644 index 000000000000..43ebc01b2a36 --- /dev/null +++ b/test/OpenMP/parallel_reduction_messages.cpp @@ -0,0 +1,240 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + S2 &operator+=(const S2 &arg) { return (*this); } + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note 2 {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}} +S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; // expected-note 2 {{'ba' defined here}} +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} + S3 operator+=(const S3 &arg1) { return arg1; } +}; +int operator+=(const S3 &arg1, const S3 &arg2) { return 5; } +S3 c; // expected-note 2 {{'c' defined here}} +const S3 ca[5]; // expected-note 2 {{'ca' defined here}} +extern const int f; // expected-note 4 {{'f' declared here}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + S4 &operator+=(const S4 &arg) { return (*this); } + +public: + S4(int v) : a(v) {} +}; +S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; } +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + S5 &operator+=(const S5 &arg); + +public: + S5(int v) : a(v) {} +}; +class S6 { + int a; + +public: + S6() : a(6) {} + operator int() { return 6; } +} o; // expected-note 2 {{'o' defined here}} + +S3 h, k; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class T> // expected-note {{declared here}} +T tmain(T argc) { // expected-note 2 {{'argc' defined here}} + const T d = T(); // expected-note 4 {{'d' defined here}} + const T da[5] = {T()}; // expected-note 2 {{'da' defined here}} + T qa[5] = {T()}; + T i; + T &j = i; // expected-note 4 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}} + T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}} + T fl; // expected-note {{'fl' defined here}} +#pragma omp parallel reduction // expected-error {{expected '(' after 'reduction'}} + foo(); +#pragma omp parallel reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + foo(); +#pragma omp parallel reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + foo(); +#pragma omp parallel reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + foo(); +#pragma omp parallel reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + foo(); +#pragma omp parallel reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + foo(); +#pragma omp parallel reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + foo(); +#pragma omp parallel reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}} + foo(); +#pragma omp parallel reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + foo(); +#pragma omp parallel reduction(&& : argc) + foo(); +#pragma omp parallel reduction(^ : T) // expected-error {{'T' does not refer to a value}} + foo(); +#pragma omp parallel reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(max : qa[1]) // expected-error 2 {{expected variable name}} + foo(); +#pragma omp parallel reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + foo(); +#pragma omp parallel reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + foo(); +#pragma omp parallel reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}} + foo(); +#pragma omp parallel reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + foo(); +#pragma omp parallel reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + foo(); +#pragma omp parallel private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp parallel private(k) +#pragma omp parallel reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp parallel reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}} + foo(); +#pragma omp parallel reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp parallel reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp parallel +#pragma omp for private(fl) + for (int i = 0; i < 10; ++i) +#pragma omp parallel reduction(+ : fl) + foo(); +#pragma omp parallel +#pragma omp for reduction(- : fl) + for (int i = 0; i < 10; ++i) +#pragma omp parallel reduction(+ : fl) + foo(); + + return T(); +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note 2 {{'d' defined here}} + const int da[5] = {0}; // expected-note {{'da' defined here}} + int qa[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note 2 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const int &r = da[i]; // expected-note {{'r' defined here}} + int &q = qa[i]; // expected-note {{'q' defined here}} + float fl; // expected-note {{'fl' defined here}} +#pragma omp parallel reduction // expected-error {{expected '(' after 'reduction'}} + foo(); +#pragma omp parallel reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp parallel' are ignored}} + foo(); +#pragma omp parallel reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + foo(); +#pragma omp parallel reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + foo(); +#pragma omp parallel reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + foo(); +#pragma omp parallel reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + foo(); +#pragma omp parallel reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp parallel reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); +#pragma omp parallel reduction(~ : argc) // expected-error {{expected unqualified-id}} + foo(); +#pragma omp parallel reduction(&& : argc) + foo(); +#pragma omp parallel reduction(^ : S1) // expected-error {{'S1' does not refer to a value}} + foo(); +#pragma omp parallel reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(max : argv[1]) // expected-error {{expected variable name}} + foo(); +#pragma omp parallel reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + foo(); +#pragma omp parallel reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + foo(); +#pragma omp parallel reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} + foo(); +#pragma omp parallel reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + foo(); +#pragma omp parallel reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}} + foo(); +#pragma omp parallel reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + foo(); +#pragma omp parallel reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + foo(); +#pragma omp parallel private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp parallel private(k) +#pragma omp parallel reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp parallel reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} + foo(); +#pragma omp parallel reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}} + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp parallel reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + foo(); +#pragma omp parallel +#pragma omp for private(fl) + for (int i = 0; i < 10; ++i) +#pragma omp parallel reduction(+ : fl) + foo(); +#pragma omp parallel +#pragma omp for reduction(- : fl) + for (int i = 0; i < 10; ++i) +#pragma omp parallel reduction(+ : fl) + foo(); + + return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}} +} diff --git a/test/OpenMP/parallel_sections_ast_print.cpp b/test/OpenMP/parallel_sections_ast_print.cpp new file mode 100644 index 000000000000..43665f743952 --- /dev/null +++ b/test/OpenMP/parallel_sections_ast_print.cpp @@ -0,0 +1,144 @@ +// 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> +struct S { + operator T() { return T(); } + static T TS; +#pragma omp threadprivate(TS) +}; + +// CHECK: template <class T = int> struct S { +// CHECK: static int TS; +// CHECK-NEXT: #pragma omp threadprivate(S<int>::TS) +// CHECK-NEXT: } +// CHECK: template <class T = long> struct S { +// CHECK: static long TS; +// CHECK-NEXT: #pragma omp threadprivate(S<long>::TS) +// CHECK-NEXT: } +// CHECK: template <class T> struct S { +// CHECK: static T TS; +// CHECK-NEXT: #pragma omp threadprivate(S::TS) +// CHECK: }; + +template <typename T, int C> +T tmain(T argc, T *argv) { + T b = argc, c, d, e, f, g; + static T a; + S<T> s; +#pragma omp parallel sections + { + a = 2; + } +#pragma omp parallel sections default(none), private(argc, b) firstprivate(argv) shared(d) if (argc > 0) num_threads(C) copyin(S < T > ::TS) proc_bind(master) reduction(+ : c) reduction(max : e) + { + foo(); + } +#pragma omp parallel sections if (C) num_threads(s) proc_bind(close) reduction(^ : e, f) reduction(&& : g) lastprivate(b, c) + { + foo(); +#pragma omp section + foo(); + } + return 0; +} + +// CHECK: template <typename T = int, int C = 5> int tmain(int argc, int *argv) { +// CHECK-NEXT: int b = argc, c, d, e, f, g; +// CHECK-NEXT: static int a; +// CHECK-NEXT: S<int> s; +// CHECK-NEXT: #pragma omp parallel sections +// CHECK-NEXT: { +// CHECK-NEXT: a = 2; +// CHECK-NEXT: } +// CHECK-NEXT: #pragma omp parallel sections default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) num_threads(5) copyin(S<int>::TS) proc_bind(master) reduction(+: c) reduction(max: e) +// CHECK-NEXT: { +// CHECK-NEXT: foo(); +// CHECK-NEXT: } +// CHECK-NEXT: #pragma omp parallel sections if(5) num_threads(s) proc_bind(close) reduction(^: e,f) reduction(&&: g) lastprivate(b,c) +// CHECK-NEXT: { +// CHECK-NEXT: foo(); +// CHECK-NEXT: #pragma omp section +// CHECK-NEXT: foo(); +// CHECK-NEXT: } +// CHECK: template <typename T = long, int C = 1> long tmain(long argc, long *argv) { +// CHECK-NEXT: long b = argc, c, d, e, f, g; +// CHECK-NEXT: static long a; +// CHECK-NEXT: S<long> s; +// CHECK-NEXT: #pragma omp parallel sections +// CHECK-NEXT: { +// CHECK-NEXT: a = 2; +// CHECK-NEXT: } +// CHECK-NEXT: #pragma omp parallel sections default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) num_threads(1) copyin(S<long>::TS) proc_bind(master) reduction(+: c) reduction(max: e) +// CHECK-NEXT: { +// CHECK-NEXT: foo(); +// CHECK-NEXT: } +// CHECK-NEXT: #pragma omp parallel sections if(1) num_threads(s) proc_bind(close) reduction(^: e,f) reduction(&&: g) lastprivate(b,c) +// CHECK-NEXT: { +// CHECK-NEXT: foo(); +// CHECK-NEXT: #pragma omp section +// CHECK-NEXT: foo(); +// CHECK-NEXT: } +// CHECK: template <typename T, int C> T tmain(T argc, T *argv) { +// CHECK-NEXT: T b = argc, c, d, e, f, g; +// CHECK-NEXT: static T a; +// CHECK-NEXT: S<T> s; +// CHECK-NEXT: #pragma omp parallel sections +// CHECK-NEXT: { +// CHECK-NEXT: a = 2; +// CHECK-NEXT: } +// CHECK-NEXT: #pragma omp parallel sections default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) num_threads(C) copyin(S<T>::TS) proc_bind(master) reduction(+: c) reduction(max: e) +// CHECK-NEXT: { +// CHECK-NEXT: foo(); +// CHECK-NEXT: } +// CHECK-NEXT: #pragma omp parallel sections if(C) num_threads(s) proc_bind(close) reduction(^: e,f) reduction(&&: g) lastprivate(b,c) +// CHECK-NEXT: { +// CHECK-NEXT: foo(); +// CHECK-NEXT: #pragma omp section +// CHECK-NEXT: foo(); +// CHECK-NEXT: } + +enum Enum {}; + +int main(int argc, char **argv) { + long x; + int b = argc, c, d, e, f, g; + static int a; +#pragma omp threadprivate(a) + Enum ee; +// CHECK: Enum ee; +#pragma omp parallel sections + // CHECK-NEXT: #pragma omp parallel sections + { + a = 2; + } +// CHECK-NEXT: { +// CHECK-NEXT: a = 2; +// CHECK-NEXT: } +#pragma omp parallel sections default(none), private(argc, b) firstprivate(argv) if (argc > 0) num_threads(ee) copyin(a) proc_bind(spread) reduction(| : c, d) reduction(* : e) lastprivate(argv) + // CHECK-NEXT: #pragma omp parallel sections default(none) private(argc,b) firstprivate(argv) if(argc > 0) num_threads(ee) copyin(a) proc_bind(spread) reduction(|: c,d) reduction(*: e) lastprivate(argv) + { + foo(); +#pragma omp section + foo(); +#pragma omp section + foo(); + } + // CHECK-NEXT: { + // CHECK-NEXT: foo(); + // CHECK-NEXT: #pragma omp section + // CHECK-NEXT: foo(); + // CHECK-NEXT: #pragma omp section + // CHECK-NEXT: foo(); + // CHECK-NEXT: } + return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x); +} + +#endif diff --git a/test/OpenMP/parallel_sections_copyin_messages.cpp b/test/OpenMP/parallel_sections_copyin_messages.cpp new file mode 100644 index 000000000000..500417e113be --- /dev/null +++ b/test/OpenMP/parallel_sections_copyin_messages.cpp @@ -0,0 +1,105 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2 &operator=(S2 &s2) { return *this; } +}; +class S3 { + int a; + +public: + S3() : a(0) {} + S3 &operator=(S3 &s3) { return *this; } +}; +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4 &operator=(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + S5 &operator=(const S5 &s5) { return *this; } + +public: + S5(int v) : a(v) {} +}; +template <class T> +class ST { +public: + static T s; +}; + +S2 k; +S3 h; +S4 l(3); // expected-note {{'l' defined here}} +S5 m(4); // expected-note {{'m' defined here}} +#pragma omp threadprivate(h, k, l, m) + +int main(int argc, char **argv) { + int i; +#pragma omp parallel sections copyin // expected-error {{expected '(' after 'copyin'}} + { + foo(); + } +#pragma omp parallel sections copyin( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections copyin() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel sections copyin(k // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections copyin(h, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections copyin(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections copyin(l) // expected-error {{copyin variable must have an accessible, unambiguous copy assignment operator}} + { + foo(); + } +#pragma omp parallel sections copyin(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel sections copyin(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections copyin(i) // expected-error {{copyin variable must be threadprivate}} + { + foo(); + } +#pragma omp parallel sections copyin(m) // expected-error {{copyin variable must have an accessible, unambiguous copy assignment operator}} + { + foo(); + } +#pragma omp parallel sections copyin(ST < int > ::s) // expected-error {{copyin variable must be threadprivate}} + { + foo(); + } + + return 0; +} diff --git a/test/OpenMP/parallel_sections_default_messages.cpp b/test/OpenMP/parallel_sections_default_messages.cpp new file mode 100644 index 000000000000..55d5d4f2efb6 --- /dev/null +++ b/test/OpenMP/parallel_sections_default_messages.cpp @@ -0,0 +1,39 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo(); + +int main(int argc, char **argv) { +#pragma omp parallel sections default // expected-error {{expected '(' after 'default'}} + { +#pragma omp parallel sections default( // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { +#pragma omp parallel sections default() // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} + { +#pragma omp parallel sections default(none // expected-error {{expected ')'}} expected-note {{to match this '('}} + { +#pragma omp parallel sections default(shared), default(shared) // expected-error {{directive '#pragma omp parallel sections' cannot contain more than one 'default' clause}} + { +#pragma omp parallel sections default(x) // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} + { + foo(); + } + } + } + } + } + } + +#pragma omp parallel sections default(none) + { + ++argc; // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + } + +#pragma omp parallel sections default(none) + { +#pragma omp parallel sections default(shared) + { + ++argc; + } + } + return 0; +} diff --git a/test/OpenMP/parallel_sections_firstprivate_messages.cpp b/test/OpenMP/parallel_sections_firstprivate_messages.cpp new file mode 100644 index 000000000000..ffd2b0cfd5e5 --- /dev/null +++ b/test/OpenMP/parallel_sections_firstprivate_messages.cpp @@ -0,0 +1,295 @@ +// 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 sections firstprivate // expected-error {{expected '(' after 'firstprivate'}} + { + foo(); + } +#pragma omp parallel sections firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections firstprivate() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argc) + { + foo(); + } +#pragma omp parallel sections firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel sections firstprivate(a, b) // expected-error {{firstprivate variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + { + foo(); + } +#pragma omp parallel sections firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + { + foo(); + } +#pragma omp parallel sections linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel sections'}} + { + foo(); + } +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel sections firstprivate(i) + { + foo(); + } + v += i; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel sections firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel sections firstprivate(i) + { + foo(); + } +#pragma omp parallel sections lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} + { + foo(); + } +#pragma omp parallel private(i) +#pragma omp parallel sections firstprivate(i) + { + foo(); + } +#pragma omp parallel reduction(+ : i) +#pragma omp parallel sections firstprivate(i) + { + 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 sections firstprivate // expected-error {{expected '(' after 'firstprivate'}} + { + foo(); + } +#pragma omp parallel sections firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections firstprivate() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argc) + { + foo(); + } +#pragma omp parallel sections firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel sections firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp parallel sections firstprivate(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections firstprivate(2 * 2) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections firstprivate(ba) // OK + { + foo(); + } +#pragma omp parallel sections firstprivate(ca) // OK + { + foo(); + } +#pragma omp parallel sections firstprivate(da) // OK + { + foo(); + } + int xa; +#pragma omp parallel sections firstprivate(xa) // OK + { + foo(); + } +#pragma omp parallel sections firstprivate(S2::S2s) // OK + { + foo(); + } +#pragma omp parallel sections firstprivate(S2::S2sc) // OK + { + foo(); + } +#pragma omp parallel sections safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp parallel sections'}} + { + foo(); + } +#pragma omp parallel sections firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + { + foo(); + } +#pragma omp parallel sections firstprivate(m) // OK + { + foo(); + } +#pragma omp parallel sections firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + { + foo(); + } +#pragma omp parallel sections private(xa), firstprivate(xa) // expected-error {{private variable cannot be firstprivate}} expected-note {{defined as private}} + { + foo(); + } +#pragma omp parallel shared(xa) +#pragma omp parallel sections firstprivate(xa) // OK: may be firstprivate + { + foo(); + } +#pragma omp parallel sections firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel sections lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} + { + foo(); + } +#pragma omp parallel sections lastprivate(n) firstprivate(n) // OK + { + foo(); + } +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel sections firstprivate(i) + { + foo(); + } + v += i; + } +#pragma omp parallel private(i) +#pragma omp parallel sections firstprivate(i) + { + foo(); + } +#pragma omp parallel reduction(+ : i) +#pragma omp parallel sections firstprivate(i) + { + 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/parallel_sections_if_messages.cpp b/test/OpenMP/parallel_sections_if_messages.cpp new file mode 100644 index 000000000000..4af0d8561d03 --- /dev/null +++ b/test/OpenMP/parallel_sections_if_messages.cpp @@ -0,0 +1,113 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, class S> // expected-note {{declared here}} +int tmain(T argc, S **argv) { + #pragma omp parallel sections if // expected-error {{expected '(' after 'if'}} + { + foo(); + } + #pragma omp parallel sections if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + #pragma omp parallel sections if () // expected-error {{expected expression}} + { + foo(); + } + #pragma omp parallel sections if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + #pragma omp parallel sections if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } + #pragma omp parallel sections if (argc > 0 ? argv[1] : argv[2]) + { + foo(); + } + #pragma omp parallel sections if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp parallel sections' cannot contain more than one 'if' clause}} + { + foo(); + } + #pragma omp parallel sections if (S) // expected-error {{'S' does not refer to a value}} + { + foo(); + } + #pragma omp parallel sections if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + #pragma omp parallel sections if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + #pragma omp parallel sections if(argc) + { + foo(); + } + + return 0; +} + +int main(int argc, char **argv) { + #pragma omp parallel sections if // expected-error {{expected '(' after 'if'}} + { + foo(); + } + #pragma omp parallel sections if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + #pragma omp parallel sections if () // expected-error {{expected expression}} + { + foo(); + } + #pragma omp parallel sections if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + #pragma omp parallel sections if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } + #pragma omp parallel sections if (argc > 0 ? argv[1] : argv[2]) + { + foo(); + } + #pragma omp parallel sections if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp parallel sections' cannot contain more than one 'if' clause}} + { + foo(); + } + #pragma omp parallel sections if (S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } + #pragma omp parallel sections if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + #pragma omp parallel sections if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + #pragma omp parallel sections if (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + #pragma omp parallel sections if(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } + + return tmain(argc, argv); +} diff --git a/test/OpenMP/parallel_sections_lastprivate_messages.cpp b/test/OpenMP/parallel_sections_lastprivate_messages.cpp new file mode 100644 index 000000000000..c71c115bd187 --- /dev/null +++ b/test/OpenMP/parallel_sections_lastprivate_messages.cpp @@ -0,0 +1,269 @@ +// 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; // expected-note {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}} +const S2 b; +const S2 ba[5]; +class S3 { // expected-note 2 {{'S3' declared here}} + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} +class S4 { // expected-note 3 {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + +public: + S5(const S5 &s5) : a(s5.a) {} + 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}} + I g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel sections lastprivate // expected-error {{expected '(' after 'lastprivate'}} + { + foo(); + } +#pragma omp parallel sections lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections lastprivate() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argc) + { + foo(); + } +#pragma omp parallel sections lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel sections lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + { + foo(); + } +#pragma omp parallel sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel sections linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel sections'}} + { + foo(); + } +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel sections lastprivate(i) + { + foo(); + } + v += i; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel sections lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel sections lastprivate(i) + { + foo(); + } + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}} + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + S3 m; // expected-note 2 {{'m' defined here}} + S6 n(2); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel sections lastprivate // expected-error {{expected '(' after 'lastprivate'}} + { + foo(); + } +#pragma omp parallel sections lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections lastprivate() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argc) + { + foo(); + } +#pragma omp parallel sections lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel sections lastprivate(a, b, c, d, f) // expected-error {{lastprivate variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel sections lastprivate(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections lastprivate(2 * 2) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections lastprivate(ba) + { + foo(); + } +#pragma omp parallel sections lastprivate(ca) // expected-error {{shared variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel sections lastprivate(da) // expected-error {{shared variable cannot be lastprivate}} + { + foo(); + } + int xa; +#pragma omp parallel sections lastprivate(xa) // OK + { + foo(); + } +#pragma omp parallel sections lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel sections lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel sections safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp parallel sections'}} + { + foo(); + } +#pragma omp parallel sections lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + { + foo(); + } +#pragma omp parallel sections lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + { + foo(); + } +#pragma omp parallel sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel sections private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}} + { + foo(); + } +#pragma omp parallel sections lastprivate(i) + { + foo(); + } +#pragma omp parallel private(xa) +#pragma omp parallel sections lastprivate(xa) + { + foo(); + } +#pragma omp parallel reduction(+ : xa) +#pragma omp parallel sections lastprivate(xa) + { + foo(); + } +#pragma omp parallel sections lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel sections firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + { + foo(); + } +#pragma omp parallel sections lastprivate(n) firstprivate(n) // OK + { + 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/parallel_sections_messages.cpp b/test/OpenMP/parallel_sections_messages.cpp new file mode 100644 index 000000000000..f5875098e82b --- /dev/null +++ b/test/OpenMP/parallel_sections_messages.cpp @@ -0,0 +1,85 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -std=c++11 -o - %s + +void foo() { +} + +#pragma omp parallel sections // expected-error {{unexpected OpenMP directive '#pragma omp parallel sections'}} + +int main(int argc, char **argv) { +#pragma omp parallel sections {// expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } +#pragma omp parallel sections( // expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } +#pragma omp parallel sections[ // expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } +#pragma omp parallel sections] // expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } +#pragma omp parallel sections) // expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } +#pragma omp parallel sections } // expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} +#pragma omp parallel sections unknown() + { + foo(); +#pragma omp section + L1: + foo(); + } +#pragma omp parallel sections + { + ; + } +#pragma omp parallel sections + { + goto L1; // expected-error {{use of undeclared label 'L1'}} + } + + for (int i = 0; i < 10; ++i) { + switch (argc) { + case (0): +#pragma omp parallel sections + { + foo(); + break; // expected-error {{'break' statement not in loop or switch statement}} + continue; // expected-error {{'continue' statement not in loop statement}} + } + default: + break; + } + } +#pragma omp parallel sections default(none) + { + ++argc; // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + } + + goto L2; // expected-error {{use of undeclared label 'L2'}} +#pragma omp parallel sections + { + L2: + foo(); + } +#pragma omp parallel sections + { + return 1; // expected-error {{cannot return from OpenMP region}} + } + + [[]] // expected-error {{an attribute list cannot appear here}} +#pragma omp parallel sections + { + } + + return 0; +} diff --git a/test/OpenMP/parallel_sections_misc_messages.c b/test/OpenMP/parallel_sections_misc_messages.c new file mode 100644 index 000000000000..94f1241335ab --- /dev/null +++ b/test/OpenMP/parallel_sections_misc_messages.c @@ -0,0 +1,260 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s + +void foo(); + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp parallel sections'}} +#pragma omp parallel sections + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp parallel sections'}} +#pragma omp parallel sections foo + +void test_no_clause() { + int i; +#pragma omp parallel sections + { + foo(); + } + +// expected-error@+2 {{the statement for '#pragma omp parallel sections' must be a compound statement}} +#pragma omp parallel sections + ++i; + +#pragma omp parallel sections + { + foo(); + foo(); // expected-error {{statement in 'omp parallel sections' directive must be enclosed into a section region}} + } + +} + +void test_branch_protected_scope() { + int i = 0; +L1: + ++i; + + int x[24]; + +#pragma omp parallel sections + { + 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]++; + } +#pragma omp section + 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 L3; + else if (i == 8) { + L3: + x[i]++; + } + } + + if (x[0] == 0) + goto L2; // expected-error {{use of undeclared label 'L2'}} + else if (x[1] == 1) + goto L1; + goto L3; // expected-error {{use of undeclared label 'L3'}} +} + +void test_invalid_clause() { + int i; +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} +#pragma omp parallel sections foo bar + { + foo(); +// expected-error@+1 {{unexpected OpenMP clause 'nowait' in directive '#pragma omp section'}} +#pragma omp section nowait + ; + } +} + +void test_non_identifiers() { + int i, x; + +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} +#pragma omp parallel sections; + { + foo(); + } +// expected-error@+2 {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel sections'}} +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} +#pragma omp parallel sections linear(x); + { + foo(); + } + +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} +#pragma omp parallel sections private(x); + { + foo(); + } + +// expected-warning@+1 {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} +#pragma omp parallel sections, private(x); + { + foo(); + } +} + +void test_private() { + int i; +// expected-error@+2 {{expected expression}} +// expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} +#pragma omp parallel sections private( + { + foo(); + } +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel sections private(, + { + foo(); + } +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel sections private(, ) + { + foo(); + } +// expected-error@+1 {{expected expression}} +#pragma omp parallel sections private() + { + foo(); + } +// expected-error@+1 {{expected expression}} +#pragma omp parallel sections private(int) + { + foo(); + } +// expected-error@+1 {{expected variable name}} +#pragma omp parallel sections private(0) + { + foo(); + } + + int x, y, z; +#pragma omp parallel sections private(x) + { + foo(); + } +#pragma omp parallel sections private(x, y) + { + foo(); + } +#pragma omp parallel sections private(x, y, z) + { + foo(); + } +} + +void test_lastprivate() { + int i; +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp parallel sections lastprivate( + { + foo(); + } + +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel sections lastprivate(, + { + foo(); + } +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel sections lastprivate(, ) + { + foo(); + } +// expected-error@+1 {{expected expression}} +#pragma omp parallel sections lastprivate() + { + foo(); + } +// expected-error@+1 {{expected expression}} +#pragma omp parallel sections lastprivate(int) + { + foo(); + } +// expected-error@+1 {{expected variable name}} +#pragma omp parallel sections lastprivate(0) + { + foo(); + } + + int x, y, z; +#pragma omp parallel sections lastprivate(x) + { + foo(); + } +#pragma omp parallel sections lastprivate(x, y) + { + foo(); + } +#pragma omp parallel sections lastprivate(x, y, z) + { + foo(); + } +} + +void test_firstprivate() { + int i; +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp parallel sections firstprivate( + { + foo(); + } + +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel sections firstprivate(, + { + foo(); + } +// expected-error@+1 2 {{expected expression}} +#pragma omp parallel sections firstprivate(, ) + { + foo(); + } +// expected-error@+1 {{expected expression}} +#pragma omp parallel sections firstprivate() + { + foo(); + } +// expected-error@+1 {{expected expression}} +#pragma omp parallel sections firstprivate(int) + { + foo(); + } +// expected-error@+1 {{expected variable name}} +#pragma omp parallel sections firstprivate(0) + { + foo(); + } + + int x, y, z; +#pragma omp parallel sections lastprivate(x) firstprivate(x) + { + foo(); + } +#pragma omp parallel sections lastprivate(x, y) firstprivate(x, y) + { + foo(); + } +#pragma omp parallel sections lastprivate(x, y, z) firstprivate(x, y, z) + { + foo(); + } +} + diff --git a/test/OpenMP/parallel_sections_num_threads_messages.cpp b/test/OpenMP/parallel_sections_num_threads_messages.cpp new file mode 100644 index 000000000000..927e8d76d54c --- /dev/null +++ b/test/OpenMP/parallel_sections_num_threads_messages.cpp @@ -0,0 +1,63 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N> // expected-note {{declared here}} +T tmain(T argc, S **argv) { + #pragma omp parallel sections num_threads // expected-error {{expected '(' after 'num_threads'}} + {foo();} + #pragma omp parallel sections num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + {foo();} + #pragma omp parallel sections num_threads () // expected-error {{expected expression}} + {foo();} + #pragma omp parallel sections num_threads (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + {foo();} + #pragma omp parallel sections num_threads (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + {foo();} + #pragma omp parallel sections num_threads ((argc > 0) ? argv[1] : argv[2]) // expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + {foo();} + #pragma omp parallel sections num_threads (foobool(argc)), num_threads (true), num_threads (-5) // expected-error 2 {{directive '#pragma omp parallel sections' cannot contain more than one 'num_threads' clause}} expected-error {{argument to 'num_threads' clause must be a positive integer value}} + {foo();} + #pragma omp parallel sections num_threads (S) // expected-error {{'S' does not refer to a value}} + {foo();} + #pragma omp parallel sections num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error 2 {{expression must have integral or unscoped enumeration type, not 'char *'}} + {foo();} + #pragma omp parallel sections num_threads (argc) + {foo();} + #pragma omp parallel sections num_threads (N) // expected-error {{argument to 'num_threads' clause must be a positive integer value}} + {foo();} + + return argc; +} + +int main(int argc, char **argv) { + #pragma omp parallel sections num_threads // expected-error {{expected '(' after 'num_threads'}} + {foo();} + #pragma omp parallel sections num_threads ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + {foo();} + #pragma omp parallel sections num_threads () // expected-error {{expected expression}} + {foo();} + #pragma omp parallel sections num_threads (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + {foo();} + #pragma omp parallel sections num_threads (argc)) // expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + {foo();} + #pragma omp parallel sections num_threads (argc > 0 ? argv[1] : argv[2]) // expected-error {{integral }} + {foo();} + #pragma omp parallel sections num_threads (foobool(argc)), num_threads (true), num_threads (-5) // expected-error 2 {{directive '#pragma omp parallel sections' cannot contain more than one 'num_threads' clause}} expected-error {{argument to 'num_threads' clause must be a positive integer value}} + {foo();} + #pragma omp parallel sections num_threads (S1) // expected-error {{'S1' does not refer to a value}} + {foo();} + #pragma omp parallel sections num_threads (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expression must have integral or unscoped enumeration type, not 'char *'}} + {foo();} + #pragma omp parallel sections num_threads (num_threads(tmain<int, char, -1>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} expected-note {{in instantiation of function template specialization 'tmain<int, char, -1>' requested here}} + {foo();} + + return tmain<int, char, 3>(argc, argv); // expected-note {{in instantiation of function template specialization 'tmain<int, char, 3>' requested here}} +} diff --git a/test/OpenMP/parallel_sections_private_messages.cpp b/test/OpenMP/parallel_sections_private_messages.cpp new file mode 100644 index 000000000000..7d39c7e2c5bb --- /dev/null +++ b/test/OpenMP/parallel_sections_private_messages.cpp @@ -0,0 +1,204 @@ +// 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 parallel sections private // expected-error {{expected '(' after 'private'}} + { + foo(); + } +#pragma omp parallel sections private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections private() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel sections private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections private(argc) + { + foo(); + } +#pragma omp parallel sections private(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel sections private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp parallel sections private(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections private(e, g) + { + foo(); + } +#pragma omp parallel sections private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + { + foo(); + } +#pragma omp parallel sections copyprivate(h) // expected-error {{unexpected OpenMP clause 'copyprivate' in directive '#pragma omp parallel sections'}} + { + foo(); + } +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp parallel sections private(i) + { + foo(); + } + v += i; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel sections private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel sections 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 parallel sections private // expected-error {{expected '(' after 'private'}} + { + foo(); + } +#pragma omp parallel sections private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections private() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel sections private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections private(argc) + { + foo(); + } +#pragma omp parallel sections private(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel sections private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp parallel sections private(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} + { + foo(); + } +#pragma omp parallel sections private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + { + foo(); + } +#pragma omp parallel sections copyprivate(h) // expected-error {{unexpected OpenMP clause 'copyprivate' in directive '#pragma omp parallel sections'}} + { + foo(); + } +#pragma omp parallel + { + int i; +#pragma omp parallel sections private(i) + { + foo(); + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp parallel sections private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel sections private(i) + { + foo(); + } + + return 0; +} + diff --git a/test/OpenMP/parallel_sections_proc_bind_messages.cpp b/test/OpenMP/parallel_sections_proc_bind_messages.cpp new file mode 100644 index 000000000000..9e58a734efb0 --- /dev/null +++ b/test/OpenMP/parallel_sections_proc_bind_messages.cpp @@ -0,0 +1,28 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo(); + +int main(int argc, char **argv) { +#pragma omp parallel sections proc_bind // expected-error {{expected '(' after 'proc_bind'}} + { foo(); } +#pragma omp parallel sections proc_bind( // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { foo(); } +#pragma omp parallel sections proc_bind() // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} + { foo(); } +#pragma omp parallel sections proc_bind(master // expected-error {{expected ')'}} expected-note {{to match this '('}} + { foo(); } +#pragma omp parallel sections proc_bind(close), proc_bind(spread) // expected-error {{directive '#pragma omp parallel sections' cannot contain more than one 'proc_bind' clause}} + { foo(); } +#pragma omp parallel sections proc_bind(x) // expected-error {{expected 'master', 'close' or 'spread' in OpenMP clause 'proc_bind'}} + { foo(); } + +#pragma omp parallel sections proc_bind(master) + { ++argc; } + +#pragma omp parallel sections proc_bind(close) + { +#pragma omp parallel sections proc_bind(spread) + { ++argc; } + } + return 0; +} diff --git a/test/OpenMP/parallel_sections_reduction_messages.cpp b/test/OpenMP/parallel_sections_reduction_messages.cpp new file mode 100644 index 000000000000..8b02f2315c9d --- /dev/null +++ b/test/OpenMP/parallel_sections_reduction_messages.cpp @@ -0,0 +1,358 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + S2 &operator+=(const S2 &arg) { return (*this); } + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note 2 {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}} +S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; // expected-note 2 {{'ba' defined here}} +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} + S3 operator+=(const S3 &arg1) { return arg1; } +}; +int operator+=(const S3 &arg1, const S3 &arg2) { return 5; } +S3 c; // expected-note 2 {{'c' defined here}} +const S3 ca[5]; // expected-note 2 {{'ca' defined here}} +extern const int f; // expected-note 4 {{'f' declared here}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + S4 &operator+=(const S4 &arg) { return (*this); } + +public: + S4(int v) : a(v) {} +}; +S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; } +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + S5 &operator+=(const S5 &arg); + +public: + S5(int v) : a(v) {} +}; +class S6 { + int a; + +public: + S6() : a(6) {} + operator int() { return 6; } +} o; // expected-note 2 {{'o' defined here}} + +S3 h, k; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class T> // expected-note {{declared here}} +T tmain(T argc) { // expected-note 2 {{'argc' defined here}} + const T d = T(); // expected-note 4 {{'d' defined here}} + const T da[5] = {T()}; // expected-note 2 {{'da' defined here}} + T qa[5] = {T()}; + T i; + T &j = i; // expected-note 4 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}} + T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}} + T fl; // expected-note {{'fl' defined here}} +#pragma omp parallel sections reduction // expected-error {{expected '(' after 'reduction'}} + { + foo(); + } +#pragma omp parallel sections reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } +#pragma omp parallel sections reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + { + foo(); + } +#pragma omp parallel sections reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel sections reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + { + foo(); + } +#pragma omp parallel sections reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel sections reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel sections reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + { + foo(); + } +#pragma omp parallel sections reduction(&& : argc) + { + foo(); + } +#pragma omp parallel sections reduction(^ : T) // expected-error {{'T' does not refer to a value}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(max : qa[1]) // expected-error 2 {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + { + foo(); + } +#pragma omp parallel sections reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + { + foo(); + } +#pragma omp parallel sections reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}} + { + foo(); + } +#pragma omp parallel sections reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel sections reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel sections private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel private(k) +#pragma omp parallel sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp parallel sections reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel private(fl) +#pragma omp parallel sections reduction(+ : fl) + { + foo(); + } +#pragma omp parallel reduction(* : fl) +#pragma omp parallel sections reduction(+ : fl) + { + foo(); + } + + return T(); +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note 2 {{'d' defined here}} + const int da[5] = {0}; // expected-note {{'da' defined here}} + int qa[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note 2 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const int &r = da[i]; // expected-note {{'r' defined here}} + int &q = qa[i]; // expected-note {{'q' defined here}} + float fl; // expected-note {{'fl' defined here}} +#pragma omp parallel sections reduction // expected-error {{expected '(' after 'reduction'}} + { + foo(); + } +#pragma omp parallel sections reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp parallel sections' are ignored}} + { + foo(); + } +#pragma omp parallel sections reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + { + foo(); + } +#pragma omp parallel sections reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel sections reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + { + foo(); + } +#pragma omp parallel sections reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + { + foo(); + } +#pragma omp parallel sections reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel sections reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections reduction(~ : argc) // expected-error {{expected unqualified-id}} + { + foo(); + } +#pragma omp parallel sections reduction(&& : argc) + { + foo(); + } +#pragma omp parallel sections reduction(^ : S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(max : argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + { + foo(); + } +#pragma omp parallel sections reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + { + foo(); + } +#pragma omp parallel sections reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} + { + foo(); + } +#pragma omp parallel sections reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel sections reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel sections private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel private(k) +#pragma omp parallel sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} + { + foo(); + } +#pragma omp parallel sections reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp parallel sections reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel private(fl) +#pragma omp parallel sections reduction(+ : fl) + { + foo(); + } +#pragma omp parallel reduction(* : fl) +#pragma omp parallel sections reduction(+ : fl) + { + foo(); + } + + return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}} +} diff --git a/test/OpenMP/parallel_sections_shared_messages.cpp b/test/OpenMP/parallel_sections_shared_messages.cpp new file mode 100644 index 000000000000..d4915c8eaa45 --- /dev/null +++ b/test/OpenMP/parallel_sections_shared_messages.cpp @@ -0,0 +1,110 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} +}; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; +const S3 ca[5]; +extern const int f; +class S4 { + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + +public: + S5(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note {{defined as threadprivate or thread local}} + +int main(int argc, char **argv) { + const int d = 5; + const int da[5] = {0}; + S4 e(4); + S5 g(5); + int i; + int &j = i; +#pragma omp parallel sections shared // expected-error {{expected '(' after 'shared'}} + { foo(); } +#pragma omp parallel sections shared( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { foo(); } +#pragma omp parallel sections shared() // expected-error {{expected expression}} + { foo(); } +#pragma omp parallel sections shared(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { foo(); } +#pragma omp parallel sections shared(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { foo(); } +#pragma omp parallel sections shared(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { foo(); } +#pragma omp parallel sections shared(argc) + { foo(); } +#pragma omp parallel sections shared(S1) // expected-error {{'S1' does not refer to a value}} + { foo(); } +#pragma omp parallel sections shared(a, b, c, d, f) + { foo(); } +#pragma omp parallel sections shared(argv[1]) // expected-error {{expected variable name}} + { foo(); } +#pragma omp parallel sections shared(ba) + { foo(); } +#pragma omp parallel sections shared(ca) + { foo(); } +#pragma omp parallel sections shared(da) + { foo(); } +#pragma omp parallel sections shared(e, g) + { foo(); } +#pragma omp parallel sections shared(h) // expected-error {{threadprivate or thread local variable cannot be shared}} + { foo(); } +#pragma omp parallel sections private(i), shared(i) // expected-error {{private variable cannot be shared}} expected-note {{defined as private}} + { foo(); } +#pragma omp parallel sections firstprivate(i), shared(i) // expected-error {{firstprivate variable cannot be shared}} expected-note {{defined as firstprivate}} + { foo(); } +#pragma omp parallel sections private(i) + { +#pragma omp parallel sections shared(i) + { +#pragma omp parallel sections shared(j) + { foo(); } + } + } +#pragma omp parallel sections firstprivate(i) + { +#pragma omp parallel sections shared(i) + { +#pragma omp parallel sections shared(j) + { foo(); } + } + } + + return 0; +} diff --git a/test/OpenMP/parallel_shared_messages.cpp b/test/OpenMP/parallel_shared_messages.cpp index 211d392fe04e..8363989439be 100644 --- a/test/OpenMP/parallel_shared_messages.cpp +++ b/test/OpenMP/parallel_shared_messages.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s void foo() { } diff --git a/test/OpenMP/predefined_macro.c b/test/OpenMP/predefined_macro.c index 3a8118620962..c9829ce4572a 100644 --- a/test/OpenMP/predefined_macro.c +++ b/test/OpenMP/predefined_macro.c @@ -1,32 +1,32 @@ -// RUN: %clang_cc1 -fopenmp -verify -DFOPENMP -o - %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -verify -DFOPENMP -o - %s // RUN: %clang_cc1 -verify -o - %s // expected-no-diagnostics #ifdef FOPENMP -// -fopenmp option is specified +// -fopenmp=libiomp5 option is specified #ifndef _OPENMP #error "No _OPENMP macro is defined with -fopenmp option" -#elsif _OPENMP != 201107 +#elsif _OPENMP != 201307 #error "_OPENMP has incorrect value" #endif //_OPENMP #else -// No -fopenmp option is specified +// No -fopenmp=libiomp5 option is specified #ifdef _OPENMP #error "_OPENMP macro is defined without -fopenmp option" #endif // _OPENMP #endif // FOPENMP -// RUN: %clang_cc1 -fopenmp -verify -DFOPENMP -o - %s +// RUN: %clang_cc1 -fopenmp=libiomp5 -verify -DFOPENMP -o - %s // RUN: %clang_cc1 -verify -o - %s // expected-no-diagnostics #ifdef FOPENMP -// -fopenmp option is specified +// -fopenmp=libiomp5 option is specified #ifndef _OPENMP #error "No _OPENMP macro is defined with -fopenmp option" -#elsif _OPENMP != 201107 +#elsif _OPENMP != 201307 #error "_OPENMP has incorrect value" #endif // _OPENMP #else -// No -fopenmp option is specified +// No -fopenmp=libiomp5 option is specified #ifdef _OPENMP #error "_OPENMP macro is defined without -fopenmp option" #endif // _OPENMP diff --git a/test/OpenMP/sections_ast_print.cpp b/test/OpenMP/sections_ast_print.cpp new file mode 100644 index 000000000000..b1a2e0304001 --- /dev/null +++ b/test/OpenMP/sections_ast_print.cpp @@ -0,0 +1,52 @@ +// 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 sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction(- : g) nowait + { + foo(); + } + // CHECK-NEXT: #pragma omp parallel + // CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(c,d) lastprivate(d,f) reduction(-: g) nowait + // CHECK-NEXT: { + // CHECK-NEXT: foo(); + // CHECK-NEXT: } + 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 sections private(argc, b), firstprivate(argv, c), lastprivate(d, f) reduction(+ : g) nowait + { +#pragma omp section + foo(); +#pragma omp section + foo(); + } + // CHECK-NEXT: #pragma omp parallel + // CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(argv,c) lastprivate(d,f) reduction(+: g) nowait + // CHECK-NEXT: { + // CHECK-NEXT: #pragma omp section + // CHECK-NEXT: foo(); + // CHECK-NEXT: #pragma omp section + // CHECK-NEXT: foo(); + // CHECK-NEXT: } + return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0])); +} + +#endif diff --git a/test/OpenMP/sections_firstprivate_messages.cpp b/test/OpenMP/sections_firstprivate_messages.cpp new file mode 100644 index 000000000000..b030ce549d33 --- /dev/null +++ b/test/OpenMP/sections_firstprivate_messages.cpp @@ -0,0 +1,335 @@ +// 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 sections firstprivate // expected-error {{expected '(' after 'firstprivate'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argc) + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(a, b) // expected-error {{firstprivate variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp sections'}} + { + 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 sections' directive into a parallel or another task region?}} +#pragma omp sections firstprivate(i) // expected-error {{private variable cannot be firstprivate}} + { + foo(); + } + v += i; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp sections firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(i) + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(g) 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 sections firstprivate(i) // expected-error {{firstprivate variable must be shared}} + { + foo(); + } +#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}} +#pragma omp sections 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 sections firstprivate // expected-error {{expected '(' after 'firstprivate'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argc) + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(2 * 2) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(ba) // OK + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(ca) // OK + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(da) // OK + { + foo(); + } + int xa; +#pragma omp parallel +#pragma omp sections firstprivate(xa) // OK + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(S2::S2s) // OK + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(S2::S2sc) // OK + { + foo(); + } +#pragma omp parallel +#pragma omp sections safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp sections'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(m) // OK + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections private(xa), firstprivate(xa) // expected-error {{private variable cannot be firstprivate}} expected-note {{defined as private}} + { + foo(); + } +#pragma omp parallel shared(xa) +#pragma omp sections firstprivate(xa) // OK: may be firstprivate + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(g) firstprivate(g) // expected-error {{firstprivate variable must have an accessible, unambiguous copy constructor}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(n) 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 sections' directive into a parallel or another task region?}} +#pragma omp sections firstprivate(i) // expected-error {{private variable cannot be firstprivate}} + { + foo(); + } + v += i; + } +#pragma omp parallel private(i) // expected-note {{defined as private}} +#pragma omp sections firstprivate(i) // expected-error {{firstprivate variable must be shared}} + { + foo(); + } +#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}} +#pragma omp sections 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/sections_lastprivate_messages.cpp b/test/OpenMP/sections_lastprivate_messages.cpp new file mode 100644 index 000000000000..54c6005dcef3 --- /dev/null +++ b/test/OpenMP/sections_lastprivate_messages.cpp @@ -0,0 +1,309 @@ +// 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; // expected-note {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}} +const S2 b; +const S2 ba[5]; +class S3 { // expected-note 2 {{'S3' declared here}} + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} +class S4 { // expected-note 3 {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + +public: + S5(const S5 &s5) : a(s5.a) {} + 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}} + I g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp sections lastprivate // expected-error {{expected '(' after 'lastprivate'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argc) + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp sections'}} + { + 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 sections' directive into a parallel or another task region?}} +#pragma omp sections lastprivate(i) // expected-error {{lastprivate variable must be shared}} + { + foo(); + } + v += i; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp sections lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(i) + { + foo(); + } + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}} + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + S3 m; // expected-note 2 {{'m' defined here}} + S6 n(2); + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp parallel +#pragma omp sections lastprivate // expected-error {{expected '(' after 'lastprivate'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argc) + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(a, b, c, d, f) // expected-error {{lastprivate variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(2 * 2) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(ba) + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(ca) // expected-error {{shared variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(da) // expected-error {{shared variable cannot be lastprivate}} + { + foo(); + } + int xa; +#pragma omp parallel +#pragma omp sections lastprivate(xa) // OK + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp sections'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(i) + { + foo(); + } +#pragma omp parallel private(xa) // expected-note {{defined as private}} +#pragma omp sections lastprivate(xa) // expected-error {{lastprivate variable must be shared}} + { + foo(); + } +#pragma omp parallel reduction(+ : xa) // expected-note {{defined as reduction}} +#pragma omp sections lastprivate(xa) // expected-error {{lastprivate variable must be shared}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(n) firstprivate(n) // OK + { + 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/sections_misc_messages.c b/test/OpenMP/sections_misc_messages.c new file mode 100644 index 000000000000..0297513543a9 --- /dev/null +++ b/test/OpenMP/sections_misc_messages.c @@ -0,0 +1,299 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s + +void foo(); + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp sections'}} +#pragma omp sections + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp sections'}} +#pragma omp sections foo + +void test_no_clause() { + int i; +#pragma omp sections + { + foo(); + } + +// expected-error@+2 {{the statement for '#pragma omp sections' must be a compound statement}} +#pragma omp sections + ++i; + +#pragma omp sections + { + foo(); + foo(); // expected-error {{statement in 'omp sections' directive must be enclosed into a section region}} + } +} + +void test_branch_protected_scope() { + int i = 0; +L1: + ++i; + + int x[24]; + +#pragma omp parallel +#pragma omp sections + { + 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]++; + } +#pragma omp section + 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 L3; + else if (i == 8) { + L3: + x[i]++; + } + } + + if (x[0] == 0) + goto L2; // expected-error {{use of undeclared label 'L2'}} + else if (x[1] == 1) + goto L1; + goto L3; // expected-error {{use of undeclared label 'L3'}} +} + +void test_invalid_clause() { + int i; +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}} +#pragma omp sections foo bar + { + foo(); +// expected-error@+1 {{unexpected OpenMP clause 'nowait' in directive '#pragma omp section'}} +#pragma omp section nowait + ; + } +} + +void test_non_identifiers() { + int i, x; + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}} +#pragma omp sections; + { + foo(); + } +#pragma omp parallel +// expected-error@+2 {{unexpected OpenMP clause 'linear' in directive '#pragma omp sections'}} +// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}} +#pragma omp sections linear(x); + { + foo(); + } + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}} +#pragma omp sections private(x); + { + foo(); + } + +#pragma omp parallel +// expected-warning@+1 {{extra tokens at the end of '#pragma omp sections' are ignored}} +#pragma omp sections, 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 sections private( + { + foo(); + } +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp sections private(, + { + foo(); + } +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp sections private(, ) + { + foo(); + } +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp sections private() + { + foo(); + } +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp sections private(int) + { + foo(); + } +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp sections private(0) + { + foo(); + } + + int x, y, z; +#pragma omp parallel +#pragma omp sections private(x) + { + foo(); + } +#pragma omp parallel +#pragma omp sections private(x, y) + { + foo(); + } +#pragma omp parallel +#pragma omp sections private(x, y, z) + { + foo(); + } +} + +void test_lastprivate() { + int i; +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 {{expected expression}} +#pragma omp sections lastprivate( + { + foo(); + } + +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp sections lastprivate(, + { + foo(); + } +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp sections lastprivate(, ) + { + foo(); + } +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp sections lastprivate() + { + foo(); + } +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp sections lastprivate(int) + { + foo(); + } +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp sections lastprivate(0) + { + foo(); + } + + int x, y, z; +#pragma omp parallel +#pragma omp sections lastprivate(x) + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(x, y) + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(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 sections firstprivate( + { + foo(); + } + +#pragma omp parallel +// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} +// expected-error@+1 2 {{expected expression}} +#pragma omp sections firstprivate(, + { + foo(); + } +#pragma omp parallel +// expected-error@+1 2 {{expected expression}} +#pragma omp sections firstprivate(, ) + { + foo(); + } +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp sections firstprivate() + { + foo(); + } +#pragma omp parallel +// expected-error@+1 {{expected expression}} +#pragma omp sections firstprivate(int) + { + foo(); + } +#pragma omp parallel +// expected-error@+1 {{expected variable name}} +#pragma omp sections firstprivate(0) + { + foo(); + } + + int x, y, z; +#pragma omp parallel +#pragma omp sections lastprivate(x) firstprivate(x) + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(x, y) firstprivate(x, y) + { + foo(); + } +#pragma omp parallel +#pragma omp sections lastprivate(x, y, z) firstprivate(x, y, z) + { + foo(); + } +} + +void test_nowait() { +#pragma omp parallel +#pragma omp sections nowait nowait // expected-error {{directive '#pragma omp sections' cannot contain more than one 'nowait' clause}} + { + ; + } +} diff --git a/test/OpenMP/sections_private_messages.cpp b/test/OpenMP/sections_private_messages.cpp new file mode 100644 index 000000000000..7f5aa849682a --- /dev/null +++ b/test/OpenMP/sections_private_messages.cpp @@ -0,0 +1,204 @@ +// 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 sections private // expected-error {{expected '(' after 'private'}} + { + foo(); + } +#pragma omp sections private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp sections private() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp sections private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp sections private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp sections private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp sections private(argc) + { + foo(); + } +#pragma omp sections private(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp sections private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp sections private(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp sections private(e, g) + { + foo(); + } +#pragma omp sections private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + { + foo(); + } +#pragma omp sections shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp sections'}} + { + foo(); + } +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp sections private(i) + { + foo(); + } + v += i; + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp sections private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + { + foo(); + } +#pragma omp sections 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 sections private // expected-error {{expected '(' after 'private'}} + { + foo(); + } +#pragma omp sections private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp sections private() // expected-error {{expected expression}} + { + foo(); + } +#pragma omp sections private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp sections private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp sections private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp sections private(argc) + { + foo(); + } +#pragma omp sections private(S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp sections private(a, b) // expected-error {{private variable with incomplete type 'S1'}} + { + foo(); + } +#pragma omp sections private(argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp sections private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} + { + foo(); + } +#pragma omp sections private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + { + foo(); + } +#pragma omp sections shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp sections'}} + { + foo(); + } +#pragma omp parallel + { + int i; +#pragma omp sections private(i) + { + foo(); + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp sections private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + { + foo(); + } +#pragma omp sections private(i) + { + foo(); + } + + return 0; +} + diff --git a/test/OpenMP/sections_reduction_messages.cpp b/test/OpenMP/sections_reduction_messages.cpp new file mode 100644 index 000000000000..8c4bdcc2e8fc --- /dev/null +++ b/test/OpenMP/sections_reduction_messages.cpp @@ -0,0 +1,413 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + S2 &operator+=(const S2 &arg) { return (*this); } + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note 2 {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}} +S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; // expected-note 2 {{'ba' defined here}} +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} + S3 operator+=(const S3 &arg1) { return arg1; } +}; +int operator+=(const S3 &arg1, const S3 &arg2) { return 5; } +S3 c; // expected-note 2 {{'c' defined here}} +const S3 ca[5]; // expected-note 2 {{'ca' defined here}} +extern const int f; // expected-note 4 {{'f' declared here}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + S4 &operator+=(const S4 &arg) { return (*this); } + +public: + S4(int v) : a(v) {} +}; +S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; } +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + S5 &operator+=(const S5 &arg); + +public: + S5(int v) : a(v) {} +}; +class S6 { + int a; + +public: + S6() : a(6) {} + operator int() { return 6; } +} o; // expected-note 2 {{'o' defined here}} + +S3 h, k; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class T> // expected-note {{declared here}} +T tmain(T argc) { // expected-note 2 {{'argc' defined here}} + const T d = T(); // expected-note 4 {{'d' defined here}} + const T da[5] = {T()}; // expected-note 2 {{'da' defined here}} + T qa[5] = {T()}; + T i; + T &j = i; // expected-note 4 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}} + T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}} + T fl; // expected-note {{'fl' defined here}} +#pragma omp parallel +#pragma omp sections reduction // expected-error {{expected '(' after 'reduction'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp sections' are ignored}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(&& : argc) + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(^ : T) // expected-error {{'T' does not refer to a value}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(max : qa[1]) // expected-error 2 {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel private(k) +#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp sections reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel private(fl) // expected-note 2 {{defined as private}} +#pragma omp sections reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}} + { + foo(); + } +#pragma omp parallel reduction(* : fl) // expected-note 2 {{defined as reduction}} +#pragma omp sections reduction(+ : fl) // expected-error 2 {{reduction variable must be shared}} + { + foo(); + } + + return T(); +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note 2 {{'d' defined here}} + const int da[5] = {0}; // expected-note {{'da' defined here}} + int qa[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note 2 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const int &r = da[i]; // expected-note {{'r' defined here}} + int &q = qa[i]; // expected-note {{'q' defined here}} + float fl; // expected-note {{'fl' defined here}} +#pragma omp parallel +#pragma omp sections reduction // expected-error {{expected '(' after 'reduction'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp sections' are ignored}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(~ : argc) // expected-error {{expected unqualified-id}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(&& : argc) + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(^ : S1) // expected-error {{'S1' does not refer to a value}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(max : argv[1]) // expected-error {{expected variable name}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel private(k) +#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} + { + foo(); + } +#pragma omp parallel +#pragma omp sections reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}} + { + foo(); + } +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp sections reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + { + foo(); + } +#pragma omp parallel private(fl) // expected-note {{defined as private}} +#pragma omp sections reduction(+ : fl) // expected-error {{reduction variable must be shared}} + { + foo(); + } +#pragma omp parallel reduction(* : fl) // expected-note {{defined as reduction}} +#pragma omp sections reduction(+ : fl) // expected-error {{reduction variable must be shared}} + { + foo(); + } + + return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}} +} diff --git a/test/OpenMP/simd_aligned_messages.cpp b/test/OpenMP/simd_aligned_messages.cpp new file mode 100644 index 000000000000..84cf40c1731b --- /dev/null +++ b/test/OpenMP/simd_aligned_messages.cpp @@ -0,0 +1,201 @@ +// RUN: %clang_cc1 -x c++ -std=c++11 -verify -fopenmp=libiomp5 %s + +struct B { + static int ib[20]; // expected-note 0 {{'B::ib' declared here}} + static constexpr int bfoo() { return 8; } +}; +namespace X { + B x; // expected-note {{'x' defined here}} +}; +constexpr int bfoo() { return 4; } + +int **z; +const int C1 = 1; +const int C2 = 2; +void test_aligned_colons(int *&rp) +{ + int *B = 0; + #pragma omp simd aligned(B:bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'}} + #pragma omp simd aligned(B::ib:B:bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp simd aligned(B:B::bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'?}} + #pragma omp simd aligned(z:B:bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp simd aligned(B:B::bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+2 {{integral constant expression must have integral or unscoped enumeration type, not 'int **'}} + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'B'}} + #pragma omp simd aligned(X::x : ::z) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{integral constant expression must have integral or unscoped enumeration type, not 'B'}} + #pragma omp simd aligned(B,rp,::z: X::x) + for (int i = 0; i < 10; ++i) ; + #pragma omp simd aligned(::z) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp simd aligned(B::bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp simd aligned(B::ib,B:C1+C2) + for (int i = 0; i < 10; ++i) ; +} + +// expected-note@+1 {{'num' defined here}} +template<int L, class T, class N> T test_template(T* arr, N num) { + N i; + T sum = (T)0; + T ind2 = - num * L; + // Negative number is passed as L. + // expected-error@+1 {{argument to 'aligned' clause must be a positive integer value}} + #pragma omp simd aligned(arr:L) + for (i = 0; i < num; ++i) { + T cur = arr[(int)ind2]; + ind2 += L; + sum += cur; + } + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp simd aligned(num:4) + for (i = 0; i < num; ++i); + return T(); +} + +template<int LEN> int test_warn() { + int *ind2 = 0; + // expected-error@+1 {{argument to 'aligned' clause must be a positive integer value}} + #pragma omp simd aligned(ind2:LEN) + for (int i = 0; i < 100; i++) { + ind2 += LEN; + } + return 0; +} + +struct S1; // expected-note 2 {{declared here}} +extern S1 a; // expected-note {{'a' declared here}} +class S2 { + mutable int a; +public: + S2():a(0) { } +}; +const S2 b; // expected-note 1 {{'b' defined here}} +const S2 ba[5]; +class S3 { + int a; +public: + S3():a(0) { } +}; +const S3 ca[5]; +class S4 { + int a; + S4(); +public: + S4(int v):a(v) { } +}; +class S5 { + int a; + S5():a(0) {} +public: + S5(int v):a(v) { } +}; + +S3 h; // expected-note 2 {{'h' defined here}} +#pragma omp threadprivate(h) + +template<class I, class C> int foomain(I argc, C **argv) { + I e(argc); + I g(argc); + int i; // expected-note {{declared here}} expected-note {{'i' defined here}} + // expected-note@+2 {{declared here}} + // expected-note@+1 {{reference to 'i' is not a constant expression}} + int &j = i; + #pragma omp simd aligned // expected-error {{expected '(' after 'aligned'}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned () // expected-error {{expected expression}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (argc : 5) + for (I k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (S1) // expected-error {{'S1' does not refer to a value}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (argv[1]) // expected-error {{expected variable name}} + for (I k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned(e, g) + for (I k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}} + #pragma omp simd aligned(h) + for (I k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp simd aligned(i) + for (I k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int *v = 0; + I i; + #pragma omp simd aligned(v:16) + for (I k = 0; k < argc; ++k) { i = k; v += 2; } + } + float *f; + #pragma omp simd aligned(f) + for (I k = 0; k < argc; ++k) ++k; + int v = 0; + // expected-note@+2 {{initializer of 'j' is not a constant expression}} + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp simd aligned(f:j) + for (I k = 0; k < argc; ++k) { ++k; v += j; } + #pragma omp simd aligned(f) + for (I k = 0; k < argc; ++k) ++k; + return 0; +} + +// expected-note@+1 2 {{'argc' defined here}} +int main(int argc, char **argv) { + double darr[100]; + // expected-note@+1 {{in instantiation of function template specialization 'test_template<-4, double, int>' requested here}} + test_template<-4>(darr, 4); + test_warn<4>(); // ok + // expected-note@+1 {{in instantiation of function template specialization 'test_warn<0>' requested here}} + test_warn<0>(); + + int i; + int &j = i; + #pragma omp simd aligned // expected-error {{expected '(' after 'aligned'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (argv // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}} + #pragma omp simd aligned (argc) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S1'}} + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S2'}} + #pragma omp simd aligned (a, b) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd aligned (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}} + #pragma omp simd aligned(h) + for (int k = 0; k < argc; ++k) ++k; + int *pargc = &argc; + foomain<int*,char>(pargc,argv); + return 0; +} + diff --git a/test/OpenMP/simd_ast_print.cpp b/test/OpenMP/simd_ast_print.cpp new file mode 100644 index 000000000000..46286123750d --- /dev/null +++ b/test/OpenMP/simd_ast_print.cpp @@ -0,0 +1,126 @@ +// 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() {} +int g_ind = 1; +template<class T, class N> T reduct(T* arr, N num) { + N i; + N ind; + N myind; + T sum = (T)0; +// CHECK: T sum = (T)0; +#pragma omp simd private(myind, g_ind), linear(ind), aligned(arr) +// CHECK-NEXT: #pragma omp simd private(myind,g_ind) linear(ind) aligned(arr) + for (i = 0; i < num; ++i) { + myind = ind; + T cur = arr[myind]; + ind += g_ind; + sum += cur; + } +} + +template<class T> struct S { + S(const T &a) + :m_a(a) + {} + T result(T *v) const { + T res; + T val; + T lin = 0; +// CHECK: T res; +// CHECK: T val; +// CHECK: T lin = 0; + #pragma omp simd private(val) safelen(7) linear(lin : -5) lastprivate(res) +// CHECK-NEXT: #pragma omp simd private(val) safelen(7) linear(lin: -5) lastprivate(res) + for (T i = 7; i < m_a; ++i) { + val = v[i-7] + m_a; + res = val; + lin -= 5; + } + const T clen = 3; +// CHECK: T clen = 3; + #pragma omp simd safelen(clen-1) +// CHECK-NEXT: #pragma omp simd safelen(clen - 1) + for(T i = clen+2; i < 20; ++i) { +// CHECK-NEXT: for (T i = clen + 2; i < 20; ++i) { + v[i] = v[v-clen] + 1; +// CHECK-NEXT: v[i] = v[v - clen] + 1; + } +// CHECK-NEXT: } + return res; + } + ~S() + {} + T m_a; +}; + +template<int LEN> struct S2 { + static void func(int n, float *a, float *b, float *c) { + int k1 = 0, k2 = 0; +#pragma omp simd safelen(LEN) linear(k1,k2:LEN) aligned(a:LEN) + for(int i = 0; i < n; i++) { + c[i] = a[i] + b[i]; + c[k1] = a[k1] + b[k1]; + c[k2] = a[k2] + b[k2]; + k1 = k1 + LEN; + k2 = k2 + LEN; + } + } +}; + +// S2<4>::func is called below in main. +// CHECK: template <int LEN = 4> struct S2 { +// CHECK-NEXT: static void func(int n, float *a, float *b, float *c) { +// CHECK-NEXT: int k1 = 0, k2 = 0; +// CHECK-NEXT: #pragma omp simd safelen(4) linear(k1,k2: 4) aligned(a: 4) +// CHECK-NEXT: for (int i = 0; i < n; i++) { +// CHECK-NEXT: c[i] = a[i] + b[i]; +// CHECK-NEXT: c[k1] = a[k1] + b[k1]; +// CHECK-NEXT: c[k2] = a[k2] + b[k2]; +// CHECK-NEXT: k1 = k1 + 4; +// CHECK-NEXT: k2 = k2 + 4; +// CHECK-NEXT: } +// CHECK-NEXT: } + +int main (int argc, char **argv) { + int b = argc, c, d, e, f, g; + int k1=0,k2=0; + static int *a; +// CHECK: static int *a; +#pragma omp simd +// CHECK-NEXT: #pragma omp simd + for (int i=0; i < 2; ++i)*a=2; +// CHECK-NEXT: for (int i = 0; i < 2; ++i) +// CHECK-NEXT: *a = 2; +#pragma omp simd private(argc, b),lastprivate(d,f) collapse(2) aligned(a : 4) + for (int i = 0; i < 10; ++i) + for (int j = 0; j < 10; ++j) {foo(); k1 += 8; k2 += 8;} +// CHECK-NEXT: #pragma omp simd private(argc,b) lastprivate(d,f) collapse(2) aligned(a: 4) +// CHECK-NEXT: for (int i = 0; i < 10; ++i) +// CHECK-NEXT: for (int j = 0; j < 10; ++j) { +// CHECK-NEXT: foo(); +// CHECK-NEXT: k1 += 8; +// CHECK-NEXT: k2 += 8; +// CHECK-NEXT: } + for (int i = 0; i < 10; ++i)foo(); +// CHECK-NEXT: for (int i = 0; i < 10; ++i) +// CHECK-NEXT: foo(); + const int CLEN = 4; +// CHECK-NEXT: const int CLEN = 4; + #pragma omp simd aligned(a:CLEN) linear(a:CLEN) safelen(CLEN) collapse( 1 ) +// CHECK-NEXT: #pragma omp simd aligned(a: CLEN) linear(a: CLEN) safelen(CLEN) collapse(1) + for (int i = 0; i < 10; ++i)foo(); +// CHECK-NEXT: for (int i = 0; i < 10; ++i) +// CHECK-NEXT: foo(); + + float arr[16]; + S2<4>::func(0,arr,arr,arr); + return (0); +} + +#endif diff --git a/test/OpenMP/simd_collapse_messages.cpp b/test/OpenMP/simd_collapse_messages.cpp new file mode 100644 index 000000000000..56523b33726c --- /dev/null +++ b/test/OpenMP/simd_collapse_messages.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { //expected-note 2 {{declared here}} + #pragma omp simd collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd collapse () // expected-error {{expected expression}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 2 {{expression is not an integral constant expression}} + // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}} + #pragma omp simd collapse (argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp simd collapse (ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd collapse (1)) // expected-warning {{extra tokens at the end of '#pragma omp simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd collapse ((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'collapse' clause}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp simd', but found only 1}} + // expected-error@+3 2 {{directive '#pragma omp simd' cannot contain more than one 'collapse' clause}} + // expected-error@+2 2 {{argument to 'collapse' clause must be a positive integer value}} + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp simd collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd collapse (S) // expected-error {{'S' does not refer to a value}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp simd collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd collapse (1) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd collapse (N) // expected-error {{argument to 'collapse' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp simd'}} + return argc; +} + +int main(int argc, char **argv) { + #pragma omp simd collapse // expected-error {{expected '(' after 'collapse'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd collapse () // expected-error {{expected expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd collapse (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} + #pragma omp simd collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp simd' are ignored}} expected-note {{as specified in 'collapse' clause}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} + #pragma omp simd collapse (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{expression is not an integral constant expression}} + // expected-error@+2 2 {{directive '#pragma omp simd' cannot contain more than one 'collapse' clause}} + // expected-error@+1 2 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp simd collapse (foobool(argc)), collapse (true), collapse (-5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd collapse (S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp simd collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd collapse (2) // expected-note {{as specified in 'collapse' clause}} + foo(); // expected-error {{expected 2 for loops after '#pragma omp simd'}} + // expected-error@+3 {{statement after '#pragma omp simd' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp simd collapse(collapse(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} + foo(); + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}} + return tmain<int, char, 1, 0>(argc, argv); +} + diff --git a/test/OpenMP/simd_lastprivate_messages.cpp b/test/OpenMP/simd_lastprivate_messages.cpp new file mode 100644 index 000000000000..55f60583506d --- /dev/null +++ b/test/OpenMP/simd_lastprivate_messages.cpp @@ -0,0 +1,208 @@ +// 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; // expected-note {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}} +const S2 b; +const S2 ba[5]; +class S3 { // expected-note {{'S3' declared here}} + int a; + S3 &operator=(const S3 &s3); + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + +public: + S5(const S5 &s5) : a(s5.a) {} + 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 simd lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate() // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(argc) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(e, g) + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd firstprivate(i) // expected-error {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp parallel + { + int v = 0; + int i; +#pragma omp simd lastprivate(i) + for (int k = 0; k < argc; ++k) { + i = k; + v += i; + } + } +#pragma omp parallel shared(i) +#pragma omp parallel private(i) +#pragma omp simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (int k = 0; k < argc; ++k) + ++k; +#pragma omp simd lastprivate(i) + for (int k = 0; k < argc; ++k) + ++k; + return 0; +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}} + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + S3 m; // expected-note {{'m' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp simd lastprivate // expected-error {{expected '(' after 'lastprivate'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate() // expected-error {{expected expression}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(argc) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(S1) // expected-error {{'S1' does not refer to a value}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(a, b, c, d, f) // expected-error {{lastprivate variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(argv[1]) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(2 * 2) // expected-error {{expected variable name}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(ba) + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(ca) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(da) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); + int xa; +#pragma omp simd lastprivate(xa) // OK + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd firstprivate(g) // expected-error {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}} + for (i = 0; i < argc; ++i) + foo(); +#pragma omp simd lastprivate(i) // expected-note {{defined as lastprivate}} + for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp simd' directive may not be lastprivate, predetermined as linear}} + foo(); +#pragma omp parallel private(xa) +#pragma omp simd lastprivate(xa) // OK: may be lastprivate + for (i = 0; i < argc; ++i) + foo(); +#pragma omp parallel +#pragma omp simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}} + for (i = 0; i < argc; ++i) + foo(); + return 0; +} diff --git a/test/OpenMP/simd_linear_messages.cpp b/test/OpenMP/simd_linear_messages.cpp new file mode 100644 index 000000000000..b8b783107993 --- /dev/null +++ b/test/OpenMP/simd_linear_messages.cpp @@ -0,0 +1,206 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +namespace X { + int x; +}; + +struct B { + static int ib; // expected-note {{'B::ib' declared here}} + static int bfoo() { return 8; } +}; + +int bfoo() { return 4; } + +int z; +const int C1 = 1; +const int C2 = 2; +void test_linear_colons() +{ + int B = 0; + #pragma omp simd linear(B:bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'}} + #pragma omp simd linear(B::ib:B:bfoo()) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{use of undeclared identifier 'ib'; did you mean 'B::ib'}} + #pragma omp simd linear(B:ib) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'?}} + #pragma omp simd linear(z:B:ib) + for (int i = 0; i < 10; ++i) ; + #pragma omp simd linear(B:B::bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp simd linear(X::x : ::z) + for (int i = 0; i < 10; ++i) ; + #pragma omp simd linear(B,::z, X::x) + for (int i = 0; i < 10; ++i) ; + #pragma omp simd linear(::z) + for (int i = 0; i < 10; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp simd linear(B::bfoo()) + for (int i = 0; i < 10; ++i) ; + #pragma omp simd linear(B::ib,B:C1+C2) + for (int i = 0; i < 10; ++i) ; +} + +template<int L, class T, class N> T test_template(T* arr, N num) { + N i; + T sum = (T)0; + T ind2 = - num * L; // expected-note {{'ind2' defined here}} + // expected-error@+1 {{argument of a linear clause should be of integral or pointer type}} +#pragma omp simd linear(ind2:L) + for (i = 0; i < num; ++i) { + T cur = arr[(int)ind2]; + ind2 += L; + sum += cur; + } + return T(); +} + +template<int LEN> int test_warn() { + int ind2 = 0; + // expected-warning@+1 {{zero linear step (ind2 should probably be const)}} + #pragma omp simd linear(ind2:LEN) + for (int i = 0; i < 100; i++) { + ind2 += LEN; + } + return ind2; +} + +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; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; +class S3 { + int a; +public: + S3():a(0) { } +}; +const S3 ca[5]; +class S4 { + int a; + S4(); +public: + S4(int v):a(v) { } +}; +class S5 { + 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 simd linear // expected-error {{expected '(' after 'linear'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argc : 5) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{linear variable with incomplete type 'S1'}} + // expected-error@+1 {{const-qualified variable cannot be linear}} + #pragma omp simd linear (a, b:B::ib) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear(e, g) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int v = 0; + int i; + #pragma omp simd linear(v:i) + for (int k = 0; k < argc; ++k) { i = k; v += i; } + } + #pragma omp simd linear(j) // expected-error {{arguments of OpenMP clause 'linear' cannot be of reference type}} + for (int k = 0; k < argc; ++k) ++k; + int v = 0; + #pragma omp simd linear(v:j) + for (int k = 0; k < argc; ++k) { ++k; v += j; } + #pragma omp simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + return 0; +} + +int main(int argc, char **argv) { + double darr[100]; + // expected-note@+1 {{in instantiation of function template specialization 'test_template<-4, double, int>' requested here}} + test_template<-4>(darr, 4); + // expected-note@+1 {{in instantiation of function template specialization 'test_warn<0>' requested here}} + test_warn<0>(); + + 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 simd linear // expected-error {{expected '(' after 'linear'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argc) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{linear variable with incomplete type 'S1'}} + // expected-error@+1 {{const-qualified variable cannot be linear}} + #pragma omp simd linear (a, b) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + // expected-error@+2 {{argument of a linear clause should be of integral or pointer type, not 'S4'}} + // expected-error@+1 {{argument of a linear clause should be of integral or pointer type, not 'S5'}} + #pragma omp simd linear(e, g) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear(h) // expected-error {{threadprivate or thread local variable cannot be linear}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int i; + #pragma omp simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear(i : 4) + for (int k = 0; k < argc; ++k) { ++k; i += 4; } + } + #pragma omp simd linear(j) // expected-error {{arguments of OpenMP clause 'linear' cannot be of reference type 'int &'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd linear(i) + for (int k = 0; k < argc; ++k) ++k; + + foomain<int,char>(argc,argv); + return 0; +} + diff --git a/test/OpenMP/simd_loop_messages.cpp b/test/OpenMP/simd_loop_messages.cpp new file mode 100644 index 000000000000..ea663fddd9cf --- /dev/null +++ b/test/OpenMP/simd_loop_messages.cpp @@ -0,0 +1,579 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify %s + +static int sii; +#pragma omp threadprivate(sii) // expected-note {{defined as threadprivate or thread local}} + +int test_iteration_spaces() { + const int N = 100; + float a[N], b[N], c[N]; + int ii, jj, kk; + float fii; + double dii; + #pragma omp simd + for (int i = 0; i < 10; i+=1) { + c[i] = a[i] + b[i]; + } + #pragma omp simd + for (char i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } + #pragma omp simd + for (char i = 0; i < 10; i+='\1') { + c[i] = a[i] + b[i]; + } + #pragma omp simd + for (long long i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + } + // expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'double'}} + #pragma omp simd + for (long long i = 0; i < 10; i+=1.5) { + c[i] = a[i] + b[i]; + } + #pragma omp simd + for (long long i = 0; i < 'z'; i+=1u) { + c[i] = a[i] + b[i]; + } + // expected-error@+2 {{variable must be of integer or random access iterator type}} + #pragma omp simd + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } + // expected-error@+2 {{variable must be of integer or random access iterator type}} + #pragma omp simd + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } + // expected-error@+2 {{variable must be of integer or random access iterator type}} + #pragma omp simd + for (int &ref = ii; ref < 10; ref++) { + } + // expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} + #pragma omp simd + for (int i; i < 10; i++) + c[i] = a[i]; + + // expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} + #pragma omp simd + for (int i = 0, j = 0; i < 10; ++i) + c[i] = a[i]; + + // expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} + #pragma omp simd + for (;ii < 10; ++ii) + c[ii] = a[ii]; + + // expected-warning@+3 {{expression result unused}} + // expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} + #pragma omp simd + for (ii + 1;ii < 10; ++ii) + c[ii] = a[ii]; + + // expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} + #pragma omp simd + for (c[ii] = 0;ii < 10; ++ii) + c[ii] = a[ii]; + + // Ok to skip parenthesises. + #pragma omp simd + for (((ii)) = 0;ii < 10; ++ii) + c[ii] = a[ii]; + + // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} + #pragma omp simd + for (int i = 0; i; i++) + c[i] = a[i]; + + // expected-error@+3 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'i'}} + #pragma omp simd + for (int i = 0; jj < kk; ii++) + c[i] = a[i]; + + // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} + #pragma omp simd + for (int i = 0; !!i; i++) + c[i] = a[i]; + + // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} + #pragma omp simd + for (int i = 0; i != 1; i++) + c[i] = a[i]; + + // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} + #pragma omp simd + for (int i = 0; ; i++) + c[i] = a[i]; + + // Ok. + #pragma omp simd + for (int i = 11; i > 10; i--) + c[i] = a[i]; + + // Ok. + #pragma omp simd + for (int i = 0; i < 10; ++i) + c[i] = a[i]; + + // Ok. + #pragma omp simd + for (ii = 0; ii < 10; ++ii) + c[ii] = a[ii]; + + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} + #pragma omp simd + for (ii = 0; ii < 10; ++jj) + c[ii] = a[jj]; + + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} + #pragma omp simd + for (ii = 0; ii < 10; ++ ++ ii) + c[ii] = a[ii]; + + // Ok but undefined behavior (in general, cannot check that incr + // is really loop-invariant). + #pragma omp simd + for (ii = 0; ii < 10; ii = ii + ii) + c[ii] = a[ii]; + + // expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'float'}} + #pragma omp simd + for (ii = 0; ii < 10; ii = ii + 1.0f) + c[ii] = a[ii]; + + // Ok - step was converted to integer type. + #pragma omp simd + for (ii = 0; ii < 10; ii = ii + (int)1.1f) + c[ii] = a[ii]; + + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} + #pragma omp simd + for (ii = 0; ii < 10; jj = ii + 2) + c[ii] = a[ii]; + + // expected-warning@+3 {{relational comparison result unused}} + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} + #pragma omp simd + for (ii = 0; ii < 10; jj > kk + 2) + c[ii] = a[ii]; + + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} + #pragma omp simd + for (ii = 0; ii < 10;) + c[ii] = a[ii]; + + // expected-warning@+3 {{expression result unused}} + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} + #pragma omp simd + for (ii = 0; ii < 10; !ii) + c[ii] = a[ii]; + + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} + #pragma omp simd + for (ii = 0; ii < 10; ii ? ++ii : ++jj) + c[ii] = a[ii]; + + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}} + #pragma omp simd + for (ii = 0; ii < 10; ii = ii < 10) + c[ii] = a[ii]; + + // expected-note@+3 {{loop step is expected to be positive due to this condition}} + // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} + #pragma omp simd + for (ii = 0; ii < 10; ii = ii + 0) + c[ii] = a[ii]; + + // expected-note@+3 {{loop step is expected to be positive due to this condition}} + // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} + #pragma omp simd + for (ii = 0; ii < 10; ii = ii + (int)(0.8 - 0.45)) + c[ii] = a[ii]; + + // expected-note@+3 {{loop step is expected to be positive due to this condition}} + // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} + #pragma omp simd + for (ii = 0; (ii) < 10; ii-=25) + c[ii] = a[ii]; + + // expected-note@+3 {{loop step is expected to be positive due to this condition}} + // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} + #pragma omp simd + for (ii = 0; (ii < 10); ii-=0) + c[ii] = a[ii]; + + // expected-note@+3 {{loop step is expected to be negative due to this condition}} + // expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} + #pragma omp simd + for (ii = 0; ii > 10; (ii+=0)) + c[ii] = a[ii]; + + // expected-note@+3 {{loop step is expected to be positive due to this condition}} + // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} + #pragma omp simd + for (ii = 0; ii < 10; (ii) = (1-1)+(ii)) + c[ii] = a[ii]; + + // expected-note@+3 {{loop step is expected to be negative due to this condition}} + // expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}} + #pragma omp simd + for ((ii = 0); ii > 10; (ii-=0)) + c[ii] = a[ii]; + + // expected-note@+3 {{loop step is expected to be positive due to this condition}} + // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}} + #pragma omp simd + for (ii = 0; (ii < 10); (ii-=0)) + c[ii] = a[ii]; + + // expected-note@+2 {{defined as private}} + // expected-error@+2 {{loop iteration variable in the associated loop of 'omp simd' directive may not be private, predetermined as linear}} + #pragma omp simd private(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + + // expected-error@+3 {{unexpected OpenMP clause 'shared' in directive '#pragma omp simd'}} + // expected-note@+2 {{defined as shared}} + // expected-error@+2 {{loop iteration variable in the associated loop of 'omp simd' directive may not be shared, predetermined as linear}} + #pragma omp simd shared(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + + #pragma omp simd linear(ii) + for (ii = 0; ii < 10; ii++) + c[ii] = a[ii]; + + #pragma omp simd lastprivate(ii) linear(jj) collapse(2) // expected-note {{defined as linear}} + for (ii = 0; ii < 10; ii++) + for (jj = 0; jj < 10; jj++) // expected-error {{loop iteration variable in the associated loop of 'omp simd' directive may not be linear, predetermined as lastprivate}} + c[ii] = a[jj]; + + + #pragma omp parallel + { + // expected-error@+2 {{loop iteration variable in the associated loop of 'omp simd' directive may not be threadprivate or thread local, predetermined as linear}} + #pragma omp simd + for (sii = 0; sii < 10; sii+=1) + c[sii] = a[sii]; + } + + // expected-error@+2 {{statement after '#pragma omp simd' must be a for loop}} + #pragma omp simd + for (auto &item : a) { + item = item + 1; + } + + // expected-note@+3 {{loop step is expected to be positive due to this condition}} + // expected-error@+2 {{increment expression must cause 'i' to increase on each iteration of OpenMP for loop}} + #pragma omp simd + for (unsigned i = 9; i < 10; i--) { + c[i] = a[i] + b[i]; + } + + int (*lb)[4] = nullptr; + #pragma omp simd + for (int (*p)[4] = lb; p < lb + 8; ++p) { + } + + // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} + #pragma omp simd + for (int a{0}; a<10; ++a) { + } + + return 0; +} + +// Iterators allowed in openmp for-loops. +namespace std { +struct random_access_iterator_tag { }; +template <class Iter> struct iterator_traits { + typedef typename Iter::difference_type difference_type; + typedef typename Iter::iterator_category iterator_category; +}; +template <class Iter> +typename iterator_traits<Iter>::difference_type +distance(Iter first, Iter last) { return first - last; } +} +class Iter0 { + public: + Iter0() { } + Iter0(const Iter0 &) { } + Iter0 operator ++() { return *this; } + Iter0 operator --() { return *this; } + bool operator <(Iter0 a) { return true; } +}; +int operator -(Iter0 a, Iter0 b) { return 0; } +class Iter1 { + public: + Iter1(float f=0.0f, double d=0.0) { } + Iter1(const Iter1 &) { } + Iter1 operator ++() { return *this; } + Iter1 operator --() { return *this; } + bool operator <(Iter1 a) { return true; } + bool operator >=(Iter1 a) { return false; } +}; +class GoodIter { + public: + GoodIter() { } + GoodIter(const GoodIter &) { } + GoodIter(int fst, int snd) { } + GoodIter &operator =(const GoodIter &that) { return *this; } + GoodIter &operator =(const Iter0 &that) { return *this; } + GoodIter &operator +=(int x) { return *this; } + explicit GoodIter(void *) { } + GoodIter operator ++() { return *this; } + GoodIter operator --() { return *this; } + bool operator !() { return true; } + bool operator <(GoodIter a) { return true; } + bool operator <=(GoodIter a) { return true; } + bool operator >=(GoodIter a) { return false; } + typedef int difference_type; + typedef std::random_access_iterator_tag iterator_category; +}; +int operator -(GoodIter a, GoodIter b) { return 0; } +GoodIter operator -(GoodIter a) { return a; } +GoodIter operator -(GoodIter a, int v) { return GoodIter(); } +GoodIter operator +(GoodIter a, int v) { return GoodIter(); } +GoodIter operator -(int v, GoodIter a) { return GoodIter(); } +GoodIter operator +(int v, GoodIter a) { return GoodIter(); } + +int test_with_random_access_iterator() { + GoodIter begin, end; + Iter0 begin0, end0; + #pragma omp simd + for (GoodIter I = begin; I < end; ++I) + ++I; + // expected-error@+2 {{variable must be of integer or random access iterator type}} + #pragma omp simd + for (GoodIter &I = begin; I < end; ++I) + ++I; + #pragma omp simd + for (GoodIter I = begin; I >= end; --I) + ++I; + // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} + #pragma omp simd + for (GoodIter I(begin); I < end; ++I) + ++I; + // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} + #pragma omp simd + for (GoodIter I(nullptr); I < end; ++I) + ++I; + // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} + #pragma omp simd + for (GoodIter I(0); I < end; ++I) + ++I; + // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} + #pragma omp simd + for (GoodIter I(1,2); I < end; ++I) + ++I; + #pragma omp simd + for (begin = GoodIter(0); begin < end; ++begin) + ++begin; + #pragma omp simd + for (begin = begin0; begin < end; ++begin) + ++begin; + // expected-error@+2 {{initialization clause of OpenMP for loop must be of the form 'var = init' or 'T var = init'}} + #pragma omp simd + for (++begin; begin < end; ++begin) + ++begin; + #pragma omp simd + for (begin = end; begin < end; ++begin) + ++begin; + // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} + #pragma omp simd + for (GoodIter I = begin; I - I; ++I) + ++I; + // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} + #pragma omp simd + for (GoodIter I = begin; begin < end; ++I) + ++I; + // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} + #pragma omp simd + for (GoodIter I = begin; !I; ++I) + ++I; + // expected-note@+3 {{loop step is expected to be negative due to this condition}} + // expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} + #pragma omp simd + for (GoodIter I = begin; I >= end; I = I + 1) + ++I; + #pragma omp simd + for (GoodIter I = begin; I >= end; I = I - 1) + ++I; + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} + #pragma omp simd + for (GoodIter I = begin; I >= end; I = -I) + ++I; + // expected-note@+3 {{loop step is expected to be negative due to this condition}} + // expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} + #pragma omp simd + for (GoodIter I = begin; I >= end; I = 2 + I) + ++I; + // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}} + #pragma omp simd + for (GoodIter I = begin; I >= end; I = 2 - I) + ++I; + #pragma omp simd + for (Iter0 I = begin0; I < end0; ++I) + ++I; + // Initializer is constructor without params. + // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} + #pragma omp simd + for (Iter0 I; I < end0; ++I) + ++I; + Iter1 begin1, end1; + #pragma omp simd + for (Iter1 I = begin1; I < end1; ++I) + ++I; + // expected-note@+3 {{loop step is expected to be negative due to this condition}} + // expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} + #pragma omp simd + for (Iter1 I = begin1; I >= end1; ++I) + ++I; + // Initializer is constructor with all default params. + // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}} + #pragma omp simd + for (Iter1 I; I < end1; ++I) { + } + return 0; +} + +template <typename IT, int ST> class TC { + public: + int dotest_lt(IT begin, IT end) { + // expected-note@+3 {{loop step is expected to be positive due to this condition}} + // expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} + #pragma omp simd + for (IT I = begin; I < end; I = I + ST) { + ++I; + } + // expected-note@+3 {{loop step is expected to be positive due to this condition}} + // expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}} + #pragma omp simd + for (IT I = begin; I <= end; I += ST) { + ++I; + } + #pragma omp simd + for (IT I = begin; I < end; ++I) { + ++I; + } + } + + static IT step() { + return IT(ST); + } +}; +template <typename IT, int ST=0> int dotest_gt(IT begin, IT end) { + // expected-note@+3 2 {{loop step is expected to be negative due to this condition}} + // expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} + #pragma omp simd + for (IT I = begin; I >= end; I = I + ST) { + ++I; + } + // expected-note@+3 2 {{loop step is expected to be negative due to this condition}} + // expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} + #pragma omp simd + for (IT I = begin; I >= end; I += ST) { + ++I; + } + + // expected-note@+3 {{loop step is expected to be negative due to this condition}} + // expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}} + #pragma omp simd + for (IT I = begin; I >= end; ++I) { + ++I; + } + + #pragma omp simd + for (IT I = begin; I < end; I+=TC<int,ST>::step()) { + ++I; + } +} + +void test_with_template() { + GoodIter begin, end; + TC<GoodIter, 100> t1; + TC<GoodIter, -100> t2; + t1.dotest_lt(begin, end); + t2.dotest_lt(begin, end); // expected-note {{in instantiation of member function 'TC<GoodIter, -100>::dotest_lt' requested here}} + dotest_gt(begin, end); // expected-note {{in instantiation of function template specialization 'dotest_gt<GoodIter, 0>' requested here}} + dotest_gt<unsigned, -10>(0, 100); // expected-note {{in instantiation of function template specialization 'dotest_gt<unsigned int, -10>' requested here}} +} + +void test_loop_break() { + const int N = 100; + float a[N], b[N], c[N]; + #pragma omp simd + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + break; // OK in nested loop + } + switch(i) { + case 1: + b[i]++; + break; + default: + break; + } + if (c[i] > 10) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + + if (c[i] > 11) + break; // expected-error {{'break' statement cannot be used in OpenMP for loop}} + } + + #pragma omp simd + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 10; j++) { + c[i] = a[i] + b[i]; + if (c[i] > 10) { + if (c[i] < 20) { + break; // OK + } + } + } + } +} + +void test_loop_eh() { + const int N = 100; + float a[N], b[N], c[N]; + #pragma omp simd + for (int i = 0; i < 10; i++) { + c[i] = a[i] + b[i]; + try { // expected-error {{'try' statement cannot be used in OpenMP simd region}} + for (int j = 0; j < 10; ++j) { + if (a[i] > b[j]) + throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + } + throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + } + catch (float f) { + if (f > 0.1) + throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + return; // expected-error {{cannot return from OpenMP region}} + } + switch(i) { + case 1: + b[i]++; + break; + default: + break; + } + for (int j = 0; j < 10; j++) { + if (c[i] > 10) + throw c[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}} + } + } + if (c[9] > 10) + throw c[9]; // OK + + #pragma omp simd + for (int i = 0; i < 10; ++i) { + struct S { + void g() { throw 0; } + }; + } +} + diff --git a/test/OpenMP/simd_metadata.c b/test/OpenMP/simd_metadata.c new file mode 100644 index 000000000000..a0588adf7dad --- /dev/null +++ b/test/OpenMP/simd_metadata.c @@ -0,0 +1,51 @@ +// RUN: %clang_cc1 -fopenmp=libiomp5 -emit-llvm %s -o - | FileCheck %s + +void h1(float *c, float *a, float *b, int size) +{ +// CHECK-LABEL: define void @h1 + int t = 0; +#pragma omp simd safelen(16) linear(t) + for (int i = 0; i < size; ++i) { + c[i] = a[i] * a[i] + b[i] * b[t]; + ++t; +// do not emit parallel_loop_access metadata due to usage of safelen clause. +// CHECK-NOT: store float {{.+}}, float* {{.+}}, align {{.+}}, !llvm.mem.parallel_loop_access {{![0-9]+}} + } +} + +void h2(float *c, float *a, float *b, int size) +{ +// CHECK-LABEL: define void @h2 + int t = 0; +#pragma omp simd linear(t) + for (int i = 0; i < size; ++i) { + c[i] = a[i] * a[i] + b[i] * b[t]; + ++t; +// CHECK: store float {{.+}}, float* {{.+}}, align {{.+}}, !llvm.mem.parallel_loop_access [[LOOP_H2_HEADER:![0-9]+]] + } +} + +void h3(float *c, float *a, float *b, int size) +{ +// CHECK-LABEL: define void @h3 +#pragma omp simd + for (int i = 0; i < size; ++i) { + for (int j = 0; j < size; ++j) { + c[j*i] = a[i] * b[j]; + } + } +// do not emit parallel_loop_access for nested loop. +// CHECK-NOT: store float {{.+}}, float* {{.+}}, align {{.+}}, !llvm.mem.parallel_loop_access {{![0-9]+}} +} + +// Metadata for h1: +// CHECK: [[LOOP_H1_HEADER:![0-9]+]] = metadata !{metadata [[LOOP_H1_HEADER]], metadata [[LOOP_WIDTH_16:![0-9]+]], metadata [[LOOP_VEC_ENABLE:![0-9]+]]} +// CHECK: [[LOOP_WIDTH_16]] = metadata !{metadata !"llvm.loop.vectorize.width", i32 16} +// CHECK: [[LOOP_VEC_ENABLE]] = metadata !{metadata !"llvm.loop.vectorize.enable", i1 true} +// +// Metadata for h2: +// CHECK: [[LOOP_H2_HEADER]] = metadata !{metadata [[LOOP_H2_HEADER]], metadata [[LOOP_VEC_ENABLE]]} +// +// Metadata for h3: +// CHECK: [[LOOP_H3_HEADER:![0-9]+]] = metadata !{metadata [[LOOP_H3_HEADER]], metadata [[LOOP_VEC_ENABLE]]} +// diff --git a/test/OpenMP/simd_misc_messages.c b/test/OpenMP/simd_misc_messages.c new file mode 100644 index 000000000000..67edc6d1f867 --- /dev/null +++ b/test/OpenMP/simd_misc_messages.c @@ -0,0 +1,555 @@ +// RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp simd'}} +#pragma omp simd + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp simd'}} +#pragma omp simd foo + +// expected-error@+1 {{unexpected OpenMP directive '#pragma omp simd'}} +#pragma omp simd safelen(4) + +void test_no_clause() +{ + int i; + #pragma omp simd + for (i = 0; i < 16; ++i) ; + + // expected-error@+2 {{statement after '#pragma omp simd' must be a for loop}} + #pragma omp simd + ++i; +} + +void test_branch_protected_scope() +{ + int i = 0; +L1: + ++i; + + int x[24]; + + #pragma omp simd + for (i = 0; i < 16; ++i) { + 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; + // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} + #pragma omp simd foo bar + for (i = 0; i < 16; ++i) ; +} + +void test_non_identifiers() +{ + int i, x; + + // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} + #pragma omp simd; + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}} + // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} + #pragma omp simd firstprivate(x); + for (i = 0; i < 16; ++i) ; + + // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} + #pragma omp simd private(x); + for (i = 0; i < 16; ++i) ; + + // expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}} + #pragma omp simd , private(x); + for (i = 0; i < 16; ++i) ; +} + +extern int foo(); +void test_safelen() +{ + int i; + // expected-error@+1 {{expected '('}} + #pragma omp simd safelen + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd safelen( + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd safelen() + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd safelen(, + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd safelen(,) + for (i = 0; i < 16; ++i) ; + // expected-warning@+2 {{extra tokens at the end of '#pragma omp simd' are ignored}} + // expected-error@+1 {{expected '('}} + #pragma omp simd safelen 4) + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} + #pragma omp simd safelen(4 + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} + #pragma omp simd safelen(4, + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} + #pragma omp simd safelen(4,) + for (i = 0; i < 16; ++i) ; + // xxpected-error@+1 {{expected expression}} + #pragma omp simd safelen(4) + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} + #pragma omp simd safelen(4 4) + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} + #pragma omp simd safelen(4,,4) + for (i = 0; i < 16; ++i) ; + #pragma omp simd safelen(4) + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} + #pragma omp simd safelen(4,8) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expression is not an integer constant expression}} + #pragma omp simd safelen(2.5) + for (i = 0; i < 16; ++i); + // expected-error@+1 {{expression is not an integer constant expression}} + #pragma omp simd safelen(foo()) + for (i = 0; i < 16; ++i); + // expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} + #pragma omp simd safelen(-5) + for (i = 0; i < 16; ++i); + // expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} + #pragma omp simd safelen(0) + for (i = 0; i < 16; ++i); + // expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} + #pragma omp simd safelen(5-5) + for (i = 0; i < 16; ++i); +} + +void test_collapse() +{ + int i; + // expected-error@+1 {{expected '('}} + #pragma omp simd collapse + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd collapse( + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd collapse() + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd collapse(, + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd collapse(,) + for (i = 0; i < 16; ++i) ; + // expected-warning@+2 {{extra tokens at the end of '#pragma omp simd' are ignored}} + // expected-error@+1 {{expected '('}} + #pragma omp simd collapse 4) + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} + #pragma omp simd collapse(4 + for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} + #pragma omp simd collapse(4, + for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} + #pragma omp simd collapse(4,) + for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} + // xxpected-error@+1 {{expected expression}} expected-note@+1 {{as specified in 'collapse' clause}} + #pragma omp simd collapse(4) + for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} + #pragma omp simd collapse(4 4) + for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} + #pragma omp simd collapse(4,,4) + for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} + #pragma omp simd collapse(4) + for (int i1 = 0; i1 < 16; ++i1) + for (int i2 = 0; i2 < 16; ++i2) + for (int i3 = 0; i3 < 16; ++i3) + for (int i4 = 0; i4 < 16; ++i4) + foo(); + // expected-error@+2 {{expected ')'}} + // expected-note@+1 {{to match this '('}} expected-note@+1 {{as specified in 'collapse' clause}} + #pragma omp simd collapse(4,8) + for (i = 0; i < 16; ++i) ; // expected-error {{expected 4 for loops after '#pragma omp simd', but found only 1}} + // expected-error@+1 {{expression is not an integer constant expression}} + #pragma omp simd collapse(2.5) + for (i = 0; i < 16; ++i); + // expected-error@+1 {{expression is not an integer constant expression}} + #pragma omp simd collapse(foo()) + for (i = 0; i < 16; ++i); + // expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp simd collapse(-5) + for (i = 0; i < 16; ++i); + // expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp simd collapse(0) + for (i = 0; i < 16; ++i); + // expected-error@+1 {{argument to 'collapse' clause must be a positive integer value}} + #pragma omp simd collapse(5-5) + for (i = 0; i < 16; ++i); +} + +void test_linear() +{ + int i; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd linear( + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected expression}} + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd linear(, + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected expression}} + // expected-error@+1 {{expected expression}} + #pragma omp simd linear(,) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd linear() + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd linear(int) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp simd linear(0) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{use of undeclared identifier 'x'}} + #pragma omp simd linear(x) + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{use of undeclared identifier 'x'}} + // expected-error@+1 {{use of undeclared identifier 'y'}} + #pragma omp simd linear(x, y) + for (i = 0; i < 16; ++i) ; + // expected-error@+3 {{use of undeclared identifier 'x'}} + // expected-error@+2 {{use of undeclared identifier 'y'}} + // expected-error@+1 {{use of undeclared identifier 'z'}} + #pragma omp simd linear(x, y, z) + for (i = 0; i < 16; ++i) ; + + int x, y; + // expected-error@+1 {{expected expression}} + #pragma omp simd linear(x:) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd linear(x:,) + for (i = 0; i < 16; ++i) ; + #pragma omp simd linear(x:1) + for (i = 0; i < 16; ++i) ; + #pragma omp simd linear(x:2*2) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd linear(x:1,y) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd linear(x:1,y,z:1) + for (i = 0; i < 16; ++i) ; + + // expected-note@+2 {{defined as linear}} + // expected-error@+1 {{linear variable cannot be linear}} + #pragma omp simd linear(x) linear(x) + for (i = 0; i < 16; ++i) ; + + // expected-note@+2 {{defined as private}} + // expected-error@+1 {{private variable cannot be linear}} + #pragma omp simd private(x) linear(x) + for (i = 0; i < 16; ++i) ; + + // expected-note@+2 {{defined as linear}} + // expected-error@+1 {{linear variable cannot be private}} + #pragma omp simd linear(x) private(x) + for (i = 0; i < 16; ++i) ; + + // expected-warning@+1 {{zero linear step (x and other variables in clause should probably be const)}} + #pragma omp simd linear(x,y:0) + for (i = 0; i < 16; ++i) ; + + // expected-note@+2 {{defined as linear}} + // expected-error@+1 {{linear variable cannot be lastprivate}} + #pragma omp simd linear(x) lastprivate(x) + for (i = 0; i < 16; ++i) ; + + // expected-note@+2 {{defined as lastprivate}} + // expected-error@+1 {{lastprivate variable cannot be linear}} + #pragma omp simd lastprivate(x) linear(x) + for (i = 0; i < 16; ++i) ; + +} + +void test_aligned() +{ + int i; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd aligned( + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected expression}} + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd aligned(, + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected expression}} + // expected-error@+1 {{expected expression}} + #pragma omp simd aligned(,) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd aligned() + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd aligned(int) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp simd aligned(0) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{use of undeclared identifier 'x'}} + #pragma omp simd aligned(x) + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{use of undeclared identifier 'x'}} + // expected-error@+1 {{use of undeclared identifier 'y'}} + #pragma omp simd aligned(x, y) + for (i = 0; i < 16; ++i) ; + // expected-error@+3 {{use of undeclared identifier 'x'}} + // expected-error@+2 {{use of undeclared identifier 'y'}} + // expected-error@+1 {{use of undeclared identifier 'z'}} + #pragma omp simd aligned(x, y, z) + for (i = 0; i < 16; ++i) ; + + int *x, y, z[25]; // expected-note 4 {{'y' defined here}} + #pragma omp simd aligned(x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd aligned(z) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd aligned(x:) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd aligned(x:,) + for (i = 0; i < 16; ++i) ; + #pragma omp simd aligned(x:1) + for (i = 0; i < 16; ++i) ; + #pragma omp simd aligned(x:2*2) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd aligned(x:1,y) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd aligned(x:1,y,z:1) + for (i = 0; i < 16; ++i) ; + + // expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} + #pragma omp simd aligned(x, y) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{argument of aligned clause should be array or pointer, not 'int'}} + #pragma omp simd aligned(x, y, z) + for (i = 0; i < 16; ++i) ; + + // expected-note@+2 {{defined as aligned}} + // expected-error@+1 {{a variable cannot appear in more than one aligned clause}} + #pragma omp simd aligned(x) aligned(z,x) + for (i = 0; i < 16; ++i) ; + + // expected-note@+3 {{defined as aligned}} + // expected-error@+2 {{a variable cannot appear in more than one aligned clause}} + // expected-error@+1 2 {{argument of aligned clause should be array or pointer, not 'int'}} + #pragma omp simd aligned(x,y,z) aligned(y,z) + for (i = 0; i < 16; ++i) ; +} + +void test_private() +{ + int i; + // expected-error@+2 {{expected expression}} + // expected-error@+1 {{expected ')'}} expected-note@+1 {{to match this '('}} + #pragma omp simd private( + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} + // expected-error@+1 2 {{expected expression}} + #pragma omp simd private(, + for (i = 0; i < 16; ++i) ; + // expected-error@+1 2 {{expected expression}} + #pragma omp simd private(,) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd private() + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd private(int) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp simd private(0) + for (i = 0; i < 16; ++i) ; + + int x, y, z; + #pragma omp simd private(x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd private(x, y) + for (i = 0; i < 16; ++i) ; + #pragma omp simd private(x, y, z) + for (i = 0; i < 16; ++i) { + x = y * i + z; + } +} + +void test_firstprivate() +{ + int i; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}} + // expected-error@+1 {{expected expression}} + #pragma omp simd firstprivate( + for (i = 0; i < 16; ++i) ; +} + +void test_lastprivate() +{ + int i; + // expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} + // expected-error@+1 {{expected expression}} + #pragma omp simd lastprivate( + for (i = 0; i < 16; ++i) ; + + // expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}} + // expected-error@+1 2 {{expected expression}} + #pragma omp simd lastprivate(, + for (i = 0; i < 16; ++i) ; + // expected-error@+1 2 {{expected expression}} + #pragma omp simd lastprivate(,) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd lastprivate() + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd lastprivate(int) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp simd lastprivate(0) + for (i = 0; i < 16; ++i) ; + + int x, y, z; + #pragma omp simd lastprivate(x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd lastprivate(x, y) + for (i = 0; i < 16; ++i) ; + #pragma omp simd lastprivate(x, y, z) + for (i = 0; i < 16; ++i) ; +} + +void test_reduction() +{ + int i, x, y; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 {{expected identifier}} + // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} + #pragma omp simd reduction( + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected identifier}} + // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} + #pragma omp simd reduction() + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected expression}} + // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} + #pragma omp simd reduction(x) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected identifier}} + #pragma omp simd reduction(:x) + for (i = 0; i < 16; ++i) ; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 {{expected identifier}} + // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} + #pragma omp simd reduction(, + for (i = 0; i < 16; ++i) ; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 {{expected expression}} + // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} + #pragma omp simd reduction(+ + for (i = 0; i < 16; ++i) ; + + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // + // expected-error@+1 {{expected expression}} + #pragma omp simd reduction(+: + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd reduction(+:) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd reduction(+:,y) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected expression}} + #pragma omp simd reduction(+:x,+:y) + for (i = 0; i < 16; ++i) ; + // expected-error@+2 {{expected identifier}} + // expected-warning@+1 {{missing ':' after reduction identifier - ignoring}} + #pragma omp simd reduction(%:x) + for (i = 0; i < 16; ++i) ; + + #pragma omp simd reduction(+:x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd reduction(*:x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd reduction(-:x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd reduction(&:x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd reduction(|:x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd reduction(^:x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd reduction(&&:x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd reduction(||:x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd reduction(max:x) + for (i = 0; i < 16; ++i) ; + #pragma omp simd reduction(min:x) + for (i = 0; i < 16; ++i) ; + struct X { int x; }; + struct X X; + // expected-error@+1 {{expected variable name}} + #pragma omp simd reduction(+:X.x) + for (i = 0; i < 16; ++i) ; + // expected-error@+1 {{expected variable name}} + #pragma omp simd reduction(+:x+x) + for (i = 0; i < 16; ++i) ; +} + +void test_loop_messages() +{ + float a[100], b[100], c[100]; + // expected-error@+2 {{variable must be of integer or pointer type}} + #pragma omp simd + for (float fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } + // expected-error@+2 {{variable must be of integer or pointer type}} + #pragma omp simd + for (double fi = 0; fi < 10.0; fi++) { + c[(int)fi] = a[(int)fi] + b[(int)fi]; + } +} + diff --git a/test/OpenMP/simd_private_messages.cpp b/test/OpenMP/simd_private_messages.cpp new file mode 100644 index 000000000000..e5e4fe5b8b39 --- /dev/null +++ b/test/OpenMP/simd_private_messages.cpp @@ -0,0 +1,134 @@ +// 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 simd private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argc) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private(e, g) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp simd'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int v = 0; + int i; + #pragma omp simd private(i) + for (int k = 0; k < argc; ++k) { i = k; v += i; } + } + #pragma omp parallel shared(i) + #pragma omp parallel private(i) + #pragma omp simd private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private(i) + for (int k = 0; k < argc; ++k) ++k; + 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 simd private // expected-error {{expected '(' after 'private'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private () // expected-error {{expected expression}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argc) + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (S1) // expected-error {{'S1' does not refer to a value}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (a, b) // expected-error {{private variable with incomplete type 'S1'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private (argv[1]) // expected-error {{expected variable name}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private(h) // expected-error {{threadprivate or thread local variable cannot be private}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd shared(i) // expected-error {{unexpected OpenMP clause 'shared' in directive '#pragma omp simd'}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp parallel + { + int i; + #pragma omp simd private(i) + for (int k = 0; k < argc; ++k) ++k; + } + #pragma omp parallel shared(i) + #pragma omp parallel private(i) + #pragma omp simd private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type}} + for (int k = 0; k < argc; ++k) ++k; + #pragma omp simd private(i) + for (int k = 0; k < argc; ++k) ++k; + + return 0; +} + diff --git a/test/OpenMP/simd_reduction_messages.cpp b/test/OpenMP/simd_reduction_messages.cpp new file mode 100644 index 000000000000..347a5c1a4105 --- /dev/null +++ b/test/OpenMP/simd_reduction_messages.cpp @@ -0,0 +1,298 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + S2 &operator+=(const S2 &arg) { return (*this); } + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} + static float S2s; // expected-note 2 {{static data member is predetermined as shared}} + static const float S2sc; +}; +const float S2::S2sc = 0; // expected-note 2 {{'S2sc' defined here}} +S2 b; // expected-note 2 {{'b' defined here}} +const S2 ba[5]; // expected-note 2 {{'ba' defined here}} +class S3 { + int a; + +public: + S3() : a(0) {} + S3(const S3 &s3) : a(s3.a) {} + S3 operator+=(const S3 &arg1) { return arg1; } +}; +int operator+=(const S3 &arg1, const S3 &arg2) { return 5; } +S3 c; // expected-note 2 {{'c' defined here}} +const S3 ca[5]; // expected-note 2 {{'ca' defined here}} +extern const int f; // expected-note 4 {{'f' declared here}} +class S4 { // expected-note {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + S4 &operator+=(const S4 &arg) { return (*this); } + +public: + S4(int v) : a(v) {} +}; +S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; } +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + S5 &operator+=(const S5 &arg); + +public: + S5(int v) : a(v) {} +}; +class S6 { + int a; + +public: + S6() : a(6) {} + operator int() { return 6; } +} o; // expected-note 2 {{'o' defined here}} + +S3 h, k; +#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}} + +template <class T> // expected-note {{declared here}} +T tmain(T argc) { // expected-note 2 {{'argc' defined here}} + const T d = T(); // expected-note 4 {{'d' defined here}} + const T da[5] = {T()}; // expected-note 2 {{'da' defined here}} + T qa[5] = {T()}; + T i; + T &j = i; // expected-note 4 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}} + T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}} + T fl; // expected-note {{'fl' defined here}} +#pragma omp simd reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp simd' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(^ : T) // expected-error {{'T' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(max : qa[1]) // expected-error 2 {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} expected-error {{a reduction variable with array type 'const float [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : j), reduction(+ : q) // OK + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : p), reduction(+ : p) // expected-error 3 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 3 {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp simd reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) +#pragma omp simd reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) +#pragma omp simd reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); + + return T(); +} + +int main(int argc, char **argv) { + const int d = 5; // expected-note 2 {{'d' defined here}} + const int da[5] = {0}; // expected-note {{'da' defined here}} + int qa[5] = {0}; + S4 e(4); // expected-note {{'e' defined here}} + S5 g(5); // expected-note {{'g' defined here}} + int i; + int &j = i; // expected-note 2 {{'j' defined here}} + S3 &p = k; // expected-note 2 {{'p' defined here}} + const int &r = da[i]; // expected-note {{'r' defined here}} + int &q = qa[i]; // expected-note {{'q' defined here}} + float fl; // expected-note {{'fl' defined here}} +#pragma omp simd reduction // expected-error {{expected '(' after 'reduction'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp simd' are ignored}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(~ : argc) // expected-error {{expected unqualified-id}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(&& : argc) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(^ : S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(min : a, b, c, d, f) // expected-error {{reduction variable with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(max : argv[1]) // expected-error {{expected variable name}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : ba) // expected-error {{a reduction variable with array type 'const S2 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(* : ca) // expected-error {{a reduction variable with array type 'const S3 [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(- : da) // expected-error {{a reduction variable with array type 'const int [5]'}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(^ : fl) // expected-error {{variable of type 'float' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(& : e, g) // expected-error {{reduction variable must have an accessible, unambiguous default constructor}} expected-error {{variable of type 'S5' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : o) // expected-error {{variable of type 'class S6' is not valid for specified reduction operation}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(k) +#pragma omp simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp simd reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel shared(i) +#pragma omp parallel reduction(min : i) +#pragma omp simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}} + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel private(fl) +#pragma omp simd reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); +#pragma omp parallel reduction(* : fl) +#pragma omp simd reduction(+ : fl) + for (int i = 0; i < 10; ++i) + foo(); + + return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}} +} diff --git a/test/OpenMP/simd_safelen_messages.cpp b/test/OpenMP/simd_safelen_messages.cpp new file mode 100644 index 000000000000..0e7e80dd976c --- /dev/null +++ b/test/OpenMP/simd_safelen_messages.cpp @@ -0,0 +1,79 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, typename S, int N, int ST> // expected-note {{declared here}} +T tmain(T argc, S **argv) { //expected-note 2 {{declared here}} + #pragma omp simd safelen // expected-error {{expected '(' after 'safelen'}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd safelen () // expected-error {{expected expression}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 {{expected ')'}} expected-note@+3 {{to match this '('}} + // expected-error@+2 2 {{expression is not an integral constant expression}} + // expected-note@+1 2 {{read of non-const variable 'argc' is not allowed in a constant expression}} + #pragma omp simd safelen (argc + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 {{argument to 'safelen' clause must be a positive integer value}} + #pragma omp simd safelen (ST // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd safelen (1)) // expected-warning {{extra tokens at the end of '#pragma omp simd' are ignored}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd safelen ((ST > 0) ? 1 + ST : 2) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+3 2 {{directive '#pragma omp simd' cannot contain more than one 'safelen' clause}} + // expected-error@+2 2 {{argument to 'safelen' clause must be a positive integer value}} + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp simd safelen (foobool(argc)), safelen (true), safelen (-5) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd safelen (S) // expected-error {{'S' does not refer to a value}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + // expected-error@+1 2 {{expression is not an integral constant expression}} + #pragma omp simd safelen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd safelen (4) + for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + #pragma omp simd safelen (N) // expected-error {{argument to 'safelen' clause must be a positive integer value}} + for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; + return argc; +} + +int main(int argc, char **argv) { + #pragma omp simd safelen // expected-error {{expected '(' after 'safelen'}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd safelen () // expected-error {{expected expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd safelen (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd safelen (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp simd' are ignored}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd safelen (foobool(1) > 0 ? 1 : 2) // expected-error {{expression is not an integral constant expression}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{expression is not an integral constant expression}} + // expected-error@+2 2 {{directive '#pragma omp simd' cannot contain more than one 'safelen' clause}} + // expected-error@+1 2 {{argument to 'safelen' clause must be a positive integer value}} + #pragma omp simd safelen (foobool(argc)), safelen (true), safelen (-5) + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + #pragma omp simd safelen (S1) // expected-error {{'S1' does not refer to a value}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+1 {{expression is not an integral constant expression}} + #pragma omp simd safelen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; + // expected-error@+3 {{statement after '#pragma omp simd' must be a for loop}} + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}} + #pragma omp simd safelen(safelen(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}} + foo(); + // expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 12, 4>' requested here}} + return tmain<int, char, 12, 4>(argc, argv); +} + diff --git a/test/OpenMP/single_ast_print.cpp b/test/OpenMP/single_ast_print.cpp new file mode 100644 index 000000000000..65a007e271c4 --- /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 private(g) +#pragma omp single private(argc, b), firstprivate(c, d), nowait copyprivate(g) + foo(); + // CHECK-NEXT: #pragma omp parallel private(g) + // CHECK-NEXT: #pragma omp single private(argc,b) firstprivate(c,d) nowait copyprivate(g) + // 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 private(g) +#pragma omp single private(argc, b), firstprivate(argv, c), nowait copyprivate(g) + foo(); + // CHECK-NEXT: #pragma omp parallel private(g) + // CHECK-NEXT: #pragma omp single private(argc,b) firstprivate(argv,c) nowait copyprivate(g) + // CHECK-NEXT: foo(); + return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0])); +} + +#endif diff --git a/test/OpenMP/single_copyprivate_messages.cpp b/test/OpenMP/single_copyprivate_messages.cpp new file mode 100644 index 000000000000..f07ab12bfb46 --- /dev/null +++ b/test/OpenMP/single_copyprivate_messages.cpp @@ -0,0 +1,157 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 %s + +void foo() { +} + +struct S1; // expected-note 2 {{declared here}} +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2 &operator=(S2 &s2) { return *this; } +}; +class S3 { + int a; + +public: + S3() : a(0) {} + S3 &operator=(S3 &s3) { return *this; } +}; +class S4 { // expected-note 2 {{'S4' declared here}} + int a; + S4(); + S4 &operator=(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note 2 {{'S5' declared here}} + int a; + S5() : a(0) {} + S5 &operator=(const S5 &s5) { return *this; } + +public: + S5(int v) : a(v) {} +}; + +S2 k; +S3 h; +S4 l(3); // expected-note 2 {{'l' defined here}} +S5 m(4); // expected-note 2 {{'m' defined here}} +#pragma omp threadprivate(h, k, l, m) + +template <class T, class C> +T tmain(T argc, C **argv) { + T i; +#pragma omp parallel +#pragma omp single copyprivate // expected-error {{expected '(' after 'copyprivate'}} +#pragma omp parallel +#pragma omp single copyprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp parallel +#pragma omp single copyprivate() // expected-error {{expected expression}} +#pragma omp parallel +#pragma omp single copyprivate(k // expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp parallel +#pragma omp single copyprivate(h, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp parallel +#pragma omp single copyprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} +#pragma omp parallel +#pragma omp single copyprivate(l) // expected-error {{copyprivate variable must have an accessible, unambiguous copy assignment operator}} +#pragma omp parallel +#pragma omp single copyprivate(S1) // expected-error {{'S1' does not refer to a value}} +#pragma omp parallel +#pragma omp single copyprivate(argv[1]) // expected-error {{expected variable name}} +#pragma omp parallel // expected-note {{implicitly determined as shared}} +#pragma omp single copyprivate(i) // expected-error {{copyprivate variable must be threadprivate or private in the enclosing context}} +#pragma omp parallel +#pragma omp single copyprivate(m) // expected-error {{copyprivate variable must have an accessible, unambiguous copy assignment operator}} + foo(); +#pragma omp parallel private(i) + { +#pragma omp single copyprivate(i) + foo(); + } +#pragma omp parallel shared(i) // expected-note {{defined as shared}} + { +#pragma omp single copyprivate(i) // expected-error {{copyprivate variable must be threadprivate or private in the enclosing context}} + foo(); + } +#pragma omp parallel private(i) +#pragma omp parallel default(shared) // expected-note {{implicitly determined as shared}} + { +#pragma omp single copyprivate(i) // expected-error {{copyprivate variable must be threadprivate or private in the enclosing context}} + foo(); + } +#pragma omp parallel private(i) +#pragma omp parallel // expected-note {{implicitly determined as shared}} + { +#pragma omp single copyprivate(i) // expected-error {{copyprivate variable must be threadprivate or private in the enclosing context}} + foo(); + } +#pragma omp parallel +#pragma omp single private(i) copyprivate(i) // expected-error {{private variable cannot be copyprivate}} expected-note {{defined as private}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(i) copyprivate(i) // expected-error {{firstprivate variable cannot be copyprivate}} expected-note {{defined as firstprivate}} + foo(); + + return T(); +} + +int main(int argc, char **argv) { + int i; +#pragma omp parallel +#pragma omp single copyprivate // expected-error {{expected '(' after 'copyprivate'}} +#pragma omp parallel +#pragma omp single copyprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp parallel +#pragma omp single copyprivate() // expected-error {{expected expression}} +#pragma omp parallel +#pragma omp single copyprivate(k // expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp parallel +#pragma omp single copyprivate(h, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp parallel +#pragma omp single copyprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} +#pragma omp parallel +#pragma omp single copyprivate(l) // expected-error {{copyprivate variable must have an accessible, unambiguous copy assignment operator}} +#pragma omp parallel +#pragma omp single copyprivate(S1) // expected-error {{'S1' does not refer to a value}} +#pragma omp parallel +#pragma omp single copyprivate(argv[1]) // expected-error {{expected variable name}} +#pragma omp parallel // expected-note {{implicitly determined as shared}} +#pragma omp single copyprivate(i) // expected-error {{copyprivate variable must be threadprivate or private in the enclosing context}} +#pragma omp parallel +#pragma omp single copyprivate(m) // expected-error {{copyprivate variable must have an accessible, unambiguous copy assignment operator}} + foo(); +#pragma omp parallel private(i) + { +#pragma omp single copyprivate(i) + foo(); + } +#pragma omp parallel shared(i) // expected-note {{defined as shared}} + { +#pragma omp single copyprivate(i) // expected-error {{copyprivate variable must be threadprivate or private in the enclosing context}} + foo(); + } +#pragma omp parallel private(i) +#pragma omp parallel default(shared) // expected-note {{implicitly determined as shared}} + { +#pragma omp single copyprivate(i) // expected-error {{copyprivate variable must be threadprivate or private in the enclosing context}} + foo(); + } +#pragma omp parallel private(i) +#pragma omp parallel // expected-note {{implicitly determined as shared}} + { +#pragma omp single copyprivate(i) // expected-error {{copyprivate variable must be threadprivate or private in the enclosing context}} + foo(); + } +#pragma omp parallel +#pragma omp single private(i) copyprivate(i) // expected-error {{private variable cannot be copyprivate}} expected-note {{defined as private}} + foo(); +#pragma omp parallel +#pragma omp single firstprivate(i) copyprivate(i) // expected-error {{firstprivate variable cannot be copyprivate}} expected-note {{defined as firstprivate}} + foo(); + + return tmain(argc, argv); // expected-note {{in instantiation of function template specialization 'tmain<int, char>' requested here}} +} diff --git a/test/OpenMP/single_firstprivate_messages.cpp b/test/OpenMP/single_firstprivate_messages.cpp new file mode 100644 index 000000000000..6d4988254fb6 --- /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 000000000000..7c10ca0a2887 --- /dev/null +++ b/test/OpenMP/single_misc_messages.c @@ -0,0 +1,156 @@ +// 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(); +} + +void test_nowait() { +#pragma omp single nowait nowait // expected-error {{directive '#pragma omp single' cannot contain more than one 'nowait' clause}} + for (int i = 0; i < 16; ++i) + ; +} diff --git a/test/OpenMP/single_private_messages.cpp b/test/OpenMP/single_private_messages.cpp new file mode 100644 index 000000000000..1414a92ee030 --- /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; +} + diff --git a/test/OpenMP/task_ast_print.cpp b/test/OpenMP/task_ast_print.cpp new file mode 100644 index 000000000000..2b43c0b0896d --- /dev/null +++ b/test/OpenMP/task_ast_print.cpp @@ -0,0 +1,96 @@ +// 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> +struct S { + operator T() { return T(); } + static T TS; +#pragma omp threadprivate(TS) +}; + +// CHECK: template <class T = int> struct S { +// CHECK: static int TS; +// CHECK-NEXT: #pragma omp threadprivate(S<int>::TS) +// CHECK-NEXT: } +// CHECK: template <class T = long> struct S { +// CHECK: static long TS; +// CHECK-NEXT: #pragma omp threadprivate(S<long>::TS) +// CHECK-NEXT: } +// CHECK: template <class T> struct S { +// CHECK: static T TS; +// CHECK-NEXT: #pragma omp threadprivate(S::TS) +// CHECK: }; + +template <typename T, int C> +T tmain(T argc, T *argv) { + T b = argc, c, d, e, f, g; + static T a; + S<T> s; +#pragma omp task untied + a = 2; +#pragma omp task default(none), private(argc, b) firstprivate(argv) shared(d) if (argc > 0) final(S<T>::TS > 0) + foo(); +#pragma omp task if (C) mergeable + foo(); + return 0; +} + +// CHECK: template <typename T = int, int C = 5> int tmain(int argc, int *argv) { +// CHECK-NEXT: int b = argc, c, d, e, f, g; +// CHECK-NEXT: static int a; +// CHECK-NEXT: S<int> s; +// CHECK-NEXT: #pragma omp task untied +// CHECK-NEXT: a = 2; +// CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) final(S<int>::TS > 0) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp task if(5) mergeable +// CHECK-NEXT: foo() +// CHECK: template <typename T = long, int C = 1> long tmain(long argc, long *argv) { +// CHECK-NEXT: long b = argc, c, d, e, f, g; +// CHECK-NEXT: static long a; +// CHECK-NEXT: S<long> s; +// CHECK-NEXT: #pragma omp task untied +// CHECK-NEXT: a = 2; +// CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) final(S<long>::TS > 0) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp task if(1) mergeable +// CHECK-NEXT: foo() +// CHECK: template <typename T, int C> T tmain(T argc, T *argv) { +// CHECK-NEXT: T b = argc, c, d, e, f, g; +// CHECK-NEXT: static T a; +// CHECK-NEXT: S<T> s; +// CHECK-NEXT: #pragma omp task untied +// CHECK-NEXT: a = 2; +// CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) shared(d) if(argc > 0) final(S<T>::TS > 0) +// CHECK-NEXT: foo() +// CHECK-NEXT: #pragma omp task if(C) mergeable +// CHECK-NEXT: foo() + +enum Enum {}; + +int main(int argc, char **argv) { + long x; + int b = argc, c, d, e, f, g; + static int a; +#pragma omp threadprivate(a) + Enum ee; +// CHECK: Enum ee; +#pragma omp task untied mergeable + // CHECK-NEXT: #pragma omp task untied mergeable + a = 2; +// CHECK-NEXT: a = 2; +#pragma omp task default(none), private(argc, b) firstprivate(argv) if (argc > 0) final(a > 0) + // CHECK-NEXT: #pragma omp task default(none) private(argc,b) firstprivate(argv) if(argc > 0) final(a > 0) + foo(); + // CHECK-NEXT: foo(); + return tmain<int, 5>(b, &b) + tmain<long, 1>(x, &x); +} + +#endif diff --git a/test/OpenMP/task_default_messages.cpp b/test/OpenMP/task_default_messages.cpp new file mode 100644 index 000000000000..8da6b1aeea17 --- /dev/null +++ b/test/OpenMP/task_default_messages.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -o - %s + +void foo(); + +int main(int argc, char **argv) { +#pragma omp task default // expected-error {{expected '(' after 'default'}} +#pragma omp task default( // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp task default() // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} +#pragma omp task default(none // expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp task default(shared), default(shared) // expected-error {{directive '#pragma omp task' cannot contain more than one 'default' clause}} +#pragma omp task default(x) // expected-error {{expected 'none' or 'shared' in OpenMP clause 'default'}} + foo(); + +#pragma omp task default(none) + ++argc; // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + +#pragma omp task default(none) +#pragma omp task default(shared) + ++argc; + return 0; +} diff --git a/test/OpenMP/task_final_messages.cpp b/test/OpenMP/task_final_messages.cpp new file mode 100644 index 000000000000..0b52e6aca150 --- /dev/null +++ b/test/OpenMP/task_final_messages.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, class S> // expected-note {{declared here}} +int tmain(T argc, S **argv) { + #pragma omp task final // expected-error {{expected '(' after 'final'}} + #pragma omp task final ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task final () // expected-error {{expected expression}} + #pragma omp task final (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task final (argc)) // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + #pragma omp task final (argc > 0 ? argv[1] : argv[2]) + #pragma omp task final (foobool(argc)), final (true) // expected-error {{directive '#pragma omp task' cannot contain more than one 'final' clause}} + #pragma omp task final (S) // expected-error {{'S' does not refer to a value}} + #pragma omp task final (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task final (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task final(argc) + foo(); + + return 0; +} + +int main(int argc, char **argv) { + #pragma omp task final // expected-error {{expected '(' after 'final'}} + #pragma omp task final ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task final () // expected-error {{expected expression}} + #pragma omp task final (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task final (argc)) // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + #pragma omp task final (argc > 0 ? argv[1] : argv[2]) + #pragma omp task final (foobool(argc)), final (true) // expected-error {{directive '#pragma omp task' cannot contain more than one 'final' clause}} + #pragma omp task final (S1) // expected-error {{'S1' does not refer to a value}} + #pragma omp task final (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task final (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task final (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task final(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + + return tmain(argc, argv); +} diff --git a/test/OpenMP/task_firstprivate_messages.cpp b/test/OpenMP/task_firstprivate_messages.cpp new file mode 100644 index 000000000000..85d3f9f46144 --- /dev/null +++ b/test/OpenMP/task_firstprivate_messages.cpp @@ -0,0 +1,86 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note{{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; + +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 {{'S4' declared here}} + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { // expected-note {{'S5' declared here}} + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + +public: + S5(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note {{defined as threadprivate or thread local}} + +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 {{'g' defined here}} + int i; + int &j = i; // expected-note {{'j' defined here}} +#pragma omp task firstprivate // expected-error {{expected '(' after 'firstprivate'}} +#pragma omp task firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp task firstprivate() // expected-error {{expected expression}} +#pragma omp task firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp task firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp task firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} +#pragma omp task firstprivate(argc) +#pragma omp task firstprivate(S1) // expected-error {{'S1' does not refer to a value}} +#pragma omp task firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} +#pragma omp task firstprivate(argv[1]) // expected-error {{expected variable name}} +#pragma omp task firstprivate(ba) +#pragma omp task firstprivate(ca) +#pragma omp task firstprivate(da) +#pragma omp task firstprivate(S2::S2s) +#pragma omp task firstprivate(S2::S2sc) +#pragma omp task firstprivate(e, g) // expected-error 2 {{firstprivate variable must have an accessible, unambiguous copy constructor}} +#pragma omp task firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}} +#pragma omp task private(i), firstprivate(i) // expected-error {{private variable cannot be firstprivate}} expected-note{{defined as private}} + foo(); +#pragma omp task shared(i) +#pragma omp task firstprivate(i) +#pragma omp task firstprivate(j) // expected-error {{arguments of OpenMP clause 'firstprivate' cannot be of reference type}} + foo(); + + return 0; +} diff --git a/test/OpenMP/task_if_messages.cpp b/test/OpenMP/task_if_messages.cpp new file mode 100644 index 000000000000..51900c0be2e5 --- /dev/null +++ b/test/OpenMP/task_if_messages.cpp @@ -0,0 +1,46 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} + +template <class T, class S> // expected-note {{declared here}} +int tmain(T argc, S **argv) { + #pragma omp task if // expected-error {{expected '(' after 'if'}} + #pragma omp task if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task if () // expected-error {{expected expression}} + #pragma omp task if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + #pragma omp task if (argc > 0 ? argv[1] : argv[2]) + #pragma omp task if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp task' cannot contain more than one 'if' clause}} + #pragma omp task if (S) // expected-error {{'S' does not refer to a value}} + #pragma omp task if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task if(argc) + foo(); + + return 0; +} + +int main(int argc, char **argv) { + #pragma omp task if // expected-error {{expected '(' after 'if'}} + #pragma omp task if ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task if () // expected-error {{expected expression}} + #pragma omp task if (argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task if (argc)) // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + #pragma omp task if (argc > 0 ? argv[1] : argv[2]) + #pragma omp task if (foobool(argc)), if (true) // expected-error {{directive '#pragma omp task' cannot contain more than one 'if' clause}} + #pragma omp task if (S1) // expected-error {{'S1' does not refer to a value}} + #pragma omp task if (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task if (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task if (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}} + #pragma omp task if(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); + + return tmain(argc, argv); +} diff --git a/test/OpenMP/task_messages.cpp b/test/OpenMP/task_messages.cpp new file mode 100644 index 000000000000..88c339afc117 --- /dev/null +++ b/test/OpenMP/task_messages.cpp @@ -0,0 +1,275 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 -std=c++11 -o - %s + +void foo() { +} + +#pragma omp task // expected-error {{unexpected OpenMP directive '#pragma omp task'}} + +class S { // expected-note 6 {{'S' declared here}} + S(const S &s) { a = s.a + 12; } + int a; + +public: + S() : a(0) {} + S(int a) : a(a) {} + operator int() { return a; } + S &operator++() { return *this; } + S operator+(const S &) { return *this; } +}; + +template <class T> +int foo() { + T a; // expected-note 3 {{'a' defined here}} + T &b = a; // expected-note 4 {{'b' defined here}} + int r; +#pragma omp task default(none) +#pragma omp task default(shared) + ++a; +// expected-error@+2 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} +#pragma omp task default(none) +#pragma omp task +// expected-note@+1 {{used here}} + ++a; +#pragma omp task +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} +#pragma omp task + // expected-note@+1 {{used here}} + ++a; +#pragma omp task default(shared) +#pragma omp task + ++a; +#pragma omp task +#pragma omp parallel + ++a; +// expected-error@+2 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'int &'}} +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'S &'}} +#pragma omp task + // expected-note@+1 2 {{used here}} + ++b; +// expected-error@+3 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'int &'}} +// expected-error@+2 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'S &'}} +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} +#pragma omp task +// expected-note@+1 3 {{used here}} +#pragma omp parallel shared(a, b) + ++a, ++b; +// expected-note@+1 3 {{defined as reduction}} +#pragma omp parallel reduction(+ : r) +// expected-error@+1 {{argument of a reduction clause of a parallel construct must not appear in a firstprivate clause on a task construct}} +#pragma omp task firstprivate(r) + // expected-error@+1 2 {{reduction variables may not be accessed in an explicit task}} + ++r; +// expected-note@+1 2 {{defined as reduction}} +#pragma omp parallel reduction(+ : r) +#pragma omp task default(shared) + // expected-error@+1 2 {{reduction variables may not be accessed in an explicit task}} + ++r; +// expected-note@+1 2 {{defined as reduction}} +#pragma omp parallel reduction(+ : r) +#pragma omp task + // expected-error@+1 2 {{reduction variables may not be accessed in an explicit task}} + ++r; +#pragma omp parallel +// expected-note@+1 3 {{defined as reduction}} +#pragma omp for reduction(+ : r) + for (int i = 0; i < 10; ++i) +// expected-error@+1 {{argument of a reduction clause of a for construct must not appear in a firstprivate clause on a task construct}} +#pragma omp task firstprivate(r) + // expected-error@+1 2 {{reduction variables may not be accessed in an explicit task}} + ++r; +#pragma omp parallel +// expected-note@+1 2 {{defined as reduction}} +#pragma omp for reduction(+ : r) + for (int i = 0; i < 10; ++i) +#pragma omp task default(shared) + // expected-error@+1 2 {{reduction variables may not be accessed in an explicit task}} + ++r; +#pragma omp parallel +// expected-note@+1 2 {{defined as reduction}} +#pragma omp for reduction(+ : r) + for (int i = 0; i < 10; ++i) +#pragma omp task + // expected-error@+1 2 {{reduction variables may not be accessed in an explicit task}} + ++r; +// expected-note@+1 {{non-shared variable in a task construct is predetermined as firstprivate}} +#pragma omp task +// expected-error@+2 {{reduction variable must be shared}} +// expected-error@+1 {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} +#pragma omp for reduction(+ : r) + ++r; +// expected-error@+1 {{directive '#pragma omp task' cannot contain more than one 'untied' clause}} +#pragma omp task untied untied + ++r; +// expected-error@+1 {{directive '#pragma omp task' cannot contain more than one 'mergeable' clause}} +#pragma omp task mergeable mergeable + ++r; + return a + b; +} + +int main(int argc, char **argv) { + int a; + int &b = a; // expected-note 2 {{'b' defined here}} + S sa; // expected-note 3 {{'sa' defined here}} + S &sb = sa; // expected-note 2 {{'sb' defined here}} + int r; +#pragma omp task { // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + foo(); +#pragma omp task( // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + foo(); +#pragma omp task[ // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + foo(); +#pragma omp task] // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + foo(); +#pragma omp task) // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + foo(); +#pragma omp task } // expected-warning {{extra tokens at the end of '#pragma omp task' are ignored}} + foo(); +#pragma omp task +// expected-warning@+1 {{extra tokens at the end of '#pragma omp task' are ignored}} +#pragma omp task unknown() + foo(); +L1: + foo(); +#pragma omp task + ; +#pragma omp task + { + goto L1; // expected-error {{use of undeclared label 'L1'}} + argc++; + } + + for (int i = 0; i < 10; ++i) { + switch (argc) { + case (0): +#pragma omp task + { + foo(); + break; // expected-error {{'break' statement not in loop or switch statement}} + continue; // expected-error {{'continue' statement not in loop statement}} + } + default: + break; + } + } +#pragma omp task default(none) + ++argc; // expected-error {{variable 'argc' must have explicitly specified data sharing attributes}} + + goto L2; // expected-error {{use of undeclared label 'L2'}} +#pragma omp task +L2: + foo(); +#pragma omp task + { + return 1; // expected-error {{cannot return from OpenMP region}} + } + + [[]] // expected-error {{an attribute list cannot appear here}} +#pragma omp task + for (int n = 0; n < 100; ++n) { + } + +#pragma omp task default(none) +#pragma omp task default(shared) + ++a; +#pragma omp task default(none) +#pragma omp task + ++a; +#pragma omp task default(shared) +#pragma omp task + ++a; +#pragma omp task +#pragma omp parallel + ++a; +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'int &'}} +#pragma omp task + // expected-note@+1 {{used here}} + ++b; +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'int &'}} +#pragma omp task +// expected-note@+1 {{used here}} +#pragma omp parallel shared(a, b) + ++a, ++b; +#pragma omp task default(none) +#pragma omp task default(shared) + ++sa; +#pragma omp task default(none) +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} +#pragma omp task +// expected-note@+1 {{used here}} + ++sa; +#pragma omp task +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} +#pragma omp task +// expected-note@+1 {{used here}} + ++sa; +#pragma omp task default(shared) +#pragma omp task + ++sa; +#pragma omp task +#pragma omp parallel + ++sa; +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'S &'}} +#pragma omp task + // expected-note@+1 {{used here}} + ++sb; +// expected-error@+2 {{predetermined as a firstprivate in a task construct variable cannot be of reference type 'S &'}} +// expected-error@+1 {{predetermined as a firstprivate in a task construct variable must have an accessible, unambiguous copy constructor}} +#pragma omp task +// expected-note@+1 2 {{used here}} +#pragma omp parallel shared(sa, sb) + ++sa, ++sb; +// expected-note@+1 2 {{defined as reduction}} +#pragma omp parallel reduction(+ : r) +// expected-error@+1 {{argument of a reduction clause of a parallel construct must not appear in a firstprivate clause on a task construct}} +#pragma omp task firstprivate(r) + // expected-error@+1 {{reduction variables may not be accessed in an explicit task}} + ++r; +// expected-note@+1 {{defined as reduction}} +#pragma omp parallel reduction(+ : r) +#pragma omp task default(shared) + // expected-error@+1 {{reduction variables may not be accessed in an explicit task}} + ++r; +// expected-note@+1 {{defined as reduction}} +#pragma omp parallel reduction(+ : r) +#pragma omp task + // expected-error@+1 {{reduction variables may not be accessed in an explicit task}} + ++r; +#pragma omp parallel +// expected-note@+1 2 {{defined as reduction}} +#pragma omp for reduction(+ : r) + for (int i = 0; i < 10; ++i) +// expected-error@+1 {{argument of a reduction clause of a for construct must not appear in a firstprivate clause on a task construct}} +#pragma omp task firstprivate(r) + // expected-error@+1 {{reduction variables may not be accessed in an explicit task}} + ++r; +#pragma omp parallel +// expected-note@+1 {{defined as reduction}} +#pragma omp for reduction(+ : r) + for (int i = 0; i < 10; ++i) +#pragma omp task default(shared) + // expected-error@+1 {{reduction variables may not be accessed in an explicit task}} + ++r; +#pragma omp parallel +// expected-note@+1 {{defined as reduction}} +#pragma omp for reduction(+ : r) + for (int i = 0; i < 10; ++i) +#pragma omp task + // expected-error@+1 {{reduction variables may not be accessed in an explicit task}} + ++r; +// expected-note@+1 {{non-shared variable in a task construct is predetermined as firstprivate}} +#pragma omp task +// expected-error@+2 {{reduction variable must be shared}} +// expected-error@+1 {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} +#pragma omp for reduction(+ : r) + ++r; +// expected-error@+1 {{directive '#pragma omp task' cannot contain more than one 'untied' clause}} +#pragma omp task untied untied + ++r; +// expected-error@+1 {{directive '#pragma omp task' cannot contain more than one 'mergeable' clause}} +#pragma omp task mergeable mergeable + ++r; + // expected-note@+2 {{in instantiation of function template specialization 'foo<int>' requested here}} + // expected-note@+1 {{in instantiation of function template specialization 'foo<S>' requested here}} + return foo<int>() + foo<S>(); +} + diff --git a/test/OpenMP/task_private_messages.cpp b/test/OpenMP/task_private_messages.cpp new file mode 100644 index 000000000000..0be238dd90c4 --- /dev/null +++ b/test/OpenMP/task_private_messages.cpp @@ -0,0 +1,85 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} + static float S2s; // expected-note {{static data member is predetermined as shared}} +}; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + +public: + S3() : a(0) {} +}; +const S3 c; // expected-note {{global variable is predetermined as shared}} +const S3 ca[5]; // expected-note {{global variable is predetermined as shared}} +extern const int f; // expected-note {{global variable is predetermined as shared}} +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) {} +}; + +int threadvar; +#pragma omp threadprivate(threadvar) // expected-note {{defined as threadprivate or thread local}} + +int main(int argc, char **argv) { + const int d = 5; // expected-note {{constant variable is predetermined as shared}} + const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}} + 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 task private // expected-error {{expected '(' after 'private'}} +#pragma omp task private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp task private() // expected-error {{expected expression}} +#pragma omp task private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp task private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} +#pragma omp task private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} +#pragma omp task private(argc argv) // expected-error {{expected ',' or ')' in 'private' clause}} +#pragma omp task private(S1) // expected-error {{'S1' does not refer to a value}} +#pragma omp task private(a, b, c, d, f) // expected-error {{a private variable with incomplete type 'S1'}} expected-error 3 {{shared variable cannot be private}} +#pragma omp task private(argv[1]) // expected-error {{expected variable name}} +#pragma omp task private(ba) +#pragma omp task private(ca) // expected-error {{shared variable cannot be private}} +#pragma omp task private(da) // expected-error {{shared variable cannot be private}} +#pragma omp task private(S2::S2s) // expected-error {{shared variable cannot be private}} +#pragma omp task private(e, g) // expected-error 2 {{private variable must have an accessible, unambiguous default constructor}} +#pragma omp task private(threadvar) // expected-error {{threadprivate or thread local variable cannot be private}} +#pragma omp task shared(i), private(i) // expected-error {{shared variable cannot be private}} expected-note {{defined as shared}} + foo(); +#pragma omp task firstprivate(i) private(i) // expected-error {{firstprivate variable cannot be private}} expected-note {{defined as firstprivate}} + foo(); +#pragma omp task private(i) +#pragma omp task private(j) // expected-error {{arguments of OpenMP clause 'private' cannot be of reference type 'int &'}} + foo(); +#pragma omp task firstprivate(i) + for (int k = 0; k < 10; ++k) { +#pragma omp task private(i) + foo(); + } + + return 0; +} diff --git a/test/OpenMP/task_shared_messages.cpp b/test/OpenMP/task_shared_messages.cpp new file mode 100644 index 000000000000..747923721b9a --- /dev/null +++ b/test/OpenMP/task_shared_messages.cpp @@ -0,0 +1,102 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +void foo() { +} + +bool foobool(int argc) { + return argc; +} + +struct S1; // expected-note {{declared here}} +extern S1 a; +class S2 { + mutable int a; + +public: + S2() : a(0) {} + S2(S2 &s2) : a(s2.a) {} +}; +const S2 b; +const S2 ba[5]; +class S3 { + int a; + +public: + S3() : a(0) {} + S3(S3 &s3) : a(s3.a) {} +}; +const S3 c; +const S3 ca[5]; +extern const int f; +class S4 { + int a; + S4(); + S4(const S4 &s4); + +public: + S4(int v) : a(v) {} +}; +class S5 { + int a; + S5() : a(0) {} + S5(const S5 &s5) : a(s5.a) {} + +public: + S5(int v) : a(v) {} +}; + +S3 h; +#pragma omp threadprivate(h) // expected-note {{defined as threadprivate or thread local}} + +int main(int argc, char **argv) { + const int d = 5; + const int da[5] = {0}; + S4 e(4); + S5 g(5); + int i; + int &j = i; +#pragma omp task shared // expected-error {{expected '(' after 'shared'}} + foo(); +#pragma omp task shared( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp task shared() // expected-error {{expected expression}} + foo(); +#pragma omp task shared(argc // expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp task shared(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} + foo(); +#pragma omp task shared(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}} + foo(); +#pragma omp task shared(argc) + foo(); +#pragma omp task shared(S1) // expected-error {{'S1' does not refer to a value}} + foo(); +#pragma omp task shared(a, b, c, d, f) + foo(); +#pragma omp task shared(argv[1]) // expected-error {{expected variable name}} + foo(); +#pragma omp task shared(ba) + foo(); +#pragma omp task shared(ca) + foo(); +#pragma omp task shared(da) + foo(); +#pragma omp task shared(e, g) + foo(); +#pragma omp task shared(h) // expected-error {{threadprivate or thread local variable cannot be shared}} + foo(); +#pragma omp task private(i), shared(i) // expected-error {{private variable cannot be shared}} expected-note {{defined as private}} + foo(); +#pragma omp task firstprivate(i), shared(i) // expected-error {{firstprivate variable cannot be shared}} expected-note {{defined as firstprivate}} + foo(); +#pragma omp parallel private(i) +#pragma omp task shared(i) +#pragma omp task shared(j) + foo(); +#pragma omp parallel firstprivate(i) +#pragma omp task shared(i) +#pragma omp task shared(j) + foo(); + + return 0; +} diff --git a/test/OpenMP/taskwait_ast_print.cpp b/test/OpenMP/taskwait_ast_print.cpp new file mode 100644 index 000000000000..994262242eb7 --- /dev/null +++ b/test/OpenMP/taskwait_ast_print.cpp @@ -0,0 +1,32 @@ +// 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> +T tmain(T argc) { + static T a; +#pragma omp taskwait + return a + argc; +} +// CHECK: static int a; +// CHECK-NEXT: #pragma omp taskwait +// CHECK: static char a; +// CHECK-NEXT: #pragma omp taskwait +// CHECK: static T a; +// CHECK-NEXT: #pragma omp taskwait + +int main(int argc, char **argv) { + static int a; +// CHECK: static int a; +#pragma omp taskwait + // CHECK-NEXT: #pragma omp taskwait + return tmain(argc) + tmain(argv[0][0]) + a; +} + +#endif diff --git a/test/OpenMP/taskwait_messages.cpp b/test/OpenMP/taskwait_messages.cpp new file mode 100644 index 000000000000..f325c7328372 --- /dev/null +++ b/test/OpenMP/taskwait_messages.cpp @@ -0,0 +1,110 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +template <class T> +T tmain(T argc) { +#pragma omp taskwait + ; +#pragma omp taskwait untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp taskwait'}} +#pragma omp taskwait unknown // expected-warning {{extra tokens at the end of '#pragma omp taskwait' are ignored}} + if (argc) +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + if (argc) { +#pragma omp taskwait + } + while (argc) +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + while (argc) { +#pragma omp taskwait + } + do +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp taskwait + } while (argc); + switch (argc) +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp taskwait + } + switch (argc) { +#pragma omp taskwait + case 1: +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + break; + default: { +#pragma omp taskwait + } break; + } + for (;;) +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + for (;;) { +#pragma omp taskwait + } +label: +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} +label1 : { +#pragma omp taskwait +} + + return T(); +} + +int main(int argc, char **argv) { +#pragma omp taskwait + ; +#pragma omp taskwait untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp taskwait'}} +#pragma omp taskwait unknown // expected-warning {{extra tokens at the end of '#pragma omp taskwait' are ignored}} + if (argc) +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + if (argc) { +#pragma omp taskwait + } + while (argc) +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + while (argc) { +#pragma omp taskwait + } + do +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp taskwait + } while (argc); + switch (argc) +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp taskwait + } + switch (argc) { +#pragma omp taskwait + case 1: +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + break; + default: { +#pragma omp taskwait + } break; + } + for (;;) +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} + for (;;) { +#pragma omp taskwait + } +label: +#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}} +label1 : { +#pragma omp taskwait +} + + return tmain(argc); +} diff --git a/test/OpenMP/taskyield_ast_print.cpp b/test/OpenMP/taskyield_ast_print.cpp new file mode 100644 index 000000000000..4c3ca47cba45 --- /dev/null +++ b/test/OpenMP/taskyield_ast_print.cpp @@ -0,0 +1,32 @@ +// 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> +T tmain(T argc) { + static T a; +#pragma omp taskyield + return a + argc; +} +// CHECK: static int a; +// CHECK-NEXT: #pragma omp taskyield +// CHECK: static char a; +// CHECK-NEXT: #pragma omp taskyield +// CHECK: static T a; +// CHECK-NEXT: #pragma omp taskyield + +int main(int argc, char **argv) { + static int a; +// CHECK: static int a; +#pragma omp taskyield + // CHECK-NEXT: #pragma omp taskyield + return tmain(argc) + tmain(argv[0][0]) + a; +} + +#endif diff --git a/test/OpenMP/taskyield_messages.cpp b/test/OpenMP/taskyield_messages.cpp new file mode 100644 index 000000000000..7c355595d7ac --- /dev/null +++ b/test/OpenMP/taskyield_messages.cpp @@ -0,0 +1,110 @@ +// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s + +template <class T> +T tmain(T argc) { +#pragma omp taskyield + ; +#pragma omp taskyield untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp taskyield'}} +#pragma omp taskyield unknown // expected-warning {{extra tokens at the end of '#pragma omp taskyield' are ignored}} + if (argc) +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + if (argc) { +#pragma omp taskyield + } + while (argc) +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + while (argc) { +#pragma omp taskyield + } + do +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp taskyield + } while (argc); + switch (argc) +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp taskyield + } + switch (argc) { +#pragma omp taskyield + case 1: +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + break; + default: { +#pragma omp taskyield + } break; + } + for (;;) +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + for (;;) { +#pragma omp taskyield + } +label: +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} +label1 : { +#pragma omp taskyield +} + + return T(); +} + +int main(int argc, char **argv) { +#pragma omp taskyield + ; +#pragma omp taskyield untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp taskyield'}} +#pragma omp taskyield unknown // expected-warning {{extra tokens at the end of '#pragma omp taskyield' are ignored}} + if (argc) +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + if (argc) { +#pragma omp taskyield + } + while (argc) +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + while (argc) { +#pragma omp taskyield + } + do +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + while (argc) + ; + do { +#pragma omp taskyield + } while (argc); + switch (argc) +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + switch (argc) + case 1: +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + switch (argc) + case 1: { +#pragma omp taskyield + } + switch (argc) { +#pragma omp taskyield + case 1: +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + break; + default: { +#pragma omp taskyield + } break; + } + for (;;) +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} + for (;;) { +#pragma omp taskyield + } +label: +#pragma omp taskyield // expected-error {{'#pragma omp taskyield' cannot be an immediate substatement}} +label1 : { +#pragma omp taskyield +} + + return tmain(argc); +} diff --git a/test/OpenMP/threadprivate_ast_print.cpp b/test/OpenMP/threadprivate_ast_print.cpp index 72bf6f4077eb..4d0d40e213f2 100644 --- a/test/OpenMP/threadprivate_ast_print.cpp +++ b/test/OpenMP/threadprivate_ast_print.cpp @@ -1,9 +1,7 @@ -// RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s -// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s -// RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print +// 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 // expected-no-diagnostics -// FIXME: This test has been crashing since r186647. -// REQUIRES: disabled #ifndef HEADER #define HEADER @@ -28,9 +26,16 @@ int a, b; #pragma omp threadprivate(d, b) // CHECK-NEXT: #pragma omp threadprivate(d,b) +template <class T> +struct ST { + static T m; + #pragma omp threadprivate(m) +}; + template <class T> T foo() { static T v; #pragma omp threadprivate(v) + v = ST<T>::m; return v; } //CHECK: template <class T = int> int foo() { diff --git a/test/OpenMP/threadprivate_messages.cpp b/test/OpenMP/threadprivate_messages.cpp index 4858549a7038..491f30ad041f 100644 --- a/test/OpenMP/threadprivate_messages.cpp +++ b/test/OpenMP/threadprivate_messages.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -ferror-limit 100 %s +// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp=libiomp5 -ferror-limit 100 %s #pragma omp threadprivate // expected-error {{expected '(' after 'threadprivate'}} #pragma omp threadprivate( // expected-error {{expected identifier}} expected-error {{expected ')'}} expected-note {{to match this '('}} @@ -24,13 +24,22 @@ int foo() { // expected-note {{declared here}} return (a); } +#pragma omp threadprivate (a) ( +// expected-error@-1 {{'#pragma omp threadprivate' must precede all references to variable 'a'}} expected-warning@-1 {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} +#pragma omp threadprivate (a) [ // expected-error {{'#pragma omp threadprivate' must precede all references to variable 'a'}} expected-warning {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} +#pragma omp threadprivate (a) { // expected-error {{'#pragma omp threadprivate' must precede all references to variable 'a'}} expected-warning {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} +#pragma omp threadprivate (a) ) // expected-error {{'#pragma omp threadprivate' must precede all references to variable 'a'}} expected-warning {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} +#pragma omp threadprivate (a) ] // expected-error {{'#pragma omp threadprivate' must precede all references to variable 'a'}} expected-warning {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} +#pragma omp threadprivate (a) } // expected-error {{'#pragma omp threadprivate' must precede all references to variable 'a'}} expected-warning {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} #pragma omp threadprivate a // expected-error {{expected '(' after 'threadprivate'}} #pragma omp threadprivate(d // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{'#pragma omp threadprivate' must precede all references to variable 'd'}} #pragma omp threadprivate(d)) // expected-error {{'#pragma omp threadprivate' must precede all references to variable 'd'}} expected-warning {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} int x, y; #pragma omp threadprivate(x)) // expected-warning {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} -#pragma omp threadprivate(y)), // expected-warning {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} -#pragma omp threadprivate(a,d) // expected-error {{'#pragma omp threadprivate' must precede all references to variable 'a'}} expected-error {{'#pragma omp threadprivate' must precede all references to variable 'd'}} +#pragma omp threadprivate(y)), +// expected-warning@-1 {{extra tokens at the end of '#pragma omp threadprivate' are ignored}} +#pragma omp threadprivate(a,d) +// expected-error@-1 {{'#pragma omp threadprivate' must precede all references to variable 'a'}} expected-error@-1 {{'#pragma omp threadprivate' must precede all references to variable 'd'}} #pragma omp threadprivate(d.a) // expected-error {{expected identifier}} #pragma omp threadprivate((float)a) // expected-error {{expected unqualified-id}} int foa; // expected-note {{'foa' declared here}} @@ -46,17 +55,17 @@ extern IncompleteSt e; int &f = a; // expected-note {{'f' defined here}} #pragma omp threadprivate (f) // expected-error {{arguments of '#pragma omp threadprivate' cannot be of reference type 'int &'}} -class Class { +class TestClass { private: int a; // expected-note {{declared here}} static int b; // expected-note {{'b' declared here}} - Class() : a(0){} + TestClass() : a(0){} public: - Class (int aaa) : a(aaa) {} + TestClass (int aaa) : a(aaa) {} #pragma omp threadprivate (b, a) // expected-error {{'a' is not a global variable, static local variable or static data member}} } g(10); #pragma omp threadprivate (b) // expected-error {{use of undeclared identifier 'b'}} -#pragma omp threadprivate (Class::b) // expected-error {{'#pragma omp threadprivate' must appear in the scope of the 'Class::b' variable declaration}} +#pragma omp threadprivate (TestClass::b) // expected-error {{'#pragma omp threadprivate' must appear in the scope of the 'TestClass::b' variable declaration}} #pragma omp threadprivate (g) namespace ns { @@ -90,19 +99,21 @@ static __thread int t; // expected-note {{'t' defined here}} int o; // expected-note {{candidate found by name lookup is 'o'}} #pragma omp threadprivate (o) namespace { -int o; // expected-note {{candidate found by name lookup is '<anonymous namespace>::o'}} +int o; // expected-note {{candidate found by name lookup is '(anonymous namespace)::o'}} #pragma omp threadprivate (o) -#pragma omp threadprivate (o) // expected-error {{'#pragma omp threadprivate' must precede all references to variable '<anonymous namespace>::o'}} +#pragma omp threadprivate (o) // expected-error {{'#pragma omp threadprivate' must precede all references to variable '(anonymous namespace)::o'}} } #pragma omp threadprivate (o) // expected-error {{reference to 'o' is ambiguous}} #pragma omp threadprivate (::o) // expected-error {{'#pragma omp threadprivate' must precede all references to variable 'o'}} int main(int argc, char **argv) { // expected-note {{'argc' defined here}} - int x, y = argc; // expected-note {{'y' defined here}} + int x, y = argc; // expected-note 2 {{'y' defined here}} static double d1; static double d2; static double d3; // expected-note {{'d3' defined here}} + static TestClass LocalClass(y); // expected-error {{variable with local storage in initial value of threadprivate variable}} +#pragma omp threadprivate(LocalClass) d.a = a; d2++; |